Move all unit tests into tests modules. (#1405)

This makes the code more idiomatic. As discussed in rust-lang/cargo#10559,
the `use super::*;` pattern makes this style easier to use.

Author: sunfishcode

src/backend/libc/fs/dir.rs

@@ -449,44 +449,49 @@ fn check_dirent_layout(dirent: &c::dirent) {
     );
 }
 
-#[test]
-fn dir_iterator_handles_io_errors() {
-    // create a dir, keep the FD, then delete the dir
-    let tmp = tempfile::tempdir().unwrap();
-    let fd = crate::fs::openat(
-        crate::fs::CWD,
-        tmp.path(),
-        crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
-        crate::fs::Mode::empty(),
-    )
-    .unwrap();
-
-    let file_fd = crate::fs::openat(
-        &fd,
-        tmp.path().join("test.txt"),
-        crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
-        crate::fs::Mode::RWXU,
-    )
-    .unwrap();
-
-    let mut dir = Dir::read_from(&fd).unwrap();
-
-    // Reach inside the `Dir` and replace its directory with a file, which
-    // will cause the subsequent `readdir` to fail.
-    unsafe {
-        let raw_fd = c::dirfd(dir.libc_dir.as_ptr());
-        let mut owned_fd: crate::fd::OwnedFd = crate::fd::FromRawFd::from_raw_fd(raw_fd);
-        crate::io::dup2(&file_fd, &mut owned_fd).unwrap();
-        core::mem::forget(owned_fd);
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dir_iterator_handles_io_errors() {
+        // create a dir, keep the FD, then delete the dir
+        let tmp = tempfile::tempdir().unwrap();
+        let fd = crate::fs::openat(
+            crate::fs::CWD,
+            tmp.path(),
+            crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
+            crate::fs::Mode::empty(),
+        )
+        .unwrap();
+
+        let file_fd = crate::fs::openat(
+            &fd,
+            tmp.path().join("test.txt"),
+            crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
+            crate::fs::Mode::RWXU,
+        )
+        .unwrap();
+
+        let mut dir = Dir::read_from(&fd).unwrap();
+
+        // Reach inside the `Dir` and replace its directory with a file, which
+        // will cause the subsequent `readdir` to fail.
+        unsafe {
+            let raw_fd = c::dirfd(dir.libc_dir.as_ptr());
+            let mut owned_fd: crate::fd::OwnedFd = crate::fd::FromRawFd::from_raw_fd(raw_fd);
+            crate::io::dup2(&file_fd, &mut owned_fd).unwrap();
+            core::mem::forget(owned_fd);
+        }
 
-    // FreeBSD and macOS seem to read some directory entries before we call
-    // `.next()`.
-    #[cfg(any(apple, freebsdlike))]
-    {
-        dir.rewind();
-    }
+        // FreeBSD and macOS seem to read some directory entries before we call
+        // `.next()`.
+        #[cfg(any(apple, freebsdlike))]
+        {
+            dir.rewind();
+        }
 
-    assert!(matches!(dir.next(), Some(Err(_))));
-    assert!(dir.next().is_none());
+        assert!(matches!(dir.next(), Some(Err(_))));
+        assert!(dir.next().is_none());
+    }
 }

src/backend/libc/fs/syscalls.rs

@@ -2663,19 +2663,6 @@ fn fix_negative_stat_nsecs(mut stat: Stat) -> Stat {
     stat
 }
 
-#[test]
-fn test_sizes() {
-    #[cfg(linux_kernel)]
-    assert_eq_size!(c::loff_t, u64);
-
-    // Assert that `Timestamps` has the expected layout. If we're not fixing
-    // y2038, libc's type should match ours. If we are, it's smaller.
-    #[cfg(not(fix_y2038))]
-    assert_eq_size!([c::timespec; 2], Timestamps);
-    #[cfg(fix_y2038)]
-    assert!(core::mem::size_of::<[c::timespec; 2]>() < core::mem::size_of::<Timestamps>());
-}
-
 #[inline]
 #[cfg(linux_kernel)]
 pub(crate) fn inotify_init1(flags: super::inotify::CreateFlags) -> io::Result<OwnedFd> {
@@ -2711,3 +2698,21 @@ pub(crate) fn inotify_rm_watch(inot: BorrowedFd<'_>, wd: i32) -> io::Result<()>
     // SAFETY: The fd is valid and closing an arbitrary wd is valid.
     unsafe { ret(c::inotify_rm_watch(borrowed_fd(inot), wd)) }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sizes() {
+        #[cfg(linux_kernel)]
+        assert_eq_size!(c::loff_t, u64);
+
+        // Assert that `Timestamps` has the expected layout. If we're not fixing
+        // y2038, libc's type should match ours. If we are, it's smaller.
+        #[cfg(not(fix_y2038))]
+        assert_eq_size!([c::timespec; 2], Timestamps);
+        #[cfg(fix_y2038)]
+        assert!(core::mem::size_of::<[c::timespec; 2]>() < core::mem::size_of::<Timestamps>());
+    }
+}

src/backend/libc/pipe/types.rs

@@ -101,11 +101,17 @@ impl<'a> IoSliceRaw<'a> {
     }
 }
 
-#[cfg(not(any(apple, target_os = "wasi")))]
-#[test]
-fn test_types() {
-    assert_eq_size!(PipeFlags, c::c_int);
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[cfg(not(any(apple, target_os = "wasi")))]
+    #[test]
+    fn test_types() {
+        assert_eq_size!(PipeFlags, c::c_int);
 
-    #[cfg(linux_kernel)]
-    assert_eq_size!(SpliceFlags, c::c_int);
+        #[cfg(linux_kernel)]
+        assert_eq_size!(SpliceFlags, c::c_int);
+    }
 }

src/backend/libc/time/types.rs

@@ -165,9 +165,15 @@ pub enum TimerfdClockId {
     BoottimeAlarm = bitcast!(c::CLOCK_BOOTTIME_ALARM),
 }
 
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[test]
-fn test_types() {
-    assert_eq_size!(TimerfdFlags, c::c_int);
-    assert_eq_size!(TimerfdTimerFlags, c::c_int);
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[cfg(any(linux_kernel, target_os = "fuchsia"))]
+    #[test]
+    fn test_types() {
+        assert_eq_size!(TimerfdFlags, c::c_int);
+        assert_eq_size!(TimerfdTimerFlags, c::c_int);
+    }
 }

src/backend/linux_raw/fs/dir.rs

@@ -337,32 +337,37 @@ impl DirEntry {
     }
 }
 
