Vendor dependencies

notes-service/vendor/nix/test/sys/mod.rs

@@ -0,0 +1,84 @@
+mod test_signal;
+
+// NOTE: DragonFly lacks a kernel-level implementation of Posix AIO as of
+// this writing. There is an user-level implementation, but whether aio
+// works or not heavily depends on which pthread implementation is chosen
+// by the user at link time. For this reason we do not want to run aio test
+// cases on DragonFly.
+#[cfg(any(
+    target_os = "freebsd",
+    apple_targets,
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "netbsd"
+))]
+mod test_aio;
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku",
+    target_os = "hurd"
+)))]
+mod test_ioctl;
+#[cfg(not(target_os = "redox"))]
+mod test_mman;
+#[cfg(not(target_os = "redox"))]
+mod test_select;
+#[cfg(target_os = "linux")]
+mod test_signalfd;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+mod test_socket;
+#[cfg(not(any(target_os = "redox")))]
+mod test_sockopt;
+mod test_stat;
+#[cfg(linux_android)]
+mod test_sysinfo;
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
+mod test_termios;
+mod test_uio;
+mod test_wait;
+
+#[cfg(linux_android)]
+mod test_epoll;
+#[cfg(target_os = "linux")]
+mod test_fanotify;
+#[cfg(target_os = "linux")]
+mod test_inotify;
+mod test_pthread;
+
+#[cfg(any(linux_android, freebsdlike, netbsdlike, apple_targets))]
+mod test_ptrace;
+#[cfg(linux_android)]
+mod test_timerfd;
+
+#[cfg(all(
+    any(
+        target_os = "freebsd",
+        solarish,
+        target_os = "linux",
+        target_os = "netbsd"
+    ),
+    feature = "time",
+    feature = "signal"
+))]
+mod test_timer;
+
+#[cfg(bsd)]
+mod test_event;
+mod test_statvfs;
+mod test_time;
+mod test_utsname;
+
+#[cfg(any(linux_android, freebsdlike, apple_targets, target_os = "openbsd"))]
+mod test_statfs;
+
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    solarish,
+    target_os = "haiku"
+)))]
+mod test_resource;

notes-service/vendor/nix/test/sys/test_aio.rs

@@ -0,0 +1,685 @@
+use std::{
+    io::{Read, Seek, Write},
+    ops::Deref,
+    os::unix::io::{AsFd, AsRawFd, BorrowedFd},
+    pin::Pin,
+    sync::atomic::{AtomicBool, Ordering},
+    thread, time,
+};
+
+use libc::c_int;
+use nix::{
+    errno::*,
+    sys::{
+        aio::*,
+        signal::{
+            sigaction, SaFlags, SigAction, SigHandler, SigSet, SigevNotify,
+            Signal,
+        },
+        time::{TimeSpec, TimeValLike},
+    },
+};
+use tempfile::tempfile;
+
+pub static SIGNALED: AtomicBool = AtomicBool::new(false);
+
+extern "C" fn sigfunc(_: c_int) {
+    SIGNALED.store(true, Ordering::Relaxed);
+}
+
+// Helper that polls an AioCb for completion or error
+macro_rules! poll_aio {
+    ($aiocb: expr) => {
+        loop {
+            let err = $aiocb.as_mut().error();
+            if err != Err(Errno::EINPROGRESS) {
+                break err;
+            };
+            thread::sleep(time::Duration::from_millis(10));
+        }
+    };
+}
+
+mod aio_fsync {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let aiocb = AioFsync::new(
+            f.as_fd(),
+            AioFsyncMode::O_SYNC,
+            42,
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(AioFsyncMode::O_SYNC, aiocb.mode());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    /// `AioFsync::submit` should not modify the `AioCb` object if
+    /// `libc::aio_fsync` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg_attr(any(target_os = "android", target_os = "linux"), ignore)]
+    fn error() {
+        use std::mem;
+
+        const INITIAL: &[u8] = b"abcdef123456";
+        // Create an invalid AioFsyncMode
+        let mode = unsafe { mem::transmute::<i32, AioFsyncMode>(666) };
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiof =
+            Box::pin(AioFsync::new(f.as_fd(), mode, 0, SigevNotify::SigevNone));
+        let err = aiof.as_mut().submit();
+        err.expect_err("assertion failed");
+    }
+
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiof = Box::pin(AioFsync::new(
+            f.as_fd(),
+            AioFsyncMode::O_SYNC,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiof.as_mut().submit().unwrap();
+        poll_aio!(&mut aiof).unwrap();
+        aiof.as_mut().aio_return().unwrap();
+    }
+}
+
+mod aio_read {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let mut rbuf = vec![0; 4];
+        let aiocb = AioRead::new(
+            f.as_fd(),
+            2, //offset
+            &mut rbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn cancel() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let fd = f.as_fd();
+        let mut aior =
+            Box::pin(AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone));
+        aior.as_mut().submit().unwrap();
+
+        aior.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aior);
+        let _ = aior.as_mut().aio_return();
+    }
+
+    /// `AioRead::submit` should not modify the `AioCb` object if
+    /// `libc::aio_read` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg(any(target_os = "freebsd", apple_targets))]
+    fn error() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aior = Box::pin(AioRead::new(
+            f.as_fd(),
+            -1, //an invalid offset
+            &mut rbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aior.as_mut().submit().expect_err("assertion failed");
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior = Box::pin(AioRead::new(
+                fd,
+                2,
+                &mut rbuf,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref());
+    }
+
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior =
+                AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone);
+            let mut aior = unsafe { Pin::new_unchecked(&mut aior) };
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref());
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_readv {
+    use std::io::IoSliceMut;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 8];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        let aiocb = AioReadv::new(
+            f.as_fd(),
+            2, //offset
+            &mut rbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 2];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        const EXPECT0: &[u8] = b"cdef";
+        const EXPECT1: &[u8] = b"12";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior = Box::pin(AioReadv::new(
+                fd,
+                2,
+                &mut rbufs,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(
+                aior.as_mut().aio_return().unwrap(),
+                EXPECT0.len() + EXPECT1.len()
+            );
+        }
+        assert_eq!(&EXPECT0, &rbuf0);
+        assert_eq!(&EXPECT1, &rbuf1);
+    }
+}
+
+mod aio_write {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let wbuf = vec![0; 4];
+        let aiocb = AioWrite::new(
+            f.as_fd(),
+            2, //offset
+            &wbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(target_env = "musl", ignore)]
+    fn cancel() {
+        let wbuf: &[u8] = b"CDEF";
+
+        let f = tempfile().unwrap();
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_fd(),
+            0,
+            wbuf,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().unwrap();
+        let err = aiow.as_mut().error();
+        assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+
+        aiow.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aiow);
+        let _ = aiow.as_mut().aio_return();
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = Box::pin(AioWrite::new(
+                f.as_fd(),
+                2,
+                &wbuf,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = AioWrite::new(
+                f.as_fd(),
+                2, //offset
+                &wbuf,
+                0, //priority
+                SigevNotify::SigevNone,
+            );
+            let mut aiow = unsafe { Pin::new_unchecked(&mut aiow) };
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+
+    /// `AioWrite::write` should not modify the `AioCb` object if
+    /// `libc::aio_write` returns an error.
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg_attr(any(target_os = "android", target_os = "linux"), ignore)]
+    fn error() {
+        // Not I/O safe!  Deliberately create an invalid fd.
+        let fd = unsafe { BorrowedFd::borrow_raw(666) };
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut aiow = Box::pin(AioWrite::new(
+            fd,
+            0, //offset
+            &wbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().expect_err("assertion failed");
+        // Dropping the AioWrite at this point should not panic
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_writev {
+    use std::io::IoSlice;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let wbuf0 = vec![0; 4];
+        let wbuf1 = vec![0; 8];
+        let wbufs = [IoSlice::new(&wbuf0), IoSlice::new(&wbuf1)];
+        let aiocb = AioWritev::new(
+            f.as_fd(),
+            2, //offset
+            &wbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf0 = b"BC";
+        let wbuf1 = b"DEF";
+        let wbufs = [IoSlice::new(wbuf0), IoSlice::new(wbuf1)];
+        let wlen = wbuf0.len() + wbuf1.len();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"aBCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = Box::pin(AioWritev::new(
+                f.as_fd(),
+                1,
+                &wbufs,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wlen);
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+}
+
+// Test an aio operation with completion delivered by a signal
+#[test]
+#[cfg_attr(
+    any(
+        all(target_env = "musl", target_arch = "x86_64"),
+        target_arch = "mips",
+        target_arch = "mips32r6",
+        target_arch = "mips64",
+        target_arch = "mips64r6"
+    ),
+    ignore
+)]
+fn sigev_signal() {
+    let _m = crate::SIGNAL_MTX.lock();
+    let sa = SigAction::new(
+        SigHandler::Handler(sigfunc),
+        SaFlags::SA_RESETHAND,
+        SigSet::empty(),
+    );
+    SIGNALED.store(false, Ordering::Relaxed);
+    unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();
+
+    const INITIAL: &[u8] = b"abcdef123456";
+    const WBUF: &[u8] = b"CDEF";
+    let mut rbuf = Vec::new();
+    const EXPECT: &[u8] = b"abCDEF123456";
+
+    let mut f = tempfile().unwrap();
+    f.write_all(INITIAL).unwrap();
+    {
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_fd(),
+            2, //offset
+            WBUF,
+            0, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 0, //TODO: validate in sigfunc
+            },
+        ));
+        aiow.as_mut().submit().unwrap();
+        while !SIGNALED.load(Ordering::Relaxed) {
+            thread::sleep(time::Duration::from_millis(10));
+        }
+
+        assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+    }
+
+    f.rewind().unwrap();
+    let len = f.read_to_end(&mut rbuf).unwrap();
+    assert_eq!(len, EXPECT.len());
+    assert_eq!(rbuf, EXPECT);
+}
+
+// Tests using aio_cancel_all for all outstanding IOs.
+#[test]
+#[cfg_attr(target_env = "musl", ignore)]
+fn test_aio_cancel_all() {
+    let wbuf: &[u8] = b"CDEF";
+
+    let f = tempfile().unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        0, //offset
+        wbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
+    let err = aiocb.as_mut().error();
+    assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+
+    aio_cancel_all(f.as_fd()).unwrap();
+
+    // Wait for aiocb to complete, but don't care whether it succeeded
+    let _ = poll_aio!(&mut aiocb);
+    let _ = aiocb.as_mut().aio_return();
+}
+
+#[test]
+fn test_aio_suspend() {
+    const INITIAL: &[u8] = b"abcdef123456";
+    const WBUF: &[u8] = b"CDEFG";
+    let timeout = TimeSpec::seconds(10);
+    let mut rbuf = vec![0; 4];
+    let rlen = rbuf.len();
+    let mut f = tempfile().unwrap();
+    f.write_all(INITIAL).unwrap();
+
+    let mut wcb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+
+    let mut rcb = Box::pin(AioRead::new(
+        f.as_fd(),
+        8, //offset
+        &mut rbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    wcb.as_mut().submit().unwrap();
+    rcb.as_mut().submit().unwrap();
+    loop {
+        {
+            let cbbuf = [
+                &*wcb as &dyn AsRef<libc::aiocb>,
+                &*rcb as &dyn AsRef<libc::aiocb>,
+            ];
+            let r = aio_suspend(&cbbuf[..], Some(timeout));
+            match r {
+                Err(Errno::EINTR) => continue,
+                Err(e) => panic!("aio_suspend returned {e:?}"),
+                Ok(_) => (),
+            };
+        }
+        if rcb.as_mut().error() != Err(Errno::EINPROGRESS)
+            && wcb.as_mut().error() != Err(Errno::EINPROGRESS)
+        {
+            break;
+        }
+    }
+
+    assert_eq!(wcb.as_mut().aio_return().unwrap(), WBUF.len());
+    assert_eq!(rcb.as_mut().aio_return().unwrap(), rlen);
+}
+
+/// aio_suspend relies on casting Rust Aio* struct pointers to libc::aiocb
+/// pointers.  This test ensures that such casts are valid.
+#[test]
+fn casting() {
+    let sev = SigevNotify::SigevNone;
+    // Only safe because we'll never await the futures
+    let fd = unsafe { BorrowedFd::borrow_raw(666) };
+    let aiof = AioFsync::new(fd, AioFsyncMode::O_SYNC, 0, sev);
+    assert_eq!(
+        aiof.as_ref() as *const libc::aiocb,
+        &aiof as *const AioFsync as *const libc::aiocb
+    );
+
+    let mut rbuf = [];
+    let aior = AioRead::new(fd, 0, &mut rbuf, 0, sev);
+    assert_eq!(
+        aior.as_ref() as *const libc::aiocb,
+        &aior as *const AioRead as *const libc::aiocb
+    );
+
+    let wbuf = [];
+    let aiow = AioWrite::new(fd, 0, &wbuf, 0, sev);
+    assert_eq!(
+        aiow.as_ref() as *const libc::aiocb,
+        &aiow as *const AioWrite as *const libc::aiocb
+    );
+}
+
+#[cfg(target_os = "freebsd")]
+#[test]
+fn casting_vectored() {
+    use std::io::{IoSlice, IoSliceMut};
+
+    let sev = SigevNotify::SigevNone;
+
+    let mut rbuf = [];
+    let mut rbufs = [IoSliceMut::new(&mut rbuf)];
+    // Only safe because we'll never await the futures
+    let fd = unsafe { BorrowedFd::borrow_raw(666) };
+    let aiorv = AioReadv::new(fd, 0, &mut rbufs[..], 0, sev);
+    assert_eq!(
+        aiorv.as_ref() as *const libc::aiocb,
+        &aiorv as *const AioReadv as *const libc::aiocb
+    );
+
+    let wbuf = [];
+    let wbufs = [IoSlice::new(&wbuf)];
+    let aiowv = AioWritev::new(fd, 0, &wbufs, 0, sev);
+    assert_eq!(
+        aiowv.as_ref() as *const libc::aiocb,
+        &aiowv as *const AioWritev as *const libc::aiocb
+    );
+}

notes-service/vendor/nix/test/sys/test_aio_drop.rs

@@ -0,0 +1,34 @@
+// Test dropping an AioCb that hasn't yet finished.
+// This must happen in its own process, because on OSX this test seems to hose
+// the AIO subsystem and causes subsequent tests to fail
+#[test]
+#[should_panic(expected = "Dropped an in-progress AioCb")]
+#[cfg(all(
+    not(target_env = "musl"),
+    not(target_env = "uclibc"),
+    any(
+        target_os = "linux",
+        apple_targets,
+        target_os = "freebsd",
+        target_os = "netbsd"
+    )
+))]
+fn test_drop() {
+    use nix::sys::aio::*;
+    use nix::sys::signal::*;
+    use std::os::unix::io::AsFd;
+    use tempfile::tempfile;
+
+    const WBUF: &[u8] = b"CDEF";
+
+    let f = tempfile().unwrap();
+    f.set_len(6).unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
+}

notes-service/vendor/nix/test/sys/test_epoll.rs

@@ -0,0 +1,26 @@
+#![allow(deprecated)]
+
+use nix::errno::Errno;
+use nix::sys::epoll::{epoll_create1, epoll_ctl};
+use nix::sys::epoll::{EpollCreateFlags, EpollEvent, EpollFlags, EpollOp};
+
+#[test]
+pub fn test_epoll_errno() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let result = epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None);
+    result.expect_err("assertion failed");
+    assert_eq!(result.unwrap_err(), Errno::ENOENT);
+
+    let result = epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, None);
+    result.expect_err("assertion failed");
+    assert_eq!(result.unwrap_err(), Errno::EINVAL);
+}
+
+#[test]
+pub fn test_epoll_ctl() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let mut event =
+        EpollEvent::new(EpollFlags::EPOLLIN | EpollFlags::EPOLLERR, 1);
+    epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, &mut event).unwrap();
+    epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None).unwrap();
+}

notes-service/vendor/nix/test/sys/test_event.rs

