Ensure the makedev test does not emit unused errors

(backport <#4363>)
(cherry picked from commit a1a956d)

Author: tgross35

libc-test/Cargo.toml

@@ -12,10 +12,9 @@ description = """
 A test crate for the libc crate.
 """
 
-[dependencies.libc]
-path = ".."
-version = "0.2.171"
-default-features = false
+[dependencies]
+cfg-if = "1.0.0"
+libc = { path = "..", version = "0.2.171", default-features = false }
 
 [dev-dependencies]
 syn = { version = "2.0.91", features = ["full", "visit"] }

libc-test/test/makedev.rs

@@ -1,52 +1,7 @@
 //! Compare libc's makedev, major, minor functions against the actual C macros, for various
 //! inputs.
 
-#[cfg(any(target_os = "solaris", target_os = "illumos"))]
-mod ret {
-    pub type MajorRetType = libc::major_t;
-    pub type MinorRetType = libc::minor_t;
-}
-
-#[cfg(any(
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "aix",
-    target_os = "nto",
-    target_os = "hurd",
-    target_os = "openbsd",
-    target_os = "cygwin",
-))]
-mod ret {
-    pub type MajorRetType = libc::c_uint;
-    pub type MinorRetType = libc::c_uint;
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "netbsd",
-    target_os = "freebsd",
-))]
-mod ret {
-    pub type MajorRetType = libc::c_int;
-    pub type MinorRetType = libc::c_int;
-}
-
-#[cfg(any(
-    target_os = "macos",
-    target_os = "ios",
-    target_os = "tvos",
-    target_os = "watchos",
-    target_os = "visionos"
-))]
-mod ret {
-    pub type MajorRetType = i32;
-    pub type MinorRetType = i32;
-}
-
-#[cfg(any(
+#![cfg(any(
     target_os = "android",
     target_os = "dragonfly",
     target_os = "emscripten",
@@ -57,100 +12,134 @@ mod ret {
     target_os = "openbsd",
     target_os = "cygwin",
 ))]
-mod t {
-    use libc::{self, c_uint, dev_t};
 
-    use super::ret::*;
+use libc::{self, c_uint, dev_t};
 
-    extern "C" {
-        pub fn makedev_ffi(major: c_uint, minor: c_uint) -> dev_t;
-        pub fn major_ffi(dev: dev_t) -> c_uint;
-        pub fn minor_ffi(dev: dev_t) -> c_uint;
+cfg_if::cfg_if! {
+    if #[cfg(any(target_os = "solaris", target_os = "illumos"))] {
+        pub type MajorRetType = libc::major_t;
+        pub type MinorRetType = libc::minor_t;
+    } else if #[cfg(any(
+        target_os = "linux",
+        target_os = "l4re",
+        target_os = "emscripten",
+        target_os = "fuchsia",
+        target_os = "aix",
+        target_os = "nto",
+        target_os = "hurd",
+        target_os = "openbsd",
+        target_os = "cygwin",
+    ))] {
+        pub type MajorRetType = libc::c_uint;
+        pub type MinorRetType = libc::c_uint;
+    } else if #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "netbsd",
+        target_os = "freebsd",
+    ))] {
+        pub type MajorRetType = libc::c_int;
+        pub type MinorRetType = libc::c_int;
+    } else if #[cfg(any(
+        target_os = "macos",
+        target_os = "ios",
+        target_os = "tvos",
+        target_os = "watchos",
+        target_os = "visionos"
+    ))] {
+        pub type MajorRetType = i32;
+        pub type MinorRetType = i32;
     }
+}
 
-    fn compare(major: c_uint, minor: c_uint) {
-        let dev = unsafe { makedev_ffi(major, minor) };
-        assert_eq!(libc::makedev(major, minor), dev);
-        let major = unsafe { major_ffi(dev) };
-        assert_eq!(libc::major(dev), major as MajorRetType);
-        let minor = unsafe { minor_ffi(dev) };
-        assert_eq!(libc::minor(dev), minor as MinorRetType);
-    }
+extern "C" {
+    pub fn makedev_ffi(major: c_uint, minor: c_uint) -> dev_t;
+    pub fn major_ffi(dev: dev_t) -> c_uint;
+    pub fn minor_ffi(dev: dev_t) -> c_uint;
+}
 