-#[test]
-fn dir_iterator_handles_io_errors() {
-    // create a dir, keep the FD, then delete the dir
-    let tmp = tempfile::tempdir().unwrap();
-    let fd = crate::fs::openat(
-        crate::fs::CWD,
-        tmp.path(),
-        crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
-        crate::fs::Mode::empty(),
-    )
-    .unwrap();
-
-    let file_fd = crate::fs::openat(
-        &fd,
-        tmp.path().join("test.txt"),
-        crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
-        crate::fs::Mode::RWXU,
-    )
-    .unwrap();
-
-    let mut dir = Dir::read_from(&fd).unwrap();
-
-    // Reach inside the `Dir` and replace its directory with a file, which
-    // will cause the subsequent `getdents64` to fail.
-    crate::io::dup2(&file_fd, &mut dir.fd).unwrap();
-
-    assert!(matches!(dir.next(), Some(Err(_))));
-    assert!(dir.next().is_none());
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dir_iterator_handles_io_errors() {
+        // create a dir, keep the FD, then delete the dir
+        let tmp = tempfile::tempdir().unwrap();
+        let fd = crate::fs::openat(
+            crate::fs::CWD,
+            tmp.path(),
+            crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
+            crate::fs::Mode::empty(),
+        )
+        .unwrap();
+
+        let file_fd = crate::fs::openat(
+            &fd,
+            tmp.path().join("test.txt"),
+            crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
+            crate::fs::Mode::RWXU,
+        )
+        .unwrap();
+
+        let mut dir = Dir::read_from(&fd).unwrap();
+
+        // Reach inside the `Dir` and replace its directory with a file, which
+        // will cause the subsequent `getdents64` to fail.
+        crate::io::dup2(&file_fd, &mut dir.fd).unwrap();
+
+        assert!(matches!(dir.next(), Some(Err(_))));
+        assert!(dir.next().is_none());
+    }
 }

src/backend/linux_raw/fs/syscalls.rs

@@ -1657,16 +1657,6 @@ pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_fremovexattr, fd, name)) }
 }
 