@@ -0,0 +1,41 @@
+use libc::intptr_t;
+use nix::sys::event::{EventFilter, EventFlag, FilterFlag, KEvent};
+
+#[test]
+fn test_struct_kevent() {
+    use std::mem;
+
+    let udata: intptr_t = 12345;
+    let data: intptr_t = 0x1337;
+
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        data,
+        udata,
+    );
+    assert_eq!(0xdead_beef, actual.ident());
+    assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
+    assert_eq!(libc::EV_ONESHOT | libc::EV_ADD, actual.flags().bits());
+    assert_eq!(libc::NOTE_CHILD | libc::NOTE_EXIT, actual.fflags().bits());
+    assert_eq!(data, actual.data());
+    assert_eq!(udata, actual.udata());
+    assert_eq!(mem::size_of::<libc::kevent>(), mem::size_of::<KEvent>());
+}
+
+#[test]
+fn test_kevent_filter() {
+    let udata: intptr_t = 12345;
+
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        0x1337,
+        udata,
+    );
+    assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
+}

notes-service/vendor/nix/test/sys/test_fanotify.rs

@@ -0,0 +1,219 @@
+use crate::*;
+use nix::errno::Errno;
+use nix::sys::fanotify::{
+    EventFFlags, Fanotify, FanotifyResponse, InitFlags, MarkFlags, MaskFlags,
+    Response,
+};
+use std::fs::{read_link, read_to_string, File, OpenOptions};
+use std::io::ErrorKind;
+use std::io::{Read, Write};
+use std::os::fd::AsRawFd;
+use std::thread;
+
+#[test]
+/// Run fanotify tests sequentially to avoid tmp files races
+pub fn test_fanotify() {
+    require_capability!("test_fanotify", CAP_SYS_ADMIN);
+
+    test_fanotify_notifications();
+    test_fanotify_responses();
+    test_fanotify_overflow();
+}
+
+fn test_fanotify_notifications() {
+    let group =
+        Fanotify::init(InitFlags::FAN_CLASS_NOTIF, EventFFlags::O_RDONLY)
+            .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN | MaskFlags::FAN_MODIFY | MaskFlags::FAN_CLOSE,
+            None,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    // modify test file
+    {
+        let mut f = OpenOptions::new().write(true).open(&tempfile).unwrap();
+        f.write_all(b"hello").unwrap();
+    }
+
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(
+        event.mask(),
+        MaskFlags::FAN_OPEN
+            | MaskFlags::FAN_MODIFY
+            | MaskFlags::FAN_CLOSE_WRITE
+    );
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+
+    // read test file
+    {
+        let mut f = File::open(&tempfile).unwrap();
+        let mut s = String::new();
+        f.read_to_string(&mut s).unwrap();
+    }
+
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(
+        event.mask(),
+        MaskFlags::FAN_OPEN | MaskFlags::FAN_CLOSE_NOWRITE
+    );
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+}
+
+fn test_fanotify_responses() {
+    let group =
+        Fanotify::init(InitFlags::FAN_CLASS_CONTENT, EventFFlags::O_RDONLY)
+            .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN_PERM,
+            None,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    let file_thread = thread::spawn({
+        let tempfile = tempfile.clone();
+
+        move || {
+            // first open, should fail
+            let Err(e) = File::open(&tempfile) else {
+                panic!("The first open should fail");
+            };
+            assert_eq!(e.kind(), ErrorKind::PermissionDenied);
+
+            // second open, should succeed
+            File::open(&tempfile).unwrap();
+        }
+    });
+
+    // Deny the first open try
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(event.mask(), MaskFlags::FAN_OPEN_PERM);
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+    group
+        .write_response(FanotifyResponse::new(*fd, Response::FAN_DENY))
+        .unwrap();
+
+    // Allow the second open try
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(event.mask(), MaskFlags::FAN_OPEN_PERM);
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+    group
+        .write_response(FanotifyResponse::new(*fd, Response::FAN_ALLOW))
+        .unwrap();
+
+    file_thread.join().unwrap();
+}
+
+fn test_fanotify_overflow() {
+    let max_events: usize =
+        read_to_string("/proc/sys/fs/fanotify/max_queued_events")
+            .unwrap()
+            .trim()
+            .parse()
+            .unwrap();
+
+    // make sure the kernel is configured with the default value,
+    // just so this test doesn't run forever
+    assert_eq!(max_events, 16384);
+
+    let group = Fanotify::init(
+        InitFlags::FAN_CLASS_NOTIF
+            | InitFlags::FAN_REPORT_TID
+            | InitFlags::FAN_NONBLOCK,
+        EventFFlags::O_RDONLY,
+    )
+    .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN,
+            None,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    thread::scope(|s| {
+        // perform 10 more events to demonstrate some will be dropped
+        for _ in 0..(max_events + 10) {
+            s.spawn(|| {
+                File::open(&tempfile).unwrap();
+            });
+        }
+    });
+
+    // flush the queue until it's empty
+    let mut n = 0;
+    let mut last_event = None;
+    loop {
+        match group.read_events() {
+            Ok(events) => {
+                n += events.len();
+                if let Some(event) = events.last() {
+                    last_event = Some(event.mask());
+                }
+            }
+            Err(e) if e == Errno::EWOULDBLOCK => break,
+            Err(e) => panic!("{e:?}"),
+        }
+    }
+
+    // make sure we read all we expected.
+    // the +1 is for the overflow event.
+    assert_eq!(n, max_events + 1);
+    assert_eq!(last_event, Some(MaskFlags::FAN_Q_OVERFLOW));
+}

notes-service/vendor/nix/test/sys/test_inotify.rs

@@ -0,0 +1,65 @@
+use nix::errno::Errno;
+use nix::sys::inotify::{AddWatchFlags, InitFlags, Inotify};
+use std::ffi::OsString;
+use std::fs::{rename, File};
+
+#[test]
+pub fn test_inotify() {
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
+
+    let events = instance.read_events();
+    assert_eq!(events.unwrap_err(), Errno::EAGAIN);
+
+    File::create(tempdir.path().join("test")).unwrap();
+
+    let events = instance.read_events().unwrap();
+    assert_eq!(events[0].name, Some(OsString::from("test")));
+}
+
+#[test]
+pub fn test_inotify_multi_events() {
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
+
+    let events = instance.read_events();
+    assert_eq!(events.unwrap_err(), Errno::EAGAIN);
+
+    File::create(tempdir.path().join("test")).unwrap();
+    rename(tempdir.path().join("test"), tempdir.path().join("test2")).unwrap();
+
+    // Now there should be 5 events in queue:
+    //   - IN_CREATE on test
+    //   - IN_OPEN on test
+    //   - IN_CLOSE_WRITE on test
+    //   - IN_MOVED_FROM on test with a cookie
+    //   - IN_MOVED_TO on test2 with the same cookie
+
+    let events = instance.read_events().unwrap();
+    assert_eq!(events.len(), 5);
+
+    assert_eq!(events[0].mask, AddWatchFlags::IN_CREATE);
+    assert_eq!(events[0].name, Some(OsString::from("test")));
+
+    assert_eq!(events[1].mask, AddWatchFlags::IN_OPEN);
+    assert_eq!(events[1].name, Some(OsString::from("test")));
+
+    assert_eq!(events[2].mask, AddWatchFlags::IN_CLOSE_WRITE);
+    assert_eq!(events[2].name, Some(OsString::from("test")));
+
+    assert_eq!(events[3].mask, AddWatchFlags::IN_MOVED_FROM);
+    assert_eq!(events[3].name, Some(OsString::from("test")));
+
+    assert_eq!(events[4].mask, AddWatchFlags::IN_MOVED_TO);
+    assert_eq!(events[4].name, Some(OsString::from("test2")));
+
+    assert_eq!(events[3].cookie, events[4].cookie);
+}

notes-service/vendor/nix/test/sys/test_ioctl.rs