-    // Every OS should be able to handle 8 bit major and minor numbers
-    #[test]
-    fn test_8bits() {
-        for major in 0..256 {
-            for minor in 0..256 {
-                compare(major, minor);
-            }
+fn compare(major: c_uint, minor: c_uint) {
+    let dev = unsafe { makedev_ffi(major, minor) };
+    assert_eq!(libc::makedev(major, minor), dev);
+    let major = unsafe { major_ffi(dev) };
+    assert_eq!(libc::major(dev), major as MajorRetType);
+    let minor = unsafe { minor_ffi(dev) };
+    assert_eq!(libc::minor(dev), minor as MinorRetType);
+}
+
+// Every OS should be able to handle 8 bit major and minor numbers
+#[test]
+fn test_8bits() {
+    for major in 0..256 {
+        for minor in 0..256 {
+            compare(major, minor);
         }
     }
+}
 
-    // Android allows 12 bits for major and 20 for minor
-    #[test]
-    #[cfg(target_os = "android")]
-    fn test_android_like() {
-        for major in [0, 1, 255, 256, 4095] {
-            for minor_exp in [1, 8, 16] {
-                for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
-                    compare(major, minor);
-                }
+// Android allows 12 bits for major and 20 for minor
+#[test]
+#[cfg(target_os = "android")]
+fn test_android_like() {
+    for major in [0, 1, 255, 256, 4095] {
+        for minor_exp in [1, 8, 16] {
+            for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
+                compare(major, minor);
             }
-            compare(major, (1 << 20) - 1);
         }
+        compare(major, (1 << 20) - 1);
     }
+}
 
-    // These OSes allow 32 bits for minor, but only 8 for major
-    #[test]
-    #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd",))]
-    fn test_fbsd11_like() {
-        for major in [0, 1, 255] {
-            for minor_exp in [1, 8, 16, 24, 31] {
-                for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
-                    compare(major, minor);
-                }
+// These OSes allow 32 bits for minor, but only 8 for major
+#[test]
+#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd",))]
+fn test_fbsd11_like() {
+    for major in [0, 1, 255] {
+        for minor_exp in [1, 8, 16, 24, 31] {
+            for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
+                compare(major, minor);
             }
-            compare(major, c_uint::MAX);
         }
+        compare(major, c_uint::MAX);
     }
+}
 
-    // OpenBSD allows 8 bits for major and 24 for minor
-    #[test]
-    #[cfg(target_os = "openbsd")]
-    fn test_openbsd_like() {
-        for major in [0, 1, 255] {
-            for minor_exp in [1, 8, 16] {
-                for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
-                    compare(major, minor);
-                }
+// OpenBSD allows 8 bits for major and 24 for minor
+#[test]
+#[cfg(target_os = "openbsd")]
+fn test_openbsd_like() {
+    for major in [0, 1, 255] {
+        for minor_exp in [1, 8, 16] {
+            for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
+                compare(major, minor);
             }
-            compare(major, (1 << 24) - 1);
         }
+        compare(major, (1 << 24) - 1);
     }
+}
 
-    // These OSes allow 32 bits for both minor and major
-    #[cfg(any(
-        target_os = "emscripten",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "cygwin",
-    ))]
-    #[test]
-    fn test_fbsd12_like() {
-        if std::mem::size_of::<dev_t>() >= 8 {
-            for major_exp in [0, 16, 24, 31] {
-                for major in [(1 << major_exp) - 1, (1 << major_exp)] {
-                    for minor_exp in [1, 8, 16, 24, 31] {
-                        for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
-                            compare(major, minor);
-                        }
+// These OSes allow 32 bits for both minor and major
+#[cfg(any(
+    target_os = "emscripten",
+    target_os = "freebsd",
+    target_os = "fuchsia",
+    target_os = "linux",
+    target_os = "cygwin",
+))]
+#[test]
+fn test_fbsd12_like() {
+    if std::mem::size_of::<dev_t>() >= 8 {
+        for major_exp in [0, 16, 24, 31] {
+            for major in [(1 << major_exp) - 1, (1 << major_exp)] {
+                for minor_exp in [1, 8, 16, 24, 31] {
+                    for minor in [(1 << minor_exp) - 1, (1 << minor_exp)] {
+                        compare(major, minor);
                     }
-                    compare(major, c_uint::MAX);
                 }
-                compare(c_uint::MAX, c_uint::MAX);
+                compare(major, c_uint::MAX);
             }
+            compare(c_uint::MAX, c_uint::MAX);
         }
     }
 }