-#[test]
-fn test_sizes() {
-    assert_eq_size!(linux_raw_sys::general::__kernel_loff_t, u64);
-    assert_eq_align!(linux_raw_sys::general::__kernel_loff_t, u64);
-
-    // Assert that `Timestamps` has the expected layout.
-    assert_eq_size!([linux_raw_sys::general::__kernel_timespec; 2], Timestamps);
-    assert_eq_align!([linux_raw_sys::general::__kernel_timespec; 2], Timestamps);
-}
-
 // Some linux_raw_sys structs have unsigned types for values which are
 // interpreted as signed. This defines a utility or casting to the
 // same-sized signed type.
@@ -1715,3 +1705,18 @@ mod to_signed {
     target_arch = "mips64r6"
 ))]
 use to_signed::*;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sizes() {
+        assert_eq_size!(linux_raw_sys::general::__kernel_loff_t, u64);
+        assert_eq_align!(linux_raw_sys::general::__kernel_loff_t, u64);
+
+        // Assert that `Timestamps` has the expected layout.
+        assert_eq_size!([linux_raw_sys::general::__kernel_timespec; 2], Timestamps);
+        assert_eq_align!([linux_raw_sys::general::__kernel_timespec; 2], Timestamps);
+    }
+}

src/backend/linux_raw/param/libc_auxv.rs

@@ -56,26 +56,6 @@ const _SC_CLK_TCK: c::c_int = 6;
 #[cfg(target_os = "linux")]
 const _SC_CLK_TCK: c::c_int = 2;
 
-#[test]
-fn test_abi() {
-    const_assert_eq!(self::_SC_PAGESIZE, ::libc::_SC_PAGESIZE);
-    const_assert_eq!(self::_SC_CLK_TCK, ::libc::_SC_CLK_TCK);
-    const_assert_eq!(self::AT_HWCAP, ::libc::AT_HWCAP);
-    const_assert_eq!(self::AT_HWCAP2, ::libc::AT_HWCAP2);
-    const_assert_eq!(self::AT_EXECFN, ::libc::AT_EXECFN);
-    const_assert_eq!(self::AT_SECURE, ::libc::AT_SECURE);
-    const_assert_eq!(self::AT_SYSINFO_EHDR, ::libc::AT_SYSINFO_EHDR);
-    const_assert_eq!(self::AT_MINSIGSTKSZ, ::libc::AT_MINSIGSTKSZ);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_PHDR, ::libc::AT_PHDR);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_PHNUM, ::libc::AT_PHNUM);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_ENTRY, ::libc::AT_ENTRY);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_RANDOM, ::libc::AT_RANDOM);
-}
-
 #[cfg(feature = "param")]
 #[inline]
 pub(crate) fn page_size() -> usize {
@@ -191,3 +171,28 @@ pub(crate) fn entry() -> usize {
 pub(crate) fn random() -> *const [u8; 16] {
     unsafe { getauxval(AT_RANDOM) as *const [u8; 16] }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_abi() {
+        const_assert_eq!(self::_SC_PAGESIZE, ::libc::_SC_PAGESIZE);
+        const_assert_eq!(self::_SC_CLK_TCK, ::libc::_SC_CLK_TCK);
+        const_assert_eq!(self::AT_HWCAP, ::libc::AT_HWCAP);
+        const_assert_eq!(self::AT_HWCAP2, ::libc::AT_HWCAP2);
+        const_assert_eq!(self::AT_EXECFN, ::libc::AT_EXECFN);
+        const_assert_eq!(self::AT_SECURE, ::libc::AT_SECURE);
+        const_assert_eq!(self::AT_SYSINFO_EHDR, ::libc::AT_SYSINFO_EHDR);
+        const_assert_eq!(self::AT_MINSIGSTKSZ, ::libc::AT_MINSIGSTKSZ);
+        #[cfg(feature = "runtime")]
+        const_assert_eq!(self::AT_PHDR, ::libc::AT_PHDR);
+        #[cfg(feature = "runtime")]
+        const_assert_eq!(self::AT_PHNUM, ::libc::AT_PHNUM);
+        #[cfg(feature = "runtime")]
+        const_assert_eq!(self::AT_ENTRY, ::libc::AT_ENTRY);
+        #[cfg(feature = "runtime")]
+        const_assert_eq!(self::AT_RANDOM, ::libc::AT_RANDOM);
+    }
+}