@@ -0,0 +1,383 @@
+#![allow(dead_code)]
+
+// Simple tests to ensure macro generated fns compile
+ioctl_none_bad!(do_bad, 0x1234);
+ioctl_read_bad!(do_bad_read, 0x1234, u16);
+ioctl_write_int_bad!(do_bad_write_int, 0x1234);
+ioctl_write_ptr_bad!(do_bad_write_ptr, 0x1234, u8);
+ioctl_readwrite_bad!(do_bad_readwrite, 0x1234, u32);
+ioctl_none!(do_none, 0, 0);
+ioctl_read!(read_test, 0, 0, u32);
+ioctl_write_int!(write_ptr_int, 0, 0);
+ioctl_write_ptr!(write_ptr_u8, 0, 0, u8);
+ioctl_write_ptr!(write_ptr_u32, 0, 0, u32);
+ioctl_write_ptr!(write_ptr_u64, 0, 0, u64);
+ioctl_readwrite!(readwrite_test, 0, 0, u64);
+ioctl_read_buf!(readbuf_test, 0, 0, u32);
+const SPI_IOC_MAGIC: u8 = b'k';
+const SPI_IOC_MESSAGE: u8 = 0;
+ioctl_write_buf!(writebuf_test_consts, SPI_IOC_MAGIC, SPI_IOC_MESSAGE, u8);
+ioctl_write_buf!(writebuf_test_u8, 0, 0, u8);
+ioctl_write_buf!(writebuf_test_u32, 0, 0, u32);
+ioctl_write_buf!(writebuf_test_u64, 0, 0, u64);
+ioctl_readwrite_buf!(readwritebuf_test, 0, 0, u32);
+
+// See C code for source of values for op calculations (does NOT work for mips/powerpc):
+// https://gist.github.com/posborne/83ea6880770a1aef332e
+//
+// TODO:  Need a way to compute these constants at test time.  Using precomputed
+// values is fragile and needs to be maintained.
+
+#[cfg(linux_android)]
+mod linux {
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_none() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_none!(b'q', 10) as u32, 0x2000_710A);
+            assert_eq!(request_code_none!(b'a', 255) as u32, 0x2000_61FF);
+        } else {
+            assert_eq!(request_code_none!(b'q', 10) as u32, 0x0000_710A);
+            assert_eq!(request_code_none!(b'a', 255) as u32, 0x0000_61FF);
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_write() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_write!(b'z', 10, 1) as u32, 0x8001_7A0A);
+            assert_eq!(request_code_write!(b'z', 10, 512) as u32, 0x8200_7A0A);
+        } else {
+            assert_eq!(request_code_write!(b'z', 10, 1) as u32, 0x4001_7A0A);
+            assert_eq!(request_code_write!(b'z', 10, 512) as u32, 0x4200_7A0A);
+        }
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_write_64() {
+        if cfg!(any(
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
+        } else {
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_read() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_read!(b'z', 10, 1) as u32, 0x4001_7A0A);
+            assert_eq!(request_code_read!(b'z', 10, 512) as u32, 0x4200_7A0A);
+        } else {
+            assert_eq!(request_code_read!(b'z', 10, 1) as u32, 0x8001_7A0A);
+            assert_eq!(request_code_read!(b'z', 10, 512) as u32, 0x8200_7A0A);
+        }
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_64() {
+        if cfg!(any(
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
+        } else {
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_read_write() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1) as u32, 0xC001_7A0A);
+        assert_eq!(request_code_readwrite!(b'z', 10, 512) as u32, 0xC200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_write_64() {
+        assert_eq!(
+            request_code_readwrite!(b'z', 10, 1u64 << 32) as u32,
+            0xC000_7A0A
+        );
+    }
+}
+
+#[cfg(bsd)]
+mod bsd {
+    #[test]
+    fn test_op_none() {
+        assert_eq!(request_code_none!(b'q', 10), 0x2000_710A);
+        assert_eq!(request_code_none!(b'a', 255), 0x2000_61FF);
+    }
+
+    #[cfg(freebsdlike)]
+    #[test]
+    fn test_op_write_int() {
+        assert_eq!(request_code_write_int!(b'v', 4), 0x2004_7604);
+        assert_eq!(request_code_write_int!(b'p', 2), 0x2004_7002);
+    }
+
+    #[test]
+    fn test_op_write() {
+        assert_eq!(request_code_write!(b'z', 10, 1), 0x8001_7A0A);
+        assert_eq!(request_code_write!(b'z', 10, 512), 0x8200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_write_64() {
+        assert_eq!(request_code_write!(b'z', 10, 1u64 << 32), 0x8000_7A0A);
+    }
+
+    #[test]
+    fn test_op_read() {
+        assert_eq!(request_code_read!(b'z', 10, 1), 0x4001_7A0A);
+        assert_eq!(request_code_read!(b'z', 10, 512), 0x4200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_64() {
+        assert_eq!(request_code_read!(b'z', 10, 1u64 << 32), 0x4000_7A0A);
+    }
+
+    #[test]
+    fn test_op_read_write() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1), 0xC001_7A0A);
+        assert_eq!(request_code_readwrite!(b'z', 10, 512), 0xC200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_write_64() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1u64 << 32), 0xC000_7A0A);
+    }
+}
+
+#[cfg(linux_android)]
+mod linux_ioctls {
+    use std::mem;
+    use std::os::unix::io::AsRawFd;
+
+    use libc::{termios, TCGETS, TCSBRK, TCSETS, TIOCNXCL};
+    use tempfile::tempfile;
+
+    use nix::errno::Errno;
+
+    ioctl_none_bad!(tiocnxcl, TIOCNXCL);
+    #[test]
+    fn test_ioctl_none_bad() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tiocnxcl(file.as_raw_fd()) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_read_bad!(tcgets, TCGETS, termios);
+    #[test]
+    fn test_ioctl_read_bad() {
+        let file = tempfile().unwrap();
+        let mut termios = unsafe { mem::zeroed() };
+        let res = unsafe { tcgets(file.as_raw_fd(), &mut termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_int_bad!(tcsbrk, TCSBRK);
+    #[test]
+    fn test_ioctl_write_int_bad() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tcsbrk(file.as_raw_fd(), 0) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_ptr_bad!(tcsets, TCSETS, termios);
+    #[test]
+    fn test_ioctl_write_ptr_bad() {
+        let file = tempfile().unwrap();
+        let termios: termios = unsafe { mem::zeroed() };
+        let res = unsafe { tcsets(file.as_raw_fd(), &termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_readwrite_bad`
+
+    // From linux/videodev2.h
+    ioctl_none!(log_status, b'V', 70);
+    #[test]
+    fn test_ioctl_none() {
+        let file = tempfile().unwrap();
+        let res = unsafe { log_status(file.as_raw_fd()) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    #[repr(C)]
+    pub struct v4l2_audio {
+        index: u32,
+        name: [u8; 32],
+        capability: u32,
+        mode: u32,
+        reserved: [u32; 2],
+    }
+
+    // From linux/videodev2.h
+    ioctl_write_ptr!(s_audio, b'V', 34, v4l2_audio);
+    #[test]
+    fn test_ioctl_write_ptr() {
+        let file = tempfile().unwrap();
+        let data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { s_audio(file.as_raw_fd(), &data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/net/bluetooth/hci_sock.h
+    const HCI_IOC_MAGIC: u8 = b'H';
+    const HCI_IOC_HCIDEVUP: u8 = 201;
+    ioctl_write_int!(hcidevup, HCI_IOC_MAGIC, HCI_IOC_HCIDEVUP);
+    #[test]
+    fn test_ioctl_write_int() {
+        let file = tempfile().unwrap();
+        let res = unsafe { hcidevup(file.as_raw_fd(), 0) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/videodev2.h
+    ioctl_read!(g_audio, b'V', 33, v4l2_audio);
+    #[test]
+    fn test_ioctl_read() {
+        let file = tempfile().unwrap();
+        let mut data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { g_audio(file.as_raw_fd(), &mut data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/videodev2.h
+    ioctl_readwrite!(enum_audio, b'V', 65, v4l2_audio);
+    #[test]
+    fn test_ioctl_readwrite() {
+        let file = tempfile().unwrap();
+        let mut data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { enum_audio(file.as_raw_fd(), &mut data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_read_buf`.
+
+    #[repr(C)]
+    pub struct spi_ioc_transfer {
+        tx_buf: u64,
+        rx_buf: u64,
+        len: u32,
+        speed_hz: u32,
+        delay_usecs: u16,
+        bits_per_word: u8,
+        cs_change: u8,
+        tx_nbits: u8,
+        rx_nbits: u8,
+        pad: u16,
+    }
+
+    // From linux/spi/spidev.h
+    ioctl_write_buf!(
+        spi_ioc_message,
+        super::SPI_IOC_MAGIC,
+        super::SPI_IOC_MESSAGE,
+        spi_ioc_transfer
+    );
+    #[test]
+    fn test_ioctl_write_buf() {
+        let file = tempfile().unwrap();
+        let data: [spi_ioc_transfer; 4] = unsafe { mem::zeroed() };
+        let res = unsafe { spi_ioc_message(file.as_raw_fd(), &data[..]) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_readwrite_buf`.
+}
+
+#[cfg(target_os = "freebsd")]
+mod freebsd_ioctls {
+    use std::mem;
+    use std::os::unix::io::AsRawFd;
+
+    use libc::termios;
+    use tempfile::tempfile;
+
+    use nix::errno::Errno;
+
+    // From sys/sys/ttycom.h
+    const TTY_IOC_MAGIC: u8 = b't';
+    const TTY_IOC_TYPE_NXCL: u8 = 14;
+    const TTY_IOC_TYPE_GETA: u8 = 19;
+    const TTY_IOC_TYPE_SETA: u8 = 20;
+
+    ioctl_none!(tiocnxcl, TTY_IOC_MAGIC, TTY_IOC_TYPE_NXCL);
+    #[test]
+    fn test_ioctl_none() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tiocnxcl(file.as_raw_fd()) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_read!(tiocgeta, TTY_IOC_MAGIC, TTY_IOC_TYPE_GETA, termios);
+    #[test]
+    fn test_ioctl_read() {
+        let file = tempfile().unwrap();
+        let mut termios = unsafe { mem::zeroed() };
+        let res = unsafe { tiocgeta(file.as_raw_fd(), &mut termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_ptr!(tiocseta, TTY_IOC_MAGIC, TTY_IOC_TYPE_SETA, termios);
+    #[test]
+    fn test_ioctl_write_ptr() {
+        let file = tempfile().unwrap();
+        let termios: termios = unsafe { mem::zeroed() };
+        let res = unsafe { tiocseta(file.as_raw_fd(), &termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+}

notes-service/vendor/nix/test/sys/test_mman.rs

@@ -0,0 +1,121 @@
+#![allow(clippy::redundant_slicing)]
+
+use nix::sys::mman::{mmap_anonymous, MapFlags, ProtFlags};
+use std::num::NonZeroUsize;
+
+#[test]
+fn test_mmap_anonymous() {
+    unsafe {
+        let mut ptr = mmap_anonymous(
+            None,
+            NonZeroUsize::new(1).unwrap(),
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap()
+        .cast::<u8>();
+        assert_eq!(*ptr.as_ref(), 0x00u8);
+        *ptr.as_mut() = 0xffu8;
+        assert_eq!(*ptr.as_ref(), 0xffu8);
+    }
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "netbsd"))]
+fn test_mremap_grow() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::ptr::NonNull;
+
+    const ONE_K: size_t = 1024;
+    let one_k_non_zero = NonZeroUsize::new(ONE_K).unwrap();
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            one_k_non_zero,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+    assert_eq!(slice[ONE_K - 1], 0x00);
+    slice[ONE_K - 1] = 0xFF;
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    let slice: &mut [u8] = unsafe {
+        #[cfg(target_os = "linux")]
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MREMAP_MAYMOVE,
+            None,
+        )
+        .unwrap();
+        #[cfg(target_os = "netbsd")]
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MAP_REMAPDUP,
+            None,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.cast().as_ptr(), 10 * ONE_K)
+    };
+
+    // The first KB should still have the old data in it.
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    // The additional range should be zero-init'd and accessible.
+    assert_eq!(slice[10 * ONE_K - 1], 0x00);
+    slice[10 * ONE_K - 1] = 0xFF;
+    assert_eq!(slice[10 * ONE_K - 1], 0xFF);
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "netbsd"))]
+// Segfaults for unknown reasons under QEMU for 32-bit targets
+#[cfg_attr(all(target_pointer_width = "32", qemu), ignore)]
+fn test_mremap_shrink() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::num::NonZeroUsize;
+    use std::ptr::NonNull;
+
+    const ONE_K: size_t = 1024;
+    let ten_one_k = NonZeroUsize::new(10 * ONE_K).unwrap();
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            ten_one_k,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+    assert_eq!(slice[ONE_K - 1], 0x00);
+    slice[ONE_K - 1] = 0xFF;
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ten_one_k.into(),
+            ONE_K,
+            MRemapFlags::empty(),
+            None,
+        )
+        .unwrap();
+        // Since we didn't supply MREMAP_MAYMOVE, the address should be the
+        // same.
+        assert_eq!(mem.as_ptr(), NonNull::from(&mut slice[..]).cast().as_ptr());
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+
+    // The first KB should still be accessible and have the old data in it.
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+}

notes-service/vendor/nix/test/sys/test_prctl.rs

@@ -0,0 +1,159 @@
+#[cfg(target_os = "linux")]
+#[cfg(feature = "process")]
+mod test_prctl {
+    use std::ffi::CStr;
+
+    use nix::sys::prctl;
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_subreaper() {
+        let original = prctl::get_child_subreaper().unwrap();
+
+        prctl::set_child_subreaper(true).unwrap();
+        let subreaper = prctl::get_child_subreaper().unwrap();
+        assert!(subreaper);
+
+        prctl::set_child_subreaper(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_dumpable() {
+        let original = prctl::get_dumpable().unwrap();
+
+        prctl::set_dumpable(false).unwrap();
+        let dumpable = prctl::get_dumpable().unwrap();
+        assert!(!dumpable);
+
+        prctl::set_dumpable(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_keepcaps() {
+        let original = prctl::get_keepcaps().unwrap();
+
+        prctl::set_keepcaps(true).unwrap();
+        let keepcaps = prctl::get_keepcaps().unwrap();
+        assert!(keepcaps);
+
+        prctl::set_keepcaps(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_clear_mce_kill() {
+        use prctl::PrctlMCEKillPolicy::*;
+
+        prctl::set_mce_kill(PR_MCE_KILL_LATE).unwrap();
+        let mce = prctl::get_mce_kill().unwrap();
+        assert_eq!(mce, PR_MCE_KILL_LATE);
+
+        prctl::clear_mce_kill().unwrap();
+        let mce = prctl::get_mce_kill().unwrap();
+        assert_eq!(mce, PR_MCE_KILL_DEFAULT);
+    }
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_pdeathsig() {
+        use nix::sys::signal::Signal;
+
+        let original = prctl::get_pdeathsig().unwrap();
+
+        prctl::set_pdeathsig(Signal::SIGUSR1).unwrap();
+        let sig = prctl::get_pdeathsig().unwrap();
+        assert_eq!(sig, Some(Signal::SIGUSR1));
+
+        prctl::set_pdeathsig(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_name() {
+        let original = prctl::get_name().unwrap();
+
+        let long_name =
+            CStr::from_bytes_with_nul(b"0123456789abcdefghijklmn\0").unwrap();
+        prctl::set_name(long_name).unwrap();
+        let res = prctl::get_name().unwrap();
+
+        // name truncated by kernel to TASK_COMM_LEN
+        assert_eq!(&long_name.to_str().unwrap()[..15], res.to_str().unwrap());
+
+        let short_name = CStr::from_bytes_with_nul(b"01234567\0").unwrap();
+        prctl::set_name(short_name).unwrap();
+        let res = prctl::get_name().unwrap();
+        assert_eq!(short_name.to_str().unwrap(), res.to_str().unwrap());
+
+        prctl::set_name(&original).unwrap();
+    }
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_timerslack() {
+        let original = prctl::get_timerslack().unwrap();
+
+        let slack = 60_000;
+        prctl::set_timerslack(slack).unwrap();
+        let res = prctl::get_timerslack().unwrap();
+        assert_eq!(slack, res as u64);
+
+        prctl::set_timerslack(original as u64).unwrap();
+    }
+
+    #[test]
+    fn test_disable_enable_perf_events() {
+        prctl::task_perf_events_disable().unwrap();
+        prctl::task_perf_events_enable().unwrap();
+    }
+
+    #[test]
+    fn test_get_set_no_new_privs() {
+        prctl::set_no_new_privs().unwrap();
+        let no_new_privs = prctl::get_no_new_privs().unwrap();
+        assert!(no_new_privs);
+    }
+
+    #[test]
+    fn test_get_set_thp_disable() {
+        let original = prctl::get_thp_disable().unwrap();
+
+        prctl::set_thp_disable(true).unwrap();
+        let thp_disable = prctl::get_thp_disable().unwrap();
+        assert!(thp_disable);
+
+        prctl::set_thp_disable(original).unwrap();
+    }
+
+    #[test]
+    fn test_set_vma_anon_name() {
+        use nix::errno::Errno;
+        use nix::sys::mman;
+        use std::num::NonZeroUsize;
+
+        const ONE_K: libc::size_t = 1024;
+        let sz = NonZeroUsize::new(ONE_K).unwrap();
+        let ptr = unsafe {
+            mman::mmap_anonymous(
+                None,
+                sz,
+                mman::ProtFlags::PROT_READ,
+                mman::MapFlags::MAP_SHARED,
+            )
+            .unwrap()
+        };
+        let err = prctl::set_vma_anon_name(
+            ptr,
+            sz,
+            Some(CStr::from_bytes_with_nul(b"[,$\0").unwrap()),
+        )
+        .unwrap_err();
+        assert_eq!(err, Errno::EINVAL);
+        // `CONFIG_ANON_VMA_NAME` kernel config might not be set
+        prctl::set_vma_anon_name(
+            ptr,
+            sz,
+            Some(CStr::from_bytes_with_nul(b"Nix\0").unwrap()),
+        )
+        .unwrap_or_default();
+        prctl::set_vma_anon_name(ptr, sz, None).unwrap_or_default();
+    }
+}

notes-service/vendor/nix/test/sys/test_pthread.rs

@@ -0,0 +1,22 @@
+use nix::sys::pthread::*;
+
+#[cfg(any(target_env = "musl", target_os = "redox"))]
+#[test]
+fn test_pthread_self() {
+    let tid = pthread_self();
+    assert!(!tid.is_null());
+}
+
+#[cfg(not(any(target_env = "musl", target_os = "redox")))]
+#[test]
+fn test_pthread_self() {
+    let tid = pthread_self();
+    assert_ne!(tid, 0);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_pthread_kill_none() {
+    pthread_kill(pthread_self(), None)
+        .expect("Should be able to send signal to my thread.");
+}

notes-service/vendor/nix/test/sys/test_ptrace.rs

@@ -0,0 +1,373 @@
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(target_arch = "x86_64", target_arch = "x86")
+))]
+use memoffset::offset_of;
+use nix::errno::Errno;
+use nix::sys::ptrace;
+#[cfg(linux_android)]
+use nix::sys::ptrace::Options;
+use nix::unistd::getpid;
+
+#[cfg(linux_android)]
+use std::mem;
+
+use crate::*;
+
+#[test]
+fn test_ptrace() {
+    // Just make sure ptrace can be called at all, for now.
+    // FIXME: qemu-user doesn't implement ptrace on all arches, so permit ENOSYS
+    require_capability!("test_ptrace", CAP_SYS_PTRACE);
+    let err = ptrace::attach(getpid()).unwrap_err();
+    assert!(
+        err == Errno::EPERM || err == Errno::EINVAL || err == Errno::ENOSYS
+    );
+}
+
+// Just make sure ptrace_setoptions can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_setoptions() {
+    require_capability!("test_ptrace_setoptions", CAP_SYS_PTRACE);
+    let err = ptrace::setoptions(getpid(), Options::PTRACE_O_TRACESYSGOOD)
+        .unwrap_err();
+    assert_ne!(err, Errno::EOPNOTSUPP);
+}
+
+// Just make sure ptrace_getevent can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_getevent() {
+    require_capability!("test_ptrace_getevent", CAP_SYS_PTRACE);
+    let err = ptrace::getevent(getpid()).unwrap_err();
+    assert_ne!(err, Errno::EOPNOTSUPP);
+}
+
+// Just make sure ptrace_getsiginfo can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_getsiginfo() {
+    require_capability!("test_ptrace_getsiginfo", CAP_SYS_PTRACE);
+    if let Err(Errno::EOPNOTSUPP) = ptrace::getsiginfo(getpid()) {
+        panic!("ptrace_getsiginfo returns Errno::EOPNOTSUPP!");
+    }
+}
+
+// Just make sure ptrace_setsiginfo can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_setsiginfo() {
+    require_capability!("test_ptrace_setsiginfo", CAP_SYS_PTRACE);
+    let siginfo = unsafe { mem::zeroed() };
+    if let Err(Errno::EOPNOTSUPP) = ptrace::setsiginfo(getpid(), &siginfo) {
+        panic!("ptrace_setsiginfo returns Errno::EOPNOTSUPP!");
+    }
+}
+
+#[test]
+fn test_ptrace_cont() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::{raise, Signal};
+    use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_cont", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    // FIXME: qemu-user doesn't implement ptrace on all architectures
+    // and returns ENOSYS in this case.
+    // We (ab)use this behavior to detect the affected platforms
+    // and skip the test then.
+    // On valid platforms the ptrace call should return Errno::EPERM, this
+    // is already tested by `test_ptrace`.
+    let err = ptrace::attach(getpid()).unwrap_err();
+    if err == Errno::ENOSYS {
+        return;
+    }
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // As recommended by ptrace(2), raise SIGTRAP to pause the child
+            // until the parent is ready to continue
+            loop {
+                raise(Signal::SIGTRAP).unwrap();
+            }
+        }
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            ptrace::cont(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            ptrace::cont(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
+                    // FIXME It's been observed on some systems (apple) the
+                    // tracee may not be killed but remain as a zombie process
+                    // affecting other wait based tests. Add an extra kill just
+                    // to make sure there are no zombies.
+                    let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    while ptrace::cont(child, Some(Signal::SIGKILL)).is_ok() {
+                        let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    }
+                }
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_ptrace_interrupt() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::Signal;
+    use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    require_capability!("test_ptrace_interrupt", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => loop {
+            sleep(Duration::from_millis(1000));
+        },
+        Parent { child } => {
+            ptrace::seize(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
+            ptrace::interrupt(child).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceEvent(child, Signal::SIGTRAP, 128))
+            );
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            ptrace::detach(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
+                    let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    while ptrace::cont(child, Some(Signal::SIGKILL)).is_ok() {
+                        let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    }
+                }
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}
+
+// ptrace::{setoptions, getregs} are only available in these platforms
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(
+        target_arch = "x86_64",
+        target_arch = "x86",
+        target_arch = "aarch64",
+        target_arch = "riscv64",
+    )
+))]
+#[test]
+fn test_ptrace_syscall() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::kill;
+    use nix::sys::signal::Signal;
+    use nix::sys::wait::{waitpid, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::getpid;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_syscall", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // first sigstop until parent is ready to continue
+            let pid = getpid();
+            kill(pid, Signal::SIGSTOP).unwrap();
+            kill(pid, Signal::SIGTERM).unwrap();
+            unsafe {
+                ::libc::_exit(0);
+            }
+        }
+
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGSTOP))
+            );
+
+            // set this option to recognize syscall-stops
+            ptrace::setoptions(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_rax as libc::c_long;
+
+            #[cfg(target_arch = "x86")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_eax as libc::c_long;
+
+            #[cfg(target_arch = "aarch64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().regs[8] as libc::c_long;
+
+            #[cfg(target_arch = "riscv64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().a7 as libc::c_long;
+
+            // this duplicates `get_syscall_id` for the purpose of testing `ptrace::read_user`.
+            #[cfg(target_arch = "x86_64")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_rax);
+            #[cfg(target_arch = "x86")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_eax);
+
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            let get_syscall_from_user_area = || {
+                // Find the offset of `user.regs.rax` (or `user.regs.eax` for x86)
+                let rax_offset = offset_of!(libc::user, regs) + rax_offset;
+                ptrace::read_user(child, rax_offset as _).unwrap()
+                    as libc::c_long
+            };
+
+            // kill entry
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
+
+            // kill exit
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
+
+            // receive signal
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTERM))
+            );
+
+            // inject signal
+            ptrace::syscall(child, Signal::SIGTERM).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, Signal::SIGTERM, false))
+            );
+        }
+    }
+}
+
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(
+        target_arch = "x86_64",
+        target_arch = "x86",
+        target_arch = "aarch64",
+        target_arch = "riscv64",
+    )
+))]
+#[test]
+fn test_ptrace_regsets() {
+    use nix::sys::ptrace::{self, getregset, regset, setregset};
+    use nix::sys::signal::*;
+    use nix::sys::wait::{waitpid, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_regsets", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // As recommended by ptrace(2), raise SIGTRAP to pause the child
+            // until the parent is ready to continue
+            loop {
+                raise(Signal::SIGTRAP).unwrap();
+            }
+        }
+
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            let mut regstruct =
+                getregset::<regset::NT_PRSTATUS>(child).unwrap();
+            let mut fpregstruct =
+                getregset::<regset::NT_PRFPREG>(child).unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let (reg, fpreg) =
+                (&mut regstruct.r15, &mut fpregstruct.st_space[5]);
+            #[cfg(target_arch = "x86")]
+            let (reg, fpreg) =
+                (&mut regstruct.edx, &mut fpregstruct.st_space[5]);
+            #[cfg(target_arch = "aarch64")]
+            let (reg, fpreg) =
+                (&mut regstruct.regs[16], &mut fpregstruct.vregs[5]);
+            #[cfg(target_arch = "riscv64")]
+            let (reg, fpreg) = (&mut regstruct.t1, &mut fpregstruct.__f[5]);
+
+            *reg = 0xdeadbeefu32 as _;
+            *fpreg = 0xfeedfaceu32 as _;
+            let _ = setregset::<regset::NT_PRSTATUS>(child, regstruct);
+            regstruct = getregset::<regset::NT_PRSTATUS>(child).unwrap();
+            let _ = setregset::<regset::NT_PRFPREG>(child, fpregstruct);
+            fpregstruct = getregset::<regset::NT_PRFPREG>(child).unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let (reg, fpreg) = (regstruct.r15, fpregstruct.st_space[5]);
+            #[cfg(target_arch = "x86")]
+            let (reg, fpreg) = (regstruct.edx, fpregstruct.st_space[5]);
+            #[cfg(target_arch = "aarch64")]
+            let (reg, fpreg) = (regstruct.regs[16], fpregstruct.vregs[5]);
+            #[cfg(target_arch = "riscv64")]
+            let (reg, fpreg) = (regstruct.t1, fpregstruct.__f[5]);
+            assert_eq!(reg, 0xdeadbeefu32 as _);
+            assert_eq!(fpreg, 0xfeedfaceu32 as _);
+
+            ptrace::cont(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child => {}
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}

notes-service/vendor/nix/test/sys/test_resource.rs

@@ -0,0 +1,43 @@
+use nix::sys::resource::{getrlimit, setrlimit, Resource};
+use nix::sys::resource::{getrusage, UsageWho};
+
+/// Tests the RLIMIT_NOFILE functionality of getrlimit(), where the resource RLIMIT_NOFILE refers
+/// to the maximum file descriptor number that can be opened by the process (aka the maximum number
+/// of file descriptors that the process can open, since Linux 4.5).
+///
+/// We first fetch the existing file descriptor maximum values using getrlimit(), then edit the
+/// soft limit to make sure it has a new and distinct value to the hard limit. We then setrlimit()
+/// to put the new soft limit in effect, and then getrlimit() once more to ensure the limits have
+/// been updated.
+#[test]
+pub fn test_resource_limits_nofile() {
+    let (mut soft_limit, hard_limit) =
+        getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+
+    soft_limit -= 1;
+    assert_ne!(soft_limit, hard_limit);
+    setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
+
+    let (new_soft_limit, _) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+    assert_eq!(new_soft_limit, soft_limit);
+}
+
+#[test]
+pub fn test_self_cpu_time() {
+    // Make sure some CPU time is used.
+    let mut numbers: Vec<i32> = (1..1_000_000).collect();
+    numbers.iter_mut().for_each(|item| *item *= 2);
+
+    // FIXME: this is here to help ensure the compiler does not optimize the whole
+    // thing away. Replace the assert with test::black_box once stabilized.
+    assert_eq!(numbers[100..200].iter().sum::<i32>(), 30_100);
+
+    let usage = getrusage(UsageWho::RUSAGE_SELF)
+        .expect("Failed to call getrusage for SELF");
+    let rusage = usage.as_ref();
+
+    let user = usage.user_time();
+    assert!(user.tv_sec() > 0 || user.tv_usec() > 0);
+    assert_eq!(user.tv_sec(), rusage.ru_utime.tv_sec);
+    assert_eq!(user.tv_usec(), rusage.ru_utime.tv_usec);
+}

notes-service/vendor/nix/test/sys/test_select.rs

@@ -0,0 +1,293 @@
+use nix::sys::select::*;
+use nix::sys::signal::SigSet;
+use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
+use nix::unistd::{pipe, write};
+use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+
+#[test]
+pub fn test_pselect() {
+    let _mtx = crate::SIGNAL_MTX.lock();
+
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let timeout = TimeSpec::seconds(10);
+    let sigmask = SigSet::empty();
+    assert_eq!(
+        1,
+        pselect(None, &mut fd_set, None, None, &timeout, &sigmask).unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+pub fn test_pselect_nfds2() {
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let timeout = TimeSpec::seconds(10);
+    assert_eq!(
+        1,
+        pselect(
+            std::cmp::max(r1.as_raw_fd(), r2.as_raw_fd()) + 1,
+            &mut fd_set,
+            None,
+            None,
+            &timeout,
+            None
+        )
+        .unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+macro_rules! generate_fdset_bad_fd_tests {
+    ($fd:expr, $($method:ident),* $(,)?) => {
+        $(
+            #[test]
+            #[should_panic]
+            fn $method() {
+                let bad_fd = unsafe{BorrowedFd::borrow_raw($fd)};
+                FdSet::new().$method(bad_fd);
+            }
+        )*
+    }
+}
+
+mod test_fdset_too_large_fd {
+    use super::*;
+    generate_fdset_bad_fd_tests!(
+        FD_SETSIZE.try_into().unwrap(),
+        insert,
+        remove,
+        contains,
+    );
+}
+
+#[test]
+fn fdset_insert() {
+    let mut fd_set = FdSet::new();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    fd_set.insert(fd_seven);
+
+    assert!(fd_set.contains(fd_seven));
+}
+
+#[test]
+fn fdset_remove() {
+    let mut fd_set = FdSet::new();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    fd_set.insert(fd_seven);
+    fd_set.remove(fd_seven);
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+}
+
+#[test]
+#[allow(non_snake_case)]
+fn fdset_clear() {
+    let mut fd_set = FdSet::new();
+    let fd_one = unsafe { BorrowedFd::borrow_raw(1) };
+    let fd_FD_SETSIZE_divided_by_two =
+        unsafe { BorrowedFd::borrow_raw((FD_SETSIZE / 2) as RawFd) };
+    let fd_FD_SETSIZE_minus_one =
+        unsafe { BorrowedFd::borrow_raw((FD_SETSIZE - 1) as RawFd) };
+    fd_set.insert(fd_one);
+    fd_set.insert(fd_FD_SETSIZE_divided_by_two);
+    fd_set.insert(fd_FD_SETSIZE_minus_one);
+
+    fd_set.clear();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+}
+
+#[test]
+fn fdset_highest() {
+    let mut set = FdSet::new();
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        None
+    );
+    let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
+    let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
+    set.insert(fd_zero);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(0)
+    );
+    set.insert(fd_ninety);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(90)
+    );
+    set.remove(fd_zero);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(90)
+    );
+    set.remove(fd_ninety);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        None
+    );
+
+    let fd_four = unsafe { BorrowedFd::borrow_raw(4) };
+    let fd_five = unsafe { BorrowedFd::borrow_raw(5) };
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    set.insert(fd_four);
+    set.insert(fd_five);
+    set.insert(fd_seven);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(7)
+    );
+}
+
+#[test]
+fn fdset_fds() {
+    let mut set = FdSet::new();
+    let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
+    let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![]
+    );
+    set.insert(fd_zero);
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0]
+    );
+    set.insert(fd_ninety);
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0, 90]
+    );
+
+    // highest limit
+    assert_eq!(
+        set.fds(Some(89))
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0]
+    );
+    assert_eq!(
+        set.fds(Some(90))
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0, 90]
+    );
+}
+
+#[test]
+fn test_select() {
+    let (r1, w1) = pipe().unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    write(&w1, b"hi!").unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    assert_eq!(
+        1,
+        select(None, &mut fd_set, None, None, &mut timeout).unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+fn test_select_nfds() {
+    let (r1, w1) = pipe().unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    write(&w1, b"hi!").unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    {
+        assert_eq!(
+            1,
+            select(
+                Some(
+                    fd_set
+                        .highest()
+                        .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+                        .unwrap()
+                        + 1
+                ),
+                &mut fd_set,
+                None,
+                None,
+                &mut timeout
+            )
+            .unwrap()
+        );
+    }
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+fn test_select_nfds2() {
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    assert_eq!(
+        1,
+        select(
+            std::cmp::max(r1.as_raw_fd(), r2.as_raw_fd()) + 1,
+            &mut fd_set,
+            None,
+            None,
+            &mut timeout
+        )
+        .unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}

notes-service/vendor/nix/test/sys/test_signal.rs

@@ -0,0 +1,456 @@
+use nix::errno::Errno;
+use nix::sys::signal::*;
+use nix::unistd::*;
+use std::hash::{Hash, Hasher};
+use std::sync::atomic::{AtomicBool, Ordering};
+#[cfg(not(target_os = "redox"))]
+use std::thread;
+
+#[test]
+fn test_kill_none() {
+    kill(getpid(), None).expect("Should be able to send signal to myself.");
+}
+
+#[test]
+#[cfg(not(target_os = "fuchsia"))]
+fn test_killpg_none() {
+    killpg(getpgrp(), None)
+        .expect("Should be able to send signal to my process group.");
+}
+
+#[test]
+fn test_old_sigaction_flags() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    extern "C" fn handler(_: ::libc::c_int) {}
+    let act = SigAction::new(
+        SigHandler::Handler(handler),
+        SaFlags::empty(),
+        SigSet::empty(),
+    );
+    let oact = unsafe { sigaction(SIGINT, &act) }.unwrap();
+    let _flags = oact.flags();
+    let oact = unsafe { sigaction(SIGINT, &act) }.unwrap();
+    let _flags = oact.flags();
+}
+
+#[test]
+fn test_sigprocmask_noop() {
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, None)
+        .expect("this should be an effective noop");
+}
+
+#[test]
+fn test_sigprocmask() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // This needs to be a signal that rust doesn't use in the test harness.
+    const SIGNAL: Signal = Signal::SIGCHLD;
+
+    let mut old_signal_set = SigSet::empty();
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set))
+        .expect("expect to be able to retrieve old signals");
+
+    // Make sure the old set doesn't contain the signal, otherwise the following
+    // test don't make sense.
+    assert!(
+        !old_signal_set.contains(SIGNAL),
+        "the {SIGNAL:?} signal is already blocked, please change to a \
+             different one"
+    );
+
+    // Now block the signal.
+    let mut signal_set = SigSet::empty();
+    signal_set.add(SIGNAL);
+    sigprocmask(SigmaskHow::SIG_BLOCK, Some(&signal_set), None)
+        .expect("expect to be able to block signals");
+
+    // And test it again, to make sure the change was effective.
+    old_signal_set.clear();
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set))
+        .expect("expect to be able to retrieve old signals");
+    assert!(
+        old_signal_set.contains(SIGNAL),
+        "expected the {SIGNAL:?} to be blocked"
+    );
+
+    // Reset the signal.
+    sigprocmask(SigmaskHow::SIG_UNBLOCK, Some(&signal_set), None)
+        .expect("expect to be able to block signals");
+}
+
+static SIGNALED: AtomicBool = AtomicBool::new(false);
+
+extern "C" fn test_sigaction_handler(signal: libc::c_int) {
+    let signal = Signal::try_from(signal).unwrap();
+    SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);
+}
+
+#[cfg(not(target_os = "redox"))]
+extern "C" fn test_sigaction_action(
+    _: libc::c_int,
+    _: *mut libc::siginfo_t,
+    _: *mut libc::c_void,
+) {
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_signal_sigaction() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    let action_handler = SigHandler::SigAction(test_sigaction_action);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(),
+        Errno::ENOTSUP
+    );
+}
+
+#[test]
+fn test_signal() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    unsafe { signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();
+    raise(Signal::SIGINT).unwrap();
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigIgn
+    );
+
+    let handler = SigHandler::Handler(test_sigaction_handler);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, handler) }.unwrap(),
+        SigHandler::SigDfl
+    );
+    raise(Signal::SIGINT).unwrap();
+    assert!(SIGNALED.load(Ordering::Relaxed));
+
+    #[cfg(not(solarish))]
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        handler
+    );
+
+    // System V based OSes (e.g. illumos and Solaris) always resets the
+    // disposition to SIG_DFL prior to calling the signal handler
+    #[cfg(solarish)]
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigDfl
+    );
+
+    // Restore default signal handler
+    unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
+}
+
+#[test]
+fn test_contains() {
+    let mut mask = SigSet::empty();
+    mask.add(SIGUSR1);
+
+    assert!(mask.contains(SIGUSR1));
+    assert!(!mask.contains(SIGUSR2));
+
+    let all = SigSet::all();
+    assert!(all.contains(SIGUSR1));
+    assert!(all.contains(SIGUSR2));
+}
+
+#[test]
+fn test_clear() {
+    let mut set = SigSet::all();
+    set.clear();
+    for signal in Signal::iterator() {
+        assert!(!set.contains(signal));
+    }
+}
+
+#[test]
+fn test_from_str_round_trips() {
+    for signal in Signal::iterator() {
+        assert_eq!(signal.as_ref().parse::<Signal>().unwrap(), signal);
+        assert_eq!(signal.to_string().parse::<Signal>().unwrap(), signal);
+    }
+}
+
+#[test]
+fn test_from_str_invalid_value() {
+    let errval = Err(Errno::EINVAL);
+    assert_eq!("NOSIGNAL".parse::<Signal>(), errval);
+    assert_eq!("kill".parse::<Signal>(), errval);
+    assert_eq!("9".parse::<Signal>(), errval);
+}
+
+#[test]
+fn test_extend() {
+    let mut one_signal = SigSet::empty();
+    one_signal.add(SIGUSR1);
+
+    let mut two_signals = SigSet::empty();
+    two_signals.add(SIGUSR2);
+    two_signals.extend(&one_signal);
+
+    assert!(two_signals.contains(SIGUSR1));
+    assert!(two_signals.contains(SIGUSR2));
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_set_mask() {
+    thread::spawn(|| {
+        let prev_mask = SigSet::thread_get_mask()
+            .expect("Failed to get existing signal mask!");
+
+        let mut test_mask = prev_mask;
+        test_mask.add(SIGUSR1);
+
+        test_mask.thread_set_mask().expect("assertion failed");
+        let new_mask =
+            SigSet::thread_get_mask().expect("Failed to get new mask!");
+
+        assert!(new_mask.contains(SIGUSR1));
+        assert!(!new_mask.contains(SIGUSR2));
+
+        prev_mask
+            .thread_set_mask()
+            .expect("Failed to revert signal mask!");
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_block() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        mask.thread_block().expect("assertion failed");
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_unblock() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        mask.thread_unblock().expect("assertion failed");
+
+        assert!(!SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_swap() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+        mask.thread_block().unwrap();
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+
+        let mut mask2 = SigSet::empty();
+        mask2.add(SIGUSR2);
+
+        let oldmask = mask2.thread_swap_mask(SigmaskHow::SIG_SETMASK).unwrap();
+
+        assert!(oldmask.contains(SIGUSR1));
+        assert!(!oldmask.contains(SIGUSR2));
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR2));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+fn test_from_and_into_iterator() {
+    let sigset = SigSet::from_iter(vec![Signal::SIGUSR1, Signal::SIGUSR2]);
+    let signals = sigset.into_iter().collect::<Vec<Signal>>();
+    assert_eq!(signals, [Signal::SIGUSR1, Signal::SIGUSR2]);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_sigaction() {
+    let _m = crate::SIGNAL_MTX.lock();
+    thread::spawn(|| {
+        extern "C" fn test_sigaction_handler(_: libc::c_int) {}
+        extern "C" fn test_sigaction_action(
+            _: libc::c_int,
+            _: *mut libc::siginfo_t,
+            _: *mut libc::c_void,
+        ) {
+        }
+
+        let handler_sig = SigHandler::Handler(test_sigaction_handler);
+
+        let flags =
+            SaFlags::SA_ONSTACK | SaFlags::SA_RESTART | SaFlags::SA_SIGINFO;
+
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        let action_sig = SigAction::new(handler_sig, flags, mask);
+
+        assert_eq!(
+            action_sig.flags(),
+            SaFlags::SA_ONSTACK | SaFlags::SA_RESTART
+        );
+        assert_eq!(action_sig.handler(), handler_sig);
+
+        mask = action_sig.mask();
+        assert!(mask.contains(SIGUSR1));
+        assert!(!mask.contains(SIGUSR2));
+
+        let handler_act = SigHandler::SigAction(test_sigaction_action);
+        let action_act = SigAction::new(handler_act, flags, mask);
+        assert_eq!(action_act.handler(), handler_act);
+
+        let action_dfl = SigAction::new(SigHandler::SigDfl, flags, mask);
+        assert_eq!(action_dfl.handler(), SigHandler::SigDfl);
+
+        let action_ign = SigAction::new(SigHandler::SigIgn, flags, mask);
+        assert_eq!(action_ign.handler(), SigHandler::SigIgn);
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_sigwait() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+        mask.add(SIGUSR2);
+        mask.thread_block().unwrap();
+
+        raise(SIGUSR1).unwrap();
+        assert_eq!(mask.wait().unwrap(), SIGUSR1);
+    })
+    .join()
+    .unwrap();
+}
+
+#[cfg(any(
+    bsd,
+    linux_android,
+    solarish,
+    target_os = "haiku",
+    target_os = "hurd",
+    target_os = "aix",
+    target_os = "fuchsia"
+))]
+#[test]
+fn test_sigsuspend() {
+    // This test change signal handler
+    let _m = crate::SIGNAL_MTX.lock();
+    static SIGNAL_RECIEVED: AtomicBool = AtomicBool::new(false);
+    extern "C" fn test_sigsuspend_handler(_: libc::c_int) {
+        assert!(!SIGNAL_RECIEVED.swap(true, Ordering::SeqCst));
+    }
+    thread::spawn(|| {
+        const SIGNAL: Signal = Signal::SIGUSR1;
+
+        // Add signal mask to this thread
+        let mut signal_set = SigSet::empty();
+        signal_set.add(SIGNAL);
+        signal_set.thread_block().unwrap();
+
+        // Set signal handler and save old one.
+        let act = SigAction::new(
+            SigHandler::Handler(test_sigsuspend_handler),
+            SaFlags::empty(),
+            SigSet::empty(),
+        );
+        let old_act = unsafe { sigaction(SIGNAL, &act) }
+            .expect("expect to be able to set new action and get old action");
+
+        raise(SIGNAL).expect("expect be able to send signal");
+        // Now `SIGNAL` was sended but it is blocked.
+        let mut not_wait_set = SigSet::all();
+        not_wait_set.remove(SIGNAL);
+        // signal handler must run in SigSet::suspend()
+        assert!(!SIGNAL_RECIEVED.load(Ordering::SeqCst));
+        not_wait_set.suspend().unwrap();
+        assert!(SIGNAL_RECIEVED.load(Ordering::SeqCst));
+
+        // Restore the signal handler.
+        unsafe { sigaction(SIGNAL, &old_act) }
+            .expect("expect to be able to restore old action ");
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+fn test_from_sigset_t_unchecked() {
+    let src_set = SigSet::empty();
+    let set = unsafe { SigSet::from_sigset_t_unchecked(*src_set.as_ref()) };
+
+    for signal in Signal::iterator() {
+        assert!(!set.contains(signal));
+    }
+
+    let src_set = SigSet::all();
+    let set = unsafe { SigSet::from_sigset_t_unchecked(*src_set.as_ref()) };
+
+    for signal in Signal::iterator() {
+        assert!(set.contains(signal));
+    }
+}
+
+#[test]
+fn test_eq_empty() {
+    let set0 = SigSet::empty();
+    let set1 = SigSet::empty();
+    assert_eq!(set0, set1);
+}
+
+#[test]
+fn test_eq_all() {
+    let set0 = SigSet::all();
+    let set1 = SigSet::all();
+    assert_eq!(set0, set1);
+}
+
+#[test]
+fn test_hash_empty() {
+    use std::collections::hash_map::DefaultHasher;
+
+    let set0 = SigSet::empty();
+    let mut h0 = DefaultHasher::new();
+    set0.hash(&mut h0);
+
+    let set1 = SigSet::empty();
+    let mut h1 = DefaultHasher::new();
+    set1.hash(&mut h1);
+
+    assert_eq!(h0.finish(), h1.finish());
+}
+
+#[test]
+fn test_hash_all() {
+    use std::collections::hash_map::DefaultHasher;
+
+    let set0 = SigSet::all();
+    let mut h0 = DefaultHasher::new();
+    set0.hash(&mut h0);
+
+    let set1 = SigSet::all();
+    let mut h1 = DefaultHasher::new();
+    set1.hash(&mut h1);
+
+    assert_eq!(h0.finish(), h1.finish());
+}

notes-service/vendor/nix/test/sys/test_signalfd.rs

@@ -0,0 +1,90 @@
+use std::convert::TryFrom;
+
+#[test]
+fn create_signalfd() {
+    use nix::sys::{signal::SigSet, signalfd::SignalFd};
+
+    let mask = SigSet::empty();
+    SignalFd::new(&mask).unwrap();
+}
+
+#[test]
+fn create_signalfd_with_opts() {
+    use nix::sys::{
+        signal::SigSet,
+        signalfd::{SfdFlags, SignalFd},
+    };
+
+    let mask = SigSet::empty();
+    SignalFd::with_flags(&mask, SfdFlags::SFD_CLOEXEC | SfdFlags::SFD_NONBLOCK)
+        .unwrap();
+}
+
+#[test]
+fn read_empty_signalfd() {
+    use nix::sys::{
+        signal::SigSet,
+        signalfd::{SfdFlags, SignalFd},
+    };
+
+    let mask = SigSet::empty();
+    let fd = SignalFd::with_flags(&mask, SfdFlags::SFD_NONBLOCK).unwrap();
+
+    let res = fd.read_signal();
+    assert!(res.unwrap().is_none());
+}
+
+#[test]
+fn test_signalfd() {
+    use nix::sys::signal::{self, raise, SigSet, Signal};
+    use nix::sys::signalfd::SignalFd;
+
+    // Grab the mutex for altering signals so we don't interfere with other tests.
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // Block the SIGUSR1 signal from automatic processing for this thread
+    let mut mask = SigSet::empty();
+    mask.add(signal::SIGUSR1);
+    mask.thread_block().unwrap();
+
+    let fd = SignalFd::new(&mask).unwrap();
+
+    // Send a SIGUSR1 signal to the current process. Note that this uses `raise` instead of `kill`
+    // because `kill` with `getpid` isn't correct during multi-threaded execution like during a
+    // cargo test session. Instead use `raise` which does the correct thing by default.
+    raise(signal::SIGUSR1).expect("Error: raise(SIGUSR1) failed");
+
+    // And now catch that same signal.
+    let res = fd.read_signal().unwrap().unwrap();
+    let signo = Signal::try_from(res.ssi_signo as i32).unwrap();
+    assert_eq!(signo, signal::SIGUSR1);
+}
+
+/// Update the signal mask of an already existing signalfd.
+#[test]
+fn test_signalfd_setmask() {
+    use nix::sys::signal::{self, raise, SigSet, Signal};
+    use nix::sys::signalfd::SignalFd;
+
+    // Grab the mutex for altering signals so we don't interfere with other tests.
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // Block the SIGUSR1 signal from automatic processing for this thread
+    let mut mask = SigSet::empty();
+
+    let fd = SignalFd::new(&mask).unwrap();
+
+    mask.add(signal::SIGUSR1);
+    mask.thread_block().unwrap();
+    fd.set_mask(&mask).unwrap();
+
+    // Send a SIGUSR1 signal to the current process. Note that this uses `raise` instead of `kill`
+    // because `kill` with `getpid` isn't correct during multi-threaded execution like during a
+    // cargo test session. Instead use `raise` which does the correct thing by default.
+    raise(signal::SIGUSR1).expect("Error: raise(SIGUSR1) failed");
+
+    // And now catch that same signal.
+    let res = fd.read_signal().unwrap().unwrap();
+    let signo = Signal::try_from(res.ssi_signo as i32).unwrap();
+    assert_eq!(signo, signal::SIGUSR1);
+}

notes-service/vendor/nix/test/sys/test_sockopt.rs

@@ -0,0 +1,879 @@
+#[cfg(linux_android)]
+use crate::*;
+use nix::sys::socket::{
+    getsockopt, setsockopt, socket, sockopt, AddressFamily, SockFlag,
+    SockProtocol, SockType,
+};
+use rand::{thread_rng, Rng};
+use std::os::unix::io::{AsRawFd, FromRawFd, OwnedFd};
+
+// NB: FreeBSD supports LOCAL_PEERCRED for SOCK_SEQPACKET, but OSX does not.
+#[cfg(freebsdlike)]
+#[test]
+pub fn test_local_peercred_seqpacket() {
+    use nix::{
+        sys::socket::socketpair,
+        unistd::{Gid, Uid},
+    };
+
+    let (fd1, _fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::SeqPacket,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
+    let xucred = getsockopt(&fd1, sockopt::LocalPeerCred).unwrap();
+    assert_eq!(xucred.version(), 0);
+    assert_eq!(Uid::from_raw(xucred.uid()), Uid::current());
+    assert_eq!(Gid::from_raw(xucred.groups()[0]), Gid::current());
+}
+
+#[cfg(any(freebsdlike, apple_targets))]
+#[test]
+pub fn test_local_peercred_stream() {
+    use nix::{
+        sys::socket::socketpair,
+        unistd::{Gid, Uid},
+    };
+
+    let (fd1, _fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
+    let xucred = getsockopt(&fd1, sockopt::LocalPeerCred).unwrap();
+    assert_eq!(xucred.version(), 0);
+    assert_eq!(Uid::from_raw(xucred.uid()), Uid::current());
+    assert_eq!(Gid::from_raw(xucred.groups()[0]), Gid::current());
+}
+
+#[cfg(apple_targets)]
+#[test]
+pub fn test_local_peer_pid() {
+    use nix::sys::socket::socketpair;
+
+    let (fd1, _fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
+    let pid = getsockopt(&fd1, sockopt::LocalPeerPid).unwrap();
+    assert_eq!(pid, std::process::id() as _);
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn is_so_mark_functional() {
+    use nix::sys::socket::sockopt;
+
+    require_capability!("is_so_mark_functional", CAP_NET_ADMIN);
+
+    let s = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&s, sockopt::Mark, &1337).unwrap();
+    let mark = getsockopt(&s, sockopt::Mark).unwrap();
+    assert_eq!(mark, 1337);
+}
+
+#[test]
+fn test_so_buf() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::Udp,
+    )
+    .unwrap();
+    let bufsize: usize = thread_rng().gen_range(4096..131_072);
+    setsockopt(&fd, sockopt::SndBuf, &bufsize).unwrap();
+    let actual = getsockopt(&fd, sockopt::SndBuf).unwrap();
+    assert!(actual >= bufsize);
+    setsockopt(&fd, sockopt::RcvBuf, &bufsize).unwrap();
+    let actual = getsockopt(&fd, sockopt::RcvBuf).unwrap();
+    assert!(actual >= bufsize);
+}
+
+#[cfg(target_os = "freebsd")]
+#[test]
+fn test_so_listen_q_limit() {
+    use nix::sys::socket::{bind, listen, Backlog, SockaddrIn};
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:4004").unwrap();
+    let sock_addr = SockaddrIn::from(std_sa);
+
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    bind(rsock.as_raw_fd(), &sock_addr).unwrap();
+    let pre_limit = getsockopt(&rsock, sockopt::ListenQLimit).unwrap();
+    assert_eq!(pre_limit, 0);
+    listen(&rsock, Backlog::new(42).unwrap()).unwrap();
+    let post_limit = getsockopt(&rsock, sockopt::ListenQLimit).unwrap();
+    assert_eq!(post_limit, 42);
+}
+
+#[test]
+fn test_so_tcp_maxseg() {
+    use nix::sys::socket::{
+        accept, bind, connect, getsockname, listen, Backlog, SockaddrIn,
+    };
+    use nix::unistd::write;
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:0").unwrap();
+    let mut sock_addr = SockaddrIn::from(std_sa);
+
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    bind(rsock.as_raw_fd(), &sock_addr).unwrap();
+    sock_addr = getsockname(rsock.as_raw_fd()).unwrap();
+    listen(&rsock, Backlog::new(10).unwrap()).unwrap();
+    let initial = getsockopt(&rsock, sockopt::TcpMaxSeg).unwrap();
+    // Initial MSS is expected to be 536 (https://tools.ietf.org/html/rfc879#section-1) but some
+    // platforms keep it even lower. This might fail if you've tuned your initial MSS to be larger
+    // than 700
+    cfg_if! {
+        if #[cfg(linux_android)] {
+            let segsize: u32 = 873;
+            assert!(initial < segsize);
+            setsockopt(&rsock, sockopt::TcpMaxSeg, &segsize).unwrap();
+        } else {
+            assert!(initial < 700);
+        }
+    }
+
+    // Connect and check the MSS that was advertised
+    let ssock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    connect(ssock.as_raw_fd(), &sock_addr).unwrap();
+    let rsess = accept(rsock.as_raw_fd()).unwrap();
+    let rsess = unsafe { OwnedFd::from_raw_fd(rsess) };
+    write(&rsess, b"hello").unwrap();
+    let actual = getsockopt(&ssock, sockopt::TcpMaxSeg).unwrap();
+    // Actual max segment size takes header lengths into account, max IPv4 options (60 bytes) + max
+    // TCP options (40 bytes) are subtracted from the requested maximum as a lower boundary.
+    cfg_if! {
+        if #[cfg(linux_android)] {
+            assert!((segsize - 100) <= actual);
+            assert!(actual <= segsize);
+        } else {
+            assert!(initial < actual);
+            assert!(536 < actual);
+        }
+    }
+}
+
+#[test]
+fn test_so_type() {
+    let sockfd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    assert_eq!(Ok(SockType::Stream), getsockopt(&sockfd, sockopt::SockType));
+}
+
+/// getsockopt(_, sockopt::SockType) should gracefully handle unknown socket
+/// types.  Regression test for https://github.com/nix-rust/nix/issues/1819
+#[cfg(linux_android)]
+#[test]
+fn test_so_type_unknown() {
+    use nix::errno::Errno;
+
+    require_capability!("test_so_type", CAP_NET_RAW);
+    let raw_fd = unsafe { libc::socket(libc::AF_PACKET, libc::SOCK_PACKET, 0) };
+    assert!(raw_fd >= 0, "Error opening socket: {}", nix::Error::last());
+    let sockfd = unsafe { OwnedFd::from_raw_fd(raw_fd) };
+
+    assert_eq!(Err(Errno::EINVAL), getsockopt(&sockfd, sockopt::SockType));
+}
+
+// The CI doesn't supported getsockopt and setsockopt on emulated processors.
+// It's believed that a QEMU issue, the tests run ok on a fully emulated system.
+// Current CI just run the binary with QEMU but the Kernel remains the same as the host.
+// So the syscall doesn't work properly unless the kernel is also emulated.
+#[test]
+#[cfg(all(
+    any(target_arch = "x86", target_arch = "x86_64"),
+    any(target_os = "freebsd", target_os = "linux")
+))]
+fn test_tcp_congestion() {
+    use std::ffi::OsString;
+
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    let val = getsockopt(&fd, sockopt::TcpCongestion).unwrap();
+    setsockopt(&fd, sockopt::TcpCongestion, &val).unwrap();
+
+    setsockopt(
+        &fd,
+        sockopt::TcpCongestion,
+        &OsString::from("tcp_congestion_does_not_exist"),
+    )
+    .unwrap_err();
+
+    assert_eq!(getsockopt(&fd, sockopt::TcpCongestion).unwrap(), val);
+}
+
+#[test]
+#[cfg(linux_android)]
+fn test_bindtodevice() {
+    skip_if_not_root!("test_bindtodevice");
+
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    let val = getsockopt(&fd, sockopt::BindToDevice).unwrap();
+    setsockopt(&fd, sockopt::BindToDevice, &val).unwrap();
+
+    assert_eq!(getsockopt(&fd, sockopt::BindToDevice).unwrap(), val);
+}
+
+#[test]
+fn test_so_tcp_keepalive() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(&fd, sockopt::KeepAlive, &true).unwrap();
+    assert!(getsockopt(&fd, sockopt::KeepAlive).unwrap());
+
+    #[cfg(any(linux_android, freebsdlike))]
+    {
+        let x = getsockopt(&fd, sockopt::TcpKeepIdle).unwrap();
+        setsockopt(&fd, sockopt::TcpKeepIdle, &(x + 1)).unwrap();
+        assert_eq!(getsockopt(&fd, sockopt::TcpKeepIdle).unwrap(), x + 1);
+
+        let x = getsockopt(&fd, sockopt::TcpKeepCount).unwrap();
+        setsockopt(&fd, sockopt::TcpKeepCount, &(x + 1)).unwrap();
+        assert_eq!(getsockopt(&fd, sockopt::TcpKeepCount).unwrap(), x + 1);
+
+        let x = getsockopt(&fd, sockopt::TcpKeepInterval).unwrap();
+        setsockopt(&fd, sockopt::TcpKeepInterval, &(x + 1)).unwrap();
+        assert_eq!(getsockopt(&fd, sockopt::TcpKeepInterval).unwrap(), x + 1);
+    }
+}
+
+#[test]
+#[cfg(linux_android)]
+#[cfg_attr(qemu, ignore)]
+fn test_get_mtu() {
+    use nix::sys::socket::{bind, connect, SockaddrIn};
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:0").unwrap();
+    let std_sb = SocketAddrV4::from_str("127.0.0.1:4002").unwrap();
+
+    let usock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::Udp,
+    )
+    .unwrap();
+
+    // Bind and initiate connection
+    bind(usock.as_raw_fd(), &SockaddrIn::from(std_sa)).unwrap();
+    connect(usock.as_raw_fd(), &SockaddrIn::from(std_sb)).unwrap();
+
+    // Loopback connections have 2^16 - the maximum - MTU
+    assert_eq!(getsockopt(&usock, sockopt::IpMtu), Ok(u16::MAX as i32))
+}
+
+#[test]
+#[cfg(any(linux_android, target_os = "freebsd"))]
+fn test_ttl_opts() {
+    let fd4 = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd4, sockopt::Ipv4Ttl, &1)
+        .expect("setting ipv4ttl on an inet socket should succeed");
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd6, sockopt::Ipv6Ttl, &1)
+        .expect("setting ipv6ttl on an inet6 socket should succeed");
+}
+
+#[test]
+#[cfg(any(linux_android, target_os = "freebsd"))]
+fn test_multicast_ttl_opts_ipv4() {
+    let fd4 = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd4, sockopt::IpMulticastTtl, &2)
+        .expect("setting ipmulticastttl on an inet socket should succeed");
+}
+
+#[test]
+#[cfg(linux_android)]
+fn test_multicast_ttl_opts_ipv6() {
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd6, sockopt::IpMulticastTtl, &2)
+        .expect("setting ipmulticastttl on an inet6 socket should succeed");
+}
+
+#[test]
+fn test_ipv6_multicast_hops() {
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd6, sockopt::Ipv6MulticastHops, &7)
+        .expect("setting ipv6multicasthops on an inet6 socket should succeed");
+}
+
+#[test]
+#[cfg(apple_targets)]
+fn test_dontfrag_opts() {
+    let fd4 = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(&fd4, sockopt::IpDontFrag, &true)
+        .expect("setting IP_DONTFRAG on an inet stream socket should succeed");
+    setsockopt(&fd4, sockopt::IpDontFrag, &false).expect(
+        "unsetting IP_DONTFRAG on an inet stream socket should succeed",
+    );
+    let fd4d = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd4d, sockopt::IpDontFrag, &true).expect(
+        "setting IP_DONTFRAG on an inet datagram socket should succeed",
+    );
+    setsockopt(&fd4d, sockopt::IpDontFrag, &false).expect(
+        "unsetting IP_DONTFRAG on an inet datagram socket should succeed",
+    );
+}
+
+#[test]
+#[cfg(any(linux_android, apple_targets))]
+// Disable the test under emulation because it fails in Cirrus-CI.  Lack
+// of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+fn test_v6dontfrag_opts() {
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(&fd6, sockopt::Ipv6DontFrag, &true).expect(
+        "setting IPV6_DONTFRAG on an inet6 stream socket should succeed",
+    );
+    setsockopt(&fd6, sockopt::Ipv6DontFrag, &false).expect(
+        "unsetting IPV6_DONTFRAG on an inet6 stream socket should succeed",
+    );
+    let fd6d = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd6d, sockopt::Ipv6DontFrag, &true).expect(
+        "setting IPV6_DONTFRAG on an inet6 datagram socket should succeed",
+    );
+    setsockopt(&fd6d, sockopt::Ipv6DontFrag, &false).expect(
+        "unsetting IPV6_DONTFRAG on an inet6 datagram socket should succeed",
+    );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_so_priority() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let priority = 3;
+    setsockopt(&fd, sockopt::Priority, &priority).unwrap();
+    assert_eq!(getsockopt(&fd, sockopt::Priority).unwrap(), priority);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_ip_tos() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let tos = 0x80; // CS4
+    setsockopt(&fd, sockopt::IpTos, &tos).unwrap();
+    assert_eq!(getsockopt(&fd, sockopt::IpTos).unwrap(), tos);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+// Disable the test under emulation because it fails in Cirrus-CI.  Lack
+// of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+fn test_ipv6_tclass() {
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let class = 0x80; // CS4
+    setsockopt(&fd, sockopt::Ipv6TClass, &class).unwrap();
+    assert_eq!(getsockopt(&fd, sockopt::Ipv6TClass).unwrap(), class);
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_receive_timestamp() {
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap();
+    assert!(getsockopt(&fd, sockopt::ReceiveTimestamp).unwrap());
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_ts_clock_realtime_micro() {
+    use nix::sys::socket::SocketTimestamp;
+
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP.
+    setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap();
+
+    setsockopt(
+        &fd,
+        sockopt::TsClock,
+        &SocketTimestamp::SO_TS_REALTIME_MICRO,
+    )
+    .unwrap();
+    assert_eq!(
+        getsockopt(&fd, sockopt::TsClock).unwrap(),
+        SocketTimestamp::SO_TS_REALTIME_MICRO
+    );
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_ts_clock_bintime() {
+    use nix::sys::socket::SocketTimestamp;
+
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP.
+    setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap();
+
+    setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_BINTIME).unwrap();
+    assert_eq!(
+        getsockopt(&fd, sockopt::TsClock).unwrap(),
+        SocketTimestamp::SO_TS_BINTIME
+    );
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_ts_clock_realtime() {
+    use nix::sys::socket::SocketTimestamp;
+
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP.
+    setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap();
+
+    setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_REALTIME)
+        .unwrap();
+    assert_eq!(
+        getsockopt(&fd, sockopt::TsClock).unwrap(),
+        SocketTimestamp::SO_TS_REALTIME
+    );
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_ts_clock_monotonic() {
+    use nix::sys::socket::SocketTimestamp;
+
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP.
+    setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap();
+
+    setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_MONOTONIC)
+        .unwrap();
+    assert_eq!(
+        getsockopt(&fd, sockopt::TsClock).unwrap(),
+        SocketTimestamp::SO_TS_MONOTONIC
+    );
+}
+
+#[test]
+#[cfg(linux_android)]
+// Disable the test under emulation because it fails with ENOPROTOOPT in CI
+// on cross target. Lack of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+fn test_ip_bind_address_no_port() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(&fd, sockopt::IpBindAddressNoPort, &true).expect(
+        "setting IP_BIND_ADDRESS_NO_PORT on an inet stream socket should succeed",
+    );
+    assert!(getsockopt(&fd, sockopt::IpBindAddressNoPort).expect(
+        "getting IP_BIND_ADDRESS_NO_PORT on an inet stream socket should succeed",
+    ));
+    setsockopt(&fd, sockopt::IpBindAddressNoPort, &false).expect(
+        "unsetting IP_BIND_ADDRESS_NO_PORT on an inet stream socket should succeed",
+    );
+    assert!(!getsockopt(&fd, sockopt::IpBindAddressNoPort).expect(
+        "getting IP_BIND_ADDRESS_NO_PORT on an inet stream socket should succeed",
+    ));
+}
+
+#[test]
+#[cfg(linux_android)]
+fn test_tcp_fast_open_connect() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(&fd, sockopt::TcpFastOpenConnect, &true).expect(
+        "setting TCP_FASTOPEN_CONNECT on an inet stream socket should succeed",
+    );
+    assert!(getsockopt(&fd, sockopt::TcpFastOpenConnect).expect(
+        "getting TCP_FASTOPEN_CONNECT on an inet stream socket should succeed",
+    ));
+    setsockopt(&fd, sockopt::TcpFastOpenConnect, &false).expect(
+        "unsetting TCP_FASTOPEN_CONNECT on an inet stream socket should succeed",
+    );
+    assert!(!getsockopt(&fd, sockopt::TcpFastOpenConnect).expect(
+        "getting TCP_FASTOPEN_CONNECT on an inet stream socket should succeed",
+    ));
+}
+
+#[cfg(linux_android)]
+#[test]
+fn can_get_peercred_on_unix_socket() {
+    use nix::sys::socket::{socketpair, sockopt, SockFlag, SockType};
+
+    let (a, b) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
+    let a_cred = getsockopt(&a, sockopt::PeerCredentials).unwrap();
+    let b_cred = getsockopt(&b, sockopt::PeerCredentials).unwrap();
+    assert_eq!(a_cred, b_cred);
+    assert_ne!(a_cred.pid(), 0);
+}
+
+#[test]
+fn is_socket_type_unix() {
+    use nix::sys::socket::{socketpair, sockopt, SockFlag, SockType};
+
+    let (a, _b) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
+    let a_type = getsockopt(&a, sockopt::SockType).unwrap();
+    assert_eq!(a_type, SockType::Stream);
+}
+
+#[test]
+fn is_socket_type_dgram() {
+    use nix::sys::socket::{
+        getsockopt, sockopt, AddressFamily, SockFlag, SockType,
+    };
+
+    let s = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    let s_type = getsockopt(&s, sockopt::SockType).unwrap();
+    assert_eq!(s_type, SockType::Datagram);
+}
+
+#[cfg(any(target_os = "freebsd", target_os = "linux"))]
+#[test]
+fn can_get_listen_on_tcp_socket() {
+    use nix::sys::socket::{
+        getsockopt, listen, socket, sockopt, AddressFamily, Backlog, SockFlag,
+        SockType,
+    };
+
+    let s = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    let s_listening = getsockopt(&s, sockopt::AcceptConn).unwrap();
+    assert!(!s_listening);
+    listen(&s, Backlog::new(10).unwrap()).unwrap();
+    let s_listening2 = getsockopt(&s, sockopt::AcceptConn).unwrap();
+    assert!(s_listening2);
+}
+
+#[cfg(target_os = "linux")]
+// Some architectures running under cross don't support `setsockopt(SOL_TCP, TCP_ULP)`
+// because the cross image is based on Ubuntu 16.04 which predates TCP ULP support
+// (it was added in kernel v4.13 released in 2017). For these architectures,
+// the `setsockopt(SOL_TCP, TCP_ULP, "tls", sizeof("tls"))` call succeeds
+// but the subsequent `setsockopt(SOL_TLS, TLS_TX, ...)` call fails with `ENOPROTOOPT`.
+// It's as if the first `setsockopt` call enabled some other option, not `TCP_ULP`.
+// For example, `strace` says:
+//
+//     [pid   813] setsockopt(4, SOL_TCP, 0x1f /* TCP_??? */, [7564404], 4) = 0
+//
+// It's not clear why `setsockopt(SOL_TCP, TCP_ULP)` succeeds if the container image libc doesn't support it,
+// but in any case we can't run the test on such an architecture, so skip it.
+#[cfg_attr(qemu, ignore)]
+#[test]
+fn test_ktls() {
+    use nix::sys::socket::{
+        accept, bind, connect, getsockname, listen, Backlog, SockaddrIn,
+    };
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:0").unwrap();
+    let mut sock_addr = SockaddrIn::from(std_sa);
+
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    bind(rsock.as_raw_fd(), &sock_addr).unwrap();
+    sock_addr = getsockname(rsock.as_raw_fd()).unwrap();
+    listen(&rsock, Backlog::new(10).unwrap()).unwrap();
+
+    let ssock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    connect(ssock.as_raw_fd(), &sock_addr).unwrap();
+
+    let _rsess = accept(rsock.as_raw_fd()).unwrap();
+
+    match setsockopt(&ssock, sockopt::TcpUlp::default(), b"tls") {
+        Ok(()) => (),
+
+        // TLS ULP is not enabled, so we can't test kTLS.
+        Err(nix::Error::ENOENT) => skip!("TLS ULP is not enabled"),
+
+        Err(err) => panic!("{err:?}"),
+    }
+
+    // In real life we would do a TLS handshake and extract the protocol version and secrets.
+    // For this test we just make some up.
+
+    let tx = sockopt::TlsCryptoInfo::Aes128Gcm(libc::tls12_crypto_info_aes_gcm_128 {
+        info: libc::tls_crypto_info {
+            version: libc::TLS_1_2_VERSION,
+            cipher_type: libc::TLS_CIPHER_AES_GCM_128,
+        },
+        iv: *b"\x04\x05\x06\x07\x08\x09\x0a\x0b",
+        key: *b"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+        salt: *b"\x00\x01\x02\x03",
+        rec_seq: *b"\x00\x00\x00\x00\x00\x00\x00\x00",
+    });
+    setsockopt(&ssock, sockopt::TcpTlsTx, &tx)
+        .expect("setting TLS_TX after enabling TLS ULP should succeed");
+
+    let rx = sockopt::TlsCryptoInfo::Aes128Gcm(libc::tls12_crypto_info_aes_gcm_128 {
+        info: libc::tls_crypto_info {
+            version: libc::TLS_1_2_VERSION,
+            cipher_type: libc::TLS_CIPHER_AES_GCM_128,
+        },
+        iv: *b"\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb",
+        key: *b"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef",
+        salt: *b"\xf0\xf1\xf2\xf3",
+        rec_seq: *b"\x00\x00\x00\x00\x00\x00\x00\x00",
+    });
+    match setsockopt(&ssock, sockopt::TcpTlsRx, &rx) {
+        Ok(()) => (),
+        Err(nix::Error::ENOPROTOOPT) => {
+            // TLS_TX was added in v4.13 and TLS_RX in v4.17, so we appear to be between that range.
+            // It's good enough that TLS_TX worked, so let the test succeed.
+        }
+        Err(err) => panic!("{err:?}"),
+    }
+}
+
+#[test]
+#[cfg(apple_targets)]
+fn test_utun_ifname() {
+    skip_if_not_root!("test_utun_ifname");
+
+    use nix::sys::socket::connect;
+    use nix::sys::socket::SysControlAddr;
+
+    let fd = socket(
+        AddressFamily::System,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::KextControl,
+    )
+    .unwrap();
+
+    let unit = 123;
+    let addr = SysControlAddr::from_name(
+        fd.as_raw_fd(),
+        "com.apple.net.utun_control",
+        unit,
+    )
+    .unwrap();
+
+    connect(fd.as_raw_fd(), &addr).unwrap();
+
+    let name = getsockopt(&fd, sockopt::UtunIfname)
+        .expect("getting UTUN_OPT_IFNAME on a utun interface should succeed");
+
+    let expected_name = format!("utun{}", unit - 1);
+    assert_eq!(name.into_string(), Ok(expected_name));
+}
+
+#[test]
+#[cfg(target_os = "freebsd")]
+fn test_reuseport_lb() {
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(&fd, sockopt::ReusePortLb, &false).unwrap();
+    assert!(!getsockopt(&fd, sockopt::ReusePortLb).unwrap());
+    setsockopt(&fd, sockopt::ReusePortLb, &true).unwrap();
+    assert!(getsockopt(&fd, sockopt::ReusePortLb).unwrap());
+}

notes-service/vendor/nix/test/sys/test_stat.rs

@@ -0,0 +1,29 @@
+// The conversion is not useless on all platforms.
+#[allow(clippy::useless_conversion)]
+#[cfg(target_os = "freebsd")]
+#[test]
+fn test_chflags() {
+    use nix::{
+        sys::stat::{fstat, FileFlag},
+        unistd::chflags,
+    };
+    use std::os::unix::io::AsRawFd;
+    use tempfile::NamedTempFile;
+
+    let f = NamedTempFile::new().unwrap();
+
+    let initial = FileFlag::from_bits_truncate(
+        fstat(f.as_raw_fd()).unwrap().st_flags.into(),
+    );
+    // UF_OFFLINE is preserved by all FreeBSD file systems, but not interpreted
+    // in any way, so it's handy for testing.
+    let commanded = initial ^ FileFlag::UF_OFFLINE;
+
+    chflags(f.path(), commanded).unwrap();
+
+    let changed = FileFlag::from_bits_truncate(
+        fstat(f.as_raw_fd()).unwrap().st_flags.into(),
+    );
+
+    assert_eq!(commanded, changed);
+}

notes-service/vendor/nix/test/sys/test_statfs.rs

@@ -0,0 +1,98 @@
+use nix::sys::statfs::*;
+use nix::sys::statvfs::*;
+use std::fs::File;
+use std::path::Path;
+
+fn check_fstatfs(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes()).unwrap();
+    let file = File::open(path).unwrap();
+    let fs = fstatfs(&file).unwrap();
+    assert_fs_equals(fs, vfs);
+}
+
+fn check_statfs(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes()).unwrap();
+    let fs = statfs(path.as_bytes()).unwrap();
+    assert_fs_equals(fs, vfs);
+}
+
+fn check_fstatfs_strict(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes());
+    let file = File::open(path).unwrap();
+    let fs = fstatfs(&file);
+    assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
+}
+
+fn check_statfs_strict(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes());
+    let fs = statfs(path.as_bytes());
+    assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
+}
+
+// The cast is not unnecessary on all platforms.
+#[allow(clippy::unnecessary_cast)]
+fn assert_fs_equals(fs: Statfs, vfs: Statvfs) {
+    assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
+    assert_eq!(fs.block_size() as u64, vfs.fragment_size() as u64);
+}
+
+#[test]
+fn statfs_call() {
+    check_statfs("/tmp");
+    check_statfs("/dev");
+    check_statfs("/run");
+    check_statfs("/");
+}
+
+#[test]
+fn fstatfs_call() {
+    check_fstatfs("/tmp");
+    check_fstatfs("/dev");
+    check_fstatfs("/run");
+    check_fstatfs("/");
+}
+
+// This test is ignored because files_free/blocks_free can change after statvfs call and before
+// statfs call.
+#[test]
+#[ignore]
+fn statfs_call_strict() {
+    check_statfs_strict("/tmp");
+    check_statfs_strict("/dev");
+    check_statfs_strict("/run");
+    check_statfs_strict("/");
+}
+
+// This test is ignored because files_free/blocks_free can change after statvfs call and before
+// fstatfs call.
+#[test]
+#[ignore]
+fn fstatfs_call_strict() {
+    check_fstatfs_strict("/tmp");
+    check_fstatfs_strict("/dev");
+    check_fstatfs_strict("/run");
+    check_fstatfs_strict("/");
+}
+
+// The cast is not unnecessary on all platforms.
+#[allow(clippy::unnecessary_cast)]
+fn assert_fs_equals_strict(fs: Statfs, vfs: Statvfs) {
+    assert_eq!(fs.files_free() as u64, vfs.files_free() as u64);
+    assert_eq!(fs.blocks_free() as u64, vfs.blocks_free() as u64);
+    assert_eq!(fs.blocks_available() as u64, vfs.blocks_available() as u64);
+    assert_eq!(fs.files() as u64, vfs.files() as u64);
+    assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
+    assert_eq!(fs.block_size() as u64, vfs.fragment_size() as u64);
+}

notes-service/vendor/nix/test/sys/test_statvfs.rs

@@ -0,0 +1,13 @@
+use nix::sys::statvfs::*;
+use std::fs::File;
+
+#[test]
+fn statvfs_call() {
+    statvfs(&b"/"[..]).unwrap();
+}
+
+#[test]
+fn fstatvfs_call() {
+    let root = File::open("/").unwrap();
+    fstatvfs(&root).unwrap();
+}

notes-service/vendor/nix/test/sys/test_sysinfo.rs

@@ -0,0 +1,20 @@
+use nix::sys::sysinfo::*;
+
+#[test]
+fn sysinfo_works() {
+    let info = sysinfo().unwrap();
+
+    let (l1, l5, l15) = info.load_average();
+    assert!(l1 >= 0.0);
+    assert!(l5 >= 0.0);
+    assert!(l15 >= 0.0);
+
+    info.uptime(); // just test Duration construction
+
+    assert!(
+        info.swap_free() <= info.swap_total(),
+        "more swap available than installed (free: {}, total: {})",
+        info.swap_free(),
+        info.swap_total()
+    );
+}

notes-service/vendor/nix/test/sys/test_termios.rs

@@ -0,0 +1,116 @@
+use std::os::unix::io::{AsFd, AsRawFd};
+use tempfile::tempfile;
+
+use nix::errno::Errno;
+use nix::fcntl;
+use nix::pty::openpty;
+use nix::sys::termios::{self, tcgetattr, BaudRate, LocalFlags, OutputFlags};
+use nix::unistd::{read, write};
+
+/// Helper function analogous to `std::io::Write::write_all`, but for `Fd`s
+fn write_all<Fd: AsFd>(f: Fd, buf: &[u8]) {
+    let mut len = 0;
+    while len < buf.len() {
+        len += write(f.as_fd(), &buf[len..]).unwrap();
+    }
+}
+
+#[test]
+fn test_baudrate_try_from() {
+    assert_eq!(Ok(BaudRate::B0), BaudRate::try_from(libc::B0));
+    #[cfg(not(target_os = "haiku"))]
+    BaudRate::try_from(999999999).expect_err("assertion failed");
+    #[cfg(target_os = "haiku")]
+    BaudRate::try_from(99).expect_err("assertion failed");
+}
+
+// Test tcgetattr on a terminal
+#[test]
+fn test_tcgetattr_pty() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    let pty = openpty(None, None).expect("openpty failed");
+    termios::tcgetattr(&pty.slave).unwrap();
+}
+
+// Test tcgetattr on something that isn't a terminal
+#[test]
+fn test_tcgetattr_enotty() {
+    let file = tempfile().unwrap();
+    assert_eq!(termios::tcgetattr(&file).err(), Some(Errno::ENOTTY));
+}
+
+// Test modifying output flags
+#[test]
+fn test_output_flags() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    // Open one pty to get attributes for the second one
+    let mut termios = {
+        let pty = openpty(None, None).expect("openpty failed");
+        tcgetattr(&pty.slave).expect("tcgetattr failed")
+    };
+
+    // Make sure postprocessing '\r' isn't specified by default or this test is useless.
+    assert!(!termios
+        .output_flags
+        .contains(OutputFlags::OPOST | OutputFlags::OCRNL));
+
+    // Specify that '\r' characters should be transformed to '\n'
+    // OPOST is specified to enable post-processing
+    termios
+        .output_flags
+        .insert(OutputFlags::OPOST | OutputFlags::OCRNL);
+
+    // Open a pty
+    let pty = openpty(None, &termios).unwrap();
+
+    // Write into the master
+    let string = "foofoofoo\r";
+    write_all(&pty.master, string.as_bytes());
+
+    // Read from the slave verifying that the output has been properly transformed
+    let mut buf = [0u8; 10];
+    crate::read_exact(&pty.slave, &mut buf);
+    let transformed_string = "foofoofoo\n";
+    assert_eq!(&buf, transformed_string.as_bytes());
+}
+
+// Test modifying local flags
+#[test]
+fn test_local_flags() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    // Open one pty to get attributes for the second one
+    let mut termios = {
+        let pty = openpty(None, None).unwrap();
+        tcgetattr(&pty.slave).unwrap()
+    };
+
+    // Make sure echo is specified by default or this test is useless.
+    assert!(termios.local_flags.contains(LocalFlags::ECHO));
+
+    // Disable local echo
+    termios.local_flags.remove(LocalFlags::ECHO);
+
+    // Open a new pty with our modified termios settings
+    let pty = openpty(None, &termios).unwrap();
+
+    // Set the master is in nonblocking mode or reading will never return.
+    let flags = fcntl::fcntl(pty.master.as_raw_fd(), fcntl::F_GETFL).unwrap();
+    let new_flags =
+        fcntl::OFlag::from_bits_truncate(flags) | fcntl::OFlag::O_NONBLOCK;
+    fcntl::fcntl(pty.master.as_raw_fd(), fcntl::F_SETFL(new_flags)).unwrap();
+
+    // Write into the master
+    let string = "foofoofoo\r";
+    write_all(&pty.master, string.as_bytes());
+
+    // Try to read from the master, which should not have anything as echoing was disabled.
+    let mut buf = [0u8; 10];
+    let read = read(pty.master.as_raw_fd(), &mut buf).unwrap_err();
+    assert_eq!(read, Errno::EAGAIN);
+}

notes-service/vendor/nix/test/sys/test_time.rs

@@ -0,0 +1,91 @@
+use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
+use std::time::Duration;
+
+#[test]
+pub fn test_timespec() {
+    assert_ne!(TimeSpec::seconds(1), TimeSpec::zero());
+    assert_eq!(
+        TimeSpec::seconds(1) + TimeSpec::seconds(2),
+        TimeSpec::seconds(3)
+    );
+    assert_eq!(
+        TimeSpec::minutes(3) + TimeSpec::seconds(2),
+        TimeSpec::seconds(182)
+    );
+}
+
+#[test]
+pub fn test_timespec_from() {
+    let duration = Duration::new(123, 123_456_789);
+    let timespec = TimeSpec::nanoseconds(123_123_456_789);
+
+    assert_eq!(TimeSpec::from(duration), timespec);
+    assert_eq!(Duration::from(timespec), duration);
+}
+
+#[test]
+pub fn test_timespec_neg() {
+    let a = TimeSpec::seconds(1) + TimeSpec::nanoseconds(123);
+    let b = TimeSpec::seconds(-1) + TimeSpec::nanoseconds(-123);
+
+    assert_eq!(a, -b);
+}
+
+#[test]
+pub fn test_timespec_ord() {
+    assert_eq!(TimeSpec::seconds(1), TimeSpec::nanoseconds(1_000_000_000));
+    assert!(TimeSpec::seconds(1) < TimeSpec::nanoseconds(1_000_000_001));
+    assert!(TimeSpec::seconds(1) > TimeSpec::nanoseconds(999_999_999));
+    assert!(TimeSpec::seconds(-1) < TimeSpec::nanoseconds(-999_999_999));
+    assert!(TimeSpec::seconds(-1) > TimeSpec::nanoseconds(-1_000_000_001));
+}
+
+#[test]
+pub fn test_timespec_fmt() {
+    assert_eq!(TimeSpec::zero().to_string(), "0 seconds");
+    assert_eq!(TimeSpec::seconds(42).to_string(), "42 seconds");
+    assert_eq!(TimeSpec::milliseconds(42).to_string(), "0.042 seconds");
+    assert_eq!(TimeSpec::microseconds(42).to_string(), "0.000042 seconds");
+    assert_eq!(TimeSpec::nanoseconds(42).to_string(), "0.000000042 seconds");
+    assert_eq!(TimeSpec::seconds(-86401).to_string(), "-86401 seconds");
+}
+
+#[test]
+pub fn test_timeval() {
+    assert_ne!(TimeVal::seconds(1), TimeVal::zero());
+    assert_eq!(
+        TimeVal::seconds(1) + TimeVal::seconds(2),
+        TimeVal::seconds(3)
+    );
+    assert_eq!(
+        TimeVal::minutes(3) + TimeVal::seconds(2),
+        TimeVal::seconds(182)
+    );
+}
+
+#[test]
+pub fn test_timeval_ord() {
+    assert_eq!(TimeVal::seconds(1), TimeVal::microseconds(1_000_000));
+    assert!(TimeVal::seconds(1) < TimeVal::microseconds(1_000_001));
+    assert!(TimeVal::seconds(1) > TimeVal::microseconds(999_999));
+    assert!(TimeVal::seconds(-1) < TimeVal::microseconds(-999_999));
+    assert!(TimeVal::seconds(-1) > TimeVal::microseconds(-1_000_001));
+}
+
+#[test]
+pub fn test_timeval_neg() {
+    let a = TimeVal::seconds(1) + TimeVal::microseconds(123);
+    let b = TimeVal::seconds(-1) + TimeVal::microseconds(-123);
+
+    assert_eq!(a, -b);
+}
+
+#[test]
+pub fn test_timeval_fmt() {
+    assert_eq!(TimeVal::zero().to_string(), "0 seconds");
+    assert_eq!(TimeVal::seconds(42).to_string(), "42 seconds");
+    assert_eq!(TimeVal::milliseconds(42).to_string(), "0.042 seconds");
+    assert_eq!(TimeVal::microseconds(42).to_string(), "0.000042 seconds");
+    assert_eq!(TimeVal::nanoseconds(1402).to_string(), "0.000001 seconds");
+    assert_eq!(TimeVal::seconds(-86401).to_string(), "-86401 seconds");
+}

notes-service/vendor/nix/test/sys/test_timer.rs

@@ -0,0 +1,102 @@
+use nix::sys::signal::{
+    sigaction, SaFlags, SigAction, SigEvent, SigHandler, SigSet, SigevNotify,
+    Signal,
+};
+use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
+use nix::time::ClockId;
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+use std::time::{Duration, Instant};
+
+const SIG: Signal = Signal::SIGALRM;
+static ALARM_CALLED: AtomicBool = AtomicBool::new(false);
+
+pub extern "C" fn handle_sigalarm(raw_signal: libc::c_int) {
+    let signal = Signal::try_from(raw_signal).unwrap();
+    if signal == SIG {
+        ALARM_CALLED.store(true, Ordering::Release);
+    }
+}
+
+#[test]
+fn alarm_fires() {
+    // Avoid interfering with other signal using tests by taking a mutex shared
+    // among other tests in this crate.
+    let _m = crate::SIGNAL_MTX.lock();
+    const TIMER_PERIOD: Duration = Duration::from_millis(100);
+
+    //
+    // Setup
+    //
+
+    // Create a handler for the test signal, `SIG`. The handler is responsible
+    // for flipping `ALARM_CALLED`.
+    let handler = SigHandler::Handler(handle_sigalarm);
+    let signal_action =
+        SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
+    let old_handler = unsafe {
+        sigaction(SIG, &signal_action)
+            .expect("unable to set signal handler for alarm")
+    };
+
+    // Create the timer. We use the monotonic clock here, though any would do
+    // really. The timer is set to fire every 250 milliseconds with no delay for
+    // the initial firing.
+    let clockid = ClockId::CLOCK_MONOTONIC;
+    let sigevent = SigEvent::new(SigevNotify::SigevSignal {
+        signal: SIG,
+        si_value: 0,
+    });
+    let mut timer =
+        Timer::new(clockid, sigevent).expect("failed to create timer");
+    let expiration = Expiration::Interval(TIMER_PERIOD.into());
+    let flags = TimerSetTimeFlags::empty();
+    timer.set(expiration, flags).expect("could not set timer");
+
+    //
+    // Test
+    //
+
+    // Determine that there's still an expiration tracked by the
+    // timer. Depending on when this runs either an `Expiration::Interval` or
+    // `Expiration::IntervalDelayed` will be present. That is, if the timer has
+    // not fired yet we'll get our original `expiration`, else the one that
+    // represents a delay to the next expiration. We're only interested in the
+    // timer still being extant.
+    match timer.get() {
+        Ok(Some(exp)) => assert!(matches!(
+            exp,
+            Expiration::Interval(..) | Expiration::IntervalDelayed(..)
+        )),
+        _ => panic!("timer lost its expiration"),
+    }
+
+    // Wait for 2 firings of the alarm before checking that it has fired and
+    // been handled at least the once. If we wait for 3 seconds and the handler
+    // is never called something has gone sideways and the test fails.
+    let starttime = Instant::now();
+    loop {
+        thread::sleep(2 * TIMER_PERIOD);
+        if ALARM_CALLED.load(Ordering::Acquire) {
+            break;
+        }
+        if starttime.elapsed() > Duration::from_secs(3) {
+            panic!("Timeout waiting for SIGALRM");
+        }
+    }
+
+    // Cleanup:
+    // 1) deregister the OS's timer.
+    // 2) Wait for a full timer period, since POSIX does not require that
+    //    disabling the timer will clear pending signals, and on NetBSD at least
+    //    it does not.
+    // 2) Replace the old signal handler now that we've completed the test. If
+    //    the test fails this process panics, so the fact we might not get here
+    //    is okay.
+    drop(timer);
+    thread::sleep(TIMER_PERIOD);
+    unsafe {
+        sigaction(SIG, &old_handler).expect("unable to reset signal handler");
+    }
+}

notes-service/vendor/nix/test/sys/test_timerfd.rs

@@ -0,0 +1,69 @@
+use nix::sys::time::{TimeSpec, TimeValLike};
+use nix::sys::timerfd::{
+    ClockId, Expiration, TimerFd, TimerFlags, TimerSetTimeFlags,
+};
+use std::time::Instant;
+
+#[test]
+pub fn test_timerfd_oneshot() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    let before = Instant::now();
+
+    timer
+        .set(
+            Expiration::OneShot(TimeSpec::seconds(1)),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.wait().unwrap();
+
+    let millis = before.elapsed().as_millis();
+    assert!(millis > 900);
+}
+
+#[test]
+pub fn test_timerfd_interval() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    let before = Instant::now();
+    timer
+        .set(
+            Expiration::IntervalDelayed(
+                TimeSpec::seconds(1),
+                TimeSpec::seconds(2),
+            ),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.wait().unwrap();
+
+    let start_delay = before.elapsed().as_millis();
+    assert!(start_delay > 900);
+
+    timer.wait().unwrap();
+
+    let interval_delay = before.elapsed().as_millis();
+    assert!(interval_delay > 2900);
+}
+
+#[test]
+pub fn test_timerfd_unset() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    timer
+        .set(
+            Expiration::OneShot(TimeSpec::seconds(1)),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.unset().unwrap();
+
+    assert!(timer.get().unwrap().is_none());
+}

notes-service/vendor/nix/test/sys/test_uio.rs

@@ -0,0 +1,275 @@
+use nix::sys::uio::*;
+use nix::unistd::*;
+use rand::distributions::Alphanumeric;
+use rand::{thread_rng, Rng};
+use std::fs::OpenOptions;
+use std::io::IoSlice;
+use std::os::unix::io::AsRawFd;
+use std::{cmp, iter};
+
+#[cfg(not(target_os = "redox"))]
+use std::io::IoSliceMut;
+
+use tempfile::tempdir;
+#[cfg(not(target_os = "redox"))]
+use tempfile::tempfile;
+
+#[test]
+fn test_writev() {
+    let mut to_write = Vec::with_capacity(16 * 128);
+    for _ in 0..16 {
+        let s: String = thread_rng()
+            .sample_iter(&Alphanumeric)
+            .map(char::from)
+            .take(128)
+            .collect();
+        let b = s.as_bytes();
+        to_write.extend(b.iter().cloned());
+    }
+    // Allocate and fill iovecs
+    let mut iovecs = Vec::new();
+    let mut consumed = 0;
+    while consumed < to_write.len() {
+        let left = to_write.len() - consumed;
+        let slice_len = if left <= 64 {
+            left
+        } else {
+            thread_rng().gen_range(64..cmp::min(256, left))
+        };
+        let b = &to_write[consumed..consumed + slice_len];
+        iovecs.push(IoSlice::new(b));
+        consumed += slice_len;
+    }
+    let (reader, writer) = pipe().expect("Couldn't create pipe");
+    // FileDesc will close its filedesc (reader).
+    let mut read_buf: Vec<u8> = iter::repeat(0u8).take(128 * 16).collect();
+
+    // Blocking io, should write all data.
+    let write_res = writev(&writer, &iovecs);
+    let written = write_res.expect("couldn't write");
+    // Check whether we written all data
+    assert_eq!(to_write.len(), written);
+    let read_res = read(reader.as_raw_fd(), &mut read_buf[..]);
+    let read = read_res.expect("couldn't read");
+    // Check we have read as much as we written
+    assert_eq!(read, written);
+    // Check equality of written and read data
+    assert_eq!(&to_write, &read_buf);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_readv() {
+    let s: String = thread_rng()
+        .sample_iter(&Alphanumeric)
+        .map(char::from)
+        .take(128)
+        .collect();
+    let to_write = s.as_bytes().to_vec();
+    let mut storage = Vec::new();
+    let mut allocated = 0;
+    while allocated < to_write.len() {
+        let left = to_write.len() - allocated;
+        let vec_len = if left <= 64 {
+            left
+        } else {
+            thread_rng().gen_range(64..cmp::min(256, left))
+        };
+        let v: Vec<u8> = iter::repeat(0u8).take(vec_len).collect();
+        storage.push(v);
+        allocated += vec_len;
+    }
+    let mut iovecs = Vec::with_capacity(storage.len());
+    for v in &mut storage {
+        iovecs.push(IoSliceMut::new(&mut v[..]));
+    }
+    let (reader, writer) = pipe().expect("couldn't create pipe");
+    // Blocking io, should write all data.
+    write(writer, &to_write).expect("write failed");
+
+    let read = readv(&reader, &mut iovecs[..]).expect("read failed");
+    // Check whether we've read all data
+    assert_eq!(to_write.len(), read);
+    // Cccumulate data from iovecs
+    let mut read_buf = Vec::with_capacity(to_write.len());
+    for iovec in &iovecs {
+        read_buf.extend(iovec.iter().cloned());
+    }
+    // Check whether iovecs contain all written data
+    assert_eq!(read_buf.len(), to_write.len());
+    // Check equality of written and read data
+    assert_eq!(&read_buf, &to_write);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_pwrite() {
+    use std::io::Read;
+
+    let mut file = tempfile().unwrap();
+    let buf = [1u8; 8];
+    assert_eq!(Ok(8), pwrite(&file, &buf, 8));
+    let mut file_content = Vec::new();
+    file.read_to_end(&mut file_content).unwrap();
+    let mut expected = vec![0u8; 8];
+    expected.extend(vec![1; 8]);
+    assert_eq!(file_content, expected);
+}
+
+#[test]
+fn test_pread() {
+    use std::io::Write;
+
+    let tempdir = tempdir().unwrap();
+
+    let path = tempdir.path().join("pread_test_file");
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+    let file_content: Vec<u8> = (0..64).collect();
+    file.write_all(&file_content).unwrap();
+
+    let mut buf = [0u8; 16];
+    assert_eq!(Ok(16), pread(&file, &mut buf, 16));
+    let expected: Vec<_> = (16..32).collect();
+    assert_eq!(&buf[..], &expected[..]);
+}
+
+#[test]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "haiku",
+    target_os = "solaris"
+)))]
+fn test_pwritev() {
+    use std::io::Read;
+
+    let to_write: Vec<u8> = (0..128).collect();
+    let expected: Vec<u8> = [vec![0; 100], to_write.clone()].concat();
+
+    let iovecs = [
+        IoSlice::new(&to_write[0..17]),
+        IoSlice::new(&to_write[17..64]),
+        IoSlice::new(&to_write[64..128]),
+    ];
+
+    let tempdir = tempdir().unwrap();
+
+    // pwritev them into a temporary file
+    let path = tempdir.path().join("pwritev_test_file");
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+
+    let written = pwritev(&file, &iovecs, 100).ok().unwrap();
+    assert_eq!(written, to_write.len());
+
+    // Read the data back and make sure it matches
+    let mut contents = Vec::new();
+    file.read_to_end(&mut contents).unwrap();
+    assert_eq!(contents, expected);
+}
+
+#[test]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "haiku",
+    target_os = "solaris"
+)))]
+fn test_preadv() {
+    use std::io::Write;
+
+    let to_write: Vec<u8> = (0..200).collect();
+    let expected: Vec<u8> = (100..200).collect();
+
+    let tempdir = tempdir().unwrap();
+
+    let path = tempdir.path().join("preadv_test_file");
+
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+    file.write_all(&to_write).unwrap();
+
+    let mut buffers: Vec<Vec<u8>> = vec![vec![0; 24], vec![0; 1], vec![0; 75]];
+
+    {
+        // Borrow the buffers into IoVecs and preadv into them
+        let mut iovecs: Vec<_> = buffers
+            .iter_mut()
+            .map(|buf| IoSliceMut::new(&mut buf[..]))
+            .collect();
+        assert_eq!(Ok(100), preadv(&file, &mut iovecs, 100));
+    }
+
+    let all = buffers.concat();
+    assert_eq!(all, expected);
+}
+
+#[test]
+#[cfg(all(target_os = "linux", not(target_env = "uclibc")))]
+// uclibc doesn't implement process_vm_readv
+// qemu-user doesn't implement process_vm_readv/writev on most arches
+#[cfg_attr(qemu, ignore)]
+fn test_process_vm_readv() {
+    use crate::*;
+    use nix::sys::signal::*;
+    use nix::sys::wait::*;
+    use nix::unistd::ForkResult::*;
+    use std::os::unix::io::AsRawFd;
+
+    require_capability!("test_process_vm_readv", CAP_SYS_PTRACE);
+    let _m = crate::FORK_MTX.lock();
+
+    // Pre-allocate memory in the child, since allocation isn't safe
+    // post-fork (~= async-signal-safe)
+    let mut vector = vec![1u8, 2, 3, 4, 5];
+
+    let (r, w) = pipe().unwrap();
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Parent { child } => {
+            drop(w);
+            // wait for child
+            read(r.as_raw_fd(), &mut [0u8]).unwrap();
+            drop(r);
+
+            let ptr = vector.as_ptr() as usize;
+            let remote_iov = RemoteIoVec { base: ptr, len: 5 };
+            let mut buf = vec![0u8; 5];
+
+            let ret = process_vm_readv(
+                child,
+                &mut [IoSliceMut::new(&mut buf)],
+                &[remote_iov],
+            );
+
+            kill(child, SIGTERM).unwrap();
+            waitpid(child, None).unwrap();
+
+            assert_eq!(Ok(5), ret);
+            assert_eq!(20u8, buf.iter().sum());
+        }
+        Child => {
+            drop(r);
+            for i in &mut vector {
+                *i += 1;
+            }
+            let _ = write(w, b"\0");
+            loop {
+                pause();
+            }
+        }
+    }
+}

notes-service/vendor/nix/test/sys/test_utsname.rs

@@ -0,0 +1,17 @@
+#[cfg(target_os = "linux")]
+#[test]
+pub fn test_uname_linux() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "Linux");
+}
+
+#[cfg(apple_targets)]
+#[test]
+pub fn test_uname_darwin() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "Darwin");
+}
+
+#[cfg(target_os = "freebsd")]
+#[test]
+pub fn test_uname_freebsd() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "FreeBSD");
+}

notes-service/vendor/nix/test/sys/test_wait.rs

@@ -0,0 +1,267 @@
+use libc::_exit;
+use nix::errno::Errno;
+use nix::sys::signal::*;
+use nix::sys::wait::*;
+use nix::unistd::ForkResult::*;
+use nix::unistd::*;
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_wait_signal() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false))
+            );
+        }
+    }
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    //target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "mips64",
+    target_arch = "mips64r6"
+)))]
+fn test_waitid_signal() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false)),
+            );
+        }
+    }
+}
+
+#[test]
+fn test_wait_exit() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: Child only calls `_exit`, which is async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 12)));
+        }
+    }
+}
+
+#[cfg(not(target_os = "haiku"))]
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "mips64",
+    target_arch = "mips64r6"
+)))]
+fn test_waitid_exit() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: Child only calls `_exit`, which is async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Exited(child, 12)),
+            );
+        }
+    }
+}
+
+#[test]
+fn test_waitstatus_from_raw() {
+    let pid = Pid::from_raw(1);
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0002),
+        Ok(WaitStatus::Signaled(pid, Signal::SIGINT, false))
+    );
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0200),
+        Ok(WaitStatus::Exited(pid, 2))
+    );
+    assert_eq!(WaitStatus::from_raw(pid, 0x7f7f), Err(Errno::EINVAL));
+}
+
+#[test]
+fn test_waitstatus_pid() {
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.unwrap() {
+        Child => unsafe { _exit(0) },
+        Parent { child } => {
+            let status = waitpid(child, None).unwrap();
+            assert_eq!(status.pid(), Some(child));
+        }
+    }
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+fn test_waitid_pid() {
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.unwrap() {
+        Child => unsafe { _exit(0) },
+        Parent { child } => {
+            let status = waitid(Id::Pid(child), WaitPidFlag::WEXITED).unwrap();
+            assert_eq!(status.pid(), Some(child));
+        }
+    }
+}
+
+#[cfg(linux_android)]
+// FIXME: qemu-user doesn't implement ptrace on most arches
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod ptrace {
+    use crate::*;
+    use libc::_exit;
+    use nix::sys::ptrace::{self, Event, Options};
+    use nix::sys::signal::*;
+    use nix::sys::wait::*;
+    use nix::unistd::ForkResult::*;
+    use nix::unistd::*;
+
+    fn ptrace_child() -> ! {
+        ptrace::traceme().unwrap();
+        // As recommended by ptrace(2), raise SIGTRAP to pause the child
+        // until the parent is ready to continue
+        raise(SIGTRAP).unwrap();
+        unsafe { _exit(0) }
+    }
+
+    fn ptrace_wait_parent(child: Pid) {
+        // Wait for the raised SIGTRAP
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::Stopped(child, SIGTRAP))
+        );
+        // We want to test a syscall stop and a PTRACE_EVENT stop
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setoptions failed");
+
+        // First, stop on the next system call, which will be exit()
+        ptrace::syscall(child, None).expect("syscall failed");
+        assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
+        // Then get the ptrace event for the process exiting
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            ))
+        );
+        // Finally get the normal wait() result, now that the process has exited
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 0)));
+    }
+
+    #[cfg(not(target_env = "uclibc"))]
+    fn ptrace_waitid_parent(child: Pid) {
+        // Wait for the raised SIGTRAP
+        //
+        // Unlike waitpid(), waitid() can distinguish trap events from regular
+        // stop events, so unlike ptrace_wait_parent(), we get a PtraceEvent here
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(child, SIGTRAP, 0)),
+        );
+        // We want to test a syscall stop and a PTRACE_EVENT stop
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setopts failed");
+
+        // First, stop on the next system call, which will be exit()
+        ptrace::syscall(child, None).expect("syscall failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceSyscall(child)),
+        );
+        // Then get the ptrace event for the process exiting
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            )),
+        );
+        // Finally get the normal wait() result, now that the process has exited
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::Exited(child, 0)),
+        );
+    }
+
+    #[test]
+    fn test_wait_ptrace() {
+        require_capability!("test_wait_ptrace", CAP_SYS_PTRACE);
+        let _m = crate::FORK_MTX.lock();
+
+        match unsafe { fork() }.expect("Error: Fork Failed") {
+            Child => ptrace_child(),
+            Parent { child } => ptrace_wait_parent(child),
+        }
+    }
+
+    #[test]
+    #[cfg(not(target_env = "uclibc"))]
+    fn test_waitid_ptrace() {
+        require_capability!("test_waitid_ptrace", CAP_SYS_PTRACE);
+        let _m = crate::FORK_MTX.lock();
+
+        match unsafe { fork() }.expect("Error: Fork Failed") {
+            Child => ptrace_child(),
+            Parent { child } => ptrace_waitid_parent(child),
+        }
+    }
+}