Remove more unsupported functions and make it possible to run tests

Author: AdminXVII

Cargo.toml

@@ -53,6 +53,6 @@ name = "test-mount"
 path = "test/test_mount.rs"
 harness = false
 
-[[test]]
+[[target.'cfg(not(target_os = "redox"))'.test]]
 name = "test-ptymaster-drop"
 path = "test/test_ptymaster_drop.rs"

src/dir.rs

@@ -1,17 +1,25 @@
+#[cfg(not(target_os = "redox"))]
 use {Error, NixPath, Result};
+#[cfg(not(target_os = "redox"))]
 use errno::Errno;
+#[cfg(not(target_os = "redox"))]
 use fcntl::{self, OFlag};
 use libc;
-use std::os::unix::io::{IntoRawFd, RawFd};
 #[cfg(not(target_os = "redox"))]
-use std::os::unix::io::AsRawFd;
-use std::{ffi, ptr};
+use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+#[cfg(not(target_os = "redox"))]
+use std::ptr;
+use std::ffi;
+#[cfg(not(target_os = "redox"))]
 use sys;
 
 #[cfg(target_os = "linux")]
 use libc::{dirent64 as dirent, readdir64_r as readdir_r};
 
-#[cfg(not(target_os = "linux"))]
+#[cfg(target_os = "redox")]
+use libc::dirent;
+
+#[cfg(not(any(target_os = "linux", target_os = "redox")))]
 use libc::{dirent, readdir_r};
 
 /// An open directory.
@@ -28,10 +36,12 @@ use libc::{dirent, readdir_r};
 ///    * returns entries' names as a `CStr` (no allocation or conversion beyond whatever libc
 ///      does).
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[cfg(not(target_os = "redox"))]
 pub struct Dir(
     ptr::NonNull<libc::DIR>
 );
 
+#[cfg(not(target_os = "redox"))]
 impl Dir {
     /// Opens the given path as with `fcntl::open`.
     pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag,
@@ -77,6 +87,7 @@ impl Dir {
 // call `readdir` simultaneously from multiple threads.
 //
 // `Dir` is safe to pass from one thread to another, as it's not reference-counted.
+#[cfg(not(target_os = "redox"))]
 unsafe impl Send for Dir {}
 
 #[cfg(not(target_os = "redox"))]
@@ -86,15 +97,18 @@ impl AsRawFd for Dir {
     }
 }
 
+#[cfg(not(target_os = "redox"))]
 impl Drop for Dir {
     fn drop(&mut self) {
         unsafe { libc::closedir(self.0.as_ptr()) };
     }
 }
 
 #[derive(Debug, Eq, Hash, PartialEq)]
+#[cfg(not(target_os = "redox"))]
 pub struct Iter<'d>(&'d mut Dir);
 
+#[cfg(not(target_os = "redox"))]
 impl<'d> Iterator for Iter<'d> {
     type Item = Result<Entry>;
 
@@ -119,6 +133,7 @@ impl<'d> Iterator for Iter<'d> {
     }
 }
 
+#[cfg(not(target_os = "redox"))]
 impl<'d> Drop for Iter<'d> {
     fn drop(&mut self) {
         unsafe { libc::rewinddir((self.0).0.as_ptr()) }

src/fcntl.rs

@@ -165,6 +165,7 @@ pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag, mode: Mode) -> Result<R
     Errno::result(fd)
 }
 
+#[cfg(not(target_os = "redox"))]
 pub fn openat<P: ?Sized + NixPath>(dirfd: RawFd, path: &P, oflag: OFlag, mode: Mode) -> Result<RawFd> {
     let fd = path.with_nix_path(|cstr| {
         unsafe { libc::openat(dirfd, cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint) }
@@ -194,6 +195,7 @@ pub fn readlink<'a, P: ?Sized + NixPath>(path: &P, buffer: &'a mut [u8]) -> Resu
 }
 
 
+#[cfg(not(target_os = "redox"))]
 pub fn readlinkat<'a, P: ?Sized + NixPath>(dirfd: RawFd, path: &P, buffer: &'a mut [u8]) -> Result<&'a OsStr> {
     let res = path.with_nix_path(|cstr| {
         unsafe { libc::readlinkat(dirfd, cstr.as_ptr(), buffer.as_mut_ptr() as *mut c_char, buffer.len() as size_t) }

src/sys/signal.rs

@@ -452,6 +452,7 @@ impl SigSet {
 
     /// Suspends execution of the calling thread until one of the signals in the
     /// signal mask becomes pending, and returns the accepted signal.
+    #[cfg(not(target_os = "redox"))]
     pub fn wait(&self) -> Result<Signal> {
         let mut signum: libc::c_int = unsafe { mem::uninitialized() };
         let res = unsafe { libc::sigwait(&self.sigset as *const libc::sigset_t, &mut signum) };
@@ -863,6 +864,7 @@ mod sigevent {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(target_os = "redox"))]
     use std::thread;
     use super::*;
 
@@ -918,6 +920,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_thread_signal_set_mask() {
         thread::spawn(|| {
             let prev_mask = SigSet::thread_get_mask()
@@ -938,6 +941,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_thread_signal_block() {
         thread::spawn(|| {
             let mut mask = SigSet::empty();
@@ -950,6 +954,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_thread_signal_unblock() {
         thread::spawn(|| {
             let mut mask = SigSet::empty();
@@ -962,6 +967,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_thread_signal_swap() {
         thread::spawn(|| {
             let mut mask = SigSet::empty();
@@ -984,23 +990,14 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_sigaction() {
         use libc;
         thread::spawn(|| {
             extern fn test_sigaction_handler(_: libc::c_int) {}
-            #[cfg(not(target_os = "redox"))]
             extern fn test_sigaction_action(_: libc::c_int,
                 _: *mut libc::siginfo_t, _: *mut libc::c_void) {}
 
-            #[cfg(not(target_os = "redox"))]
-            fn test_sigaction_sigaction(flags: SaFlags, mask: SigSet) {
-                let handler_act = SigHandler::SigAction(test_sigaction_action);
-                let action_act = SigAction::new(handler_act, flags, mask);
-                assert_eq!(action_act.handler(), handler_act);
-            }
-            #[cfg(target_os = "redox")]
-            fn test_sigaction_sigaction() {}
-
             let handler_sig = SigHandler::Handler(test_sigaction_handler);
 
             let flags = SaFlags::SA_ONSTACK | SaFlags::SA_RESTART |
@@ -1019,7 +1016,9 @@ mod tests {
             assert!(mask.contains(SIGUSR1));
             assert!(!mask.contains(SIGUSR2));
 
-            test_sigaction_sigaction(flags, mask);
+            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);
@@ -1030,6 +1029,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(target_os = "redox"))]
     fn test_sigwait() {
         thread::spawn(|| {
             let mut mask = SigSet::empty();

src/sys/stat.rs

@@ -289,6 +289,7 @@ pub fn utimensat<P: ?Sized + NixPath>(
     Errno::result(res).map(drop)
 }
 
+#[cfg(not(target_os = "redox"))]
 pub fn mkdirat<P: ?Sized + NixPath>(fd: RawFd, path: &P, mode: Mode) -> Result<()> {
     let res = path.with_nix_path(|cstr| {
         unsafe { libc::mkdirat(fd, cstr.as_ptr(), mode.bits() as mode_t) }

src/unistd.rs

@@ -291,6 +291,7 @@ pub fn setsid() -> Result<Pid> {
 /// Obtain the process group ID of the process that is the session leader of the process specified
 /// by pid. If pid is zero, it specifies the calling process.
 #[inline]
+#[cfg(not(target_os = "redox"))]
 pub fn getsid(pid: Option<Pid>) -> Result<Pid> {
     let res = unsafe { libc::getsid(pid.unwrap_or(Pid(0)).into()) };
     Errno::result(res).map(Pid)
@@ -1110,6 +1111,7 @@ fn pipe2_setflags(fd1: RawFd, fd2: RawFd, flags: OFlag) -> Result<()> {
 ///
 /// See also
 /// [truncate(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html)
+#[cfg(not(target_os = "redox"))]
 pub fn truncate<P: ?Sized + NixPath>(path: &P, len: off_t) -> Result<()> {
     let res = path.with_nix_path(|cstr| {
         unsafe {
@@ -1513,6 +1515,7 @@ pub fn initgroups(user: &CStr, group: Gid) -> Result<()> {
 ///
 /// See also [pause(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/pause.html).
 #[inline]
+#[cfg(not(target_os = "redox"))]
 pub fn pause() {
     unsafe { libc::pause() };
 }

test/sys/mod.rs

@@ -13,12 +13,17 @@ mod test_signal;
 mod test_aio;
 #[cfg(target_os = "linux")]
 mod test_signalfd;
+#[cfg(not(target_os = "redox"))]
 mod test_socket;
+#[cfg(not(target_os = "redox"))]
 mod test_sockopt;
+#[cfg(not(target_os = "redox"))]
 mod test_select;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod test_sysinfo;
+#[cfg(not(target_os = "redox"))]
 mod test_termios;
+#[cfg(not(target_os = "redox"))]
 mod test_ioctl;
 mod test_wait;
 mod test_uio;

test/sys/test_pthread.rs

@@ -1,13 +1,13 @@
 use nix::sys::pthread::*;
 
-#[cfg(target_env = "musl")]
+#[cfg(any(target_env = "musl", target_os = "redox"))]
 #[test]
 fn test_pthread_self() {
     let tid = pthread_self();
     assert!(tid != ::std::ptr::null_mut());
 }
 
-#[cfg(not(target_env = "musl"))]
+#[cfg(not(any(target_env = "musl", target_os = "redox")))]
 #[test]
 fn test_pthread_self() {
     let tid = pthread_self();

test/sys/test_signal.rs

@@ -79,7 +79,16 @@ extern fn test_sigaction_handler(signal: libc::c_int) {
     SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);
 }
 
-extern fn test_sigaction_action(_: libc::c_int, _: *mut libc::siginfo_t, _: *mut libc::c_void) {
+#[cfg(not(target_os = "redox"))]
+extern 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 = ::SIGNAL_MTX.lock().expect("Mutex got poisoned by another test");
+
+    let action_handler = SigHandler::SigAction(test_sigaction_action);
+    assert_eq!(unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(), Error::UnsupportedOperation);
 }
 
 #[test]
@@ -96,9 +105,6 @@ fn test_signal() {
     assert!(SIGNALED.load(Ordering::Relaxed));
     assert_eq!(unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(), handler);
 
-    let action_handler = SigHandler::SigAction(test_sigaction_action);
-    assert_eq!(unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(), Error::UnsupportedOperation);
-
     // Restore default signal handler
     unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
 }

test/sys/test_wait.rs

@@ -6,6 +6,7 @@ use nix::sys::wait::*;
 use libc::_exit;
 
 #[test]
+#[cfg(not(target_os = "redox"))]
 fn test_wait_signal() {
     let _ = ::FORK_MTX.lock().expect("Mutex got poisoned by another test");
 

test/test.rs

@@ -62,6 +62,7 @@ macro_rules! skip_if_not_root {
 }
 
 mod sys;
+#[cfg(not(target_os = "redox"))]
 mod test_dir;
 mod test_fcntl;
 #[cfg(any(target_os = "android",
@@ -73,9 +74,12 @@ mod test_kmod;
           target_os = "linux",
           target_os = "netbsd"))]
 mod test_mq;
+#[cfg(not(target_os = "redox"))]
 mod test_net;
 mod test_nix_path;
+#[cfg(not(target_os = "redox"))]
 mod test_poll;
+#[cfg(not(target_os = "redox"))]
 mod test_pty;
 #[cfg(any(target_os = "android",
           target_os = "freebsd",

test/test_fcntl.rs

@@ -1,11 +1,14 @@
-use nix::fcntl::{openat, open, OFlag, readlink, readlinkat};
+use nix::fcntl::{open, OFlag, readlink};
+#[cfg(not(target_os = "redox"))]
+use nix::fcntl::{openat, readlinkat};
 use nix::sys::stat::Mode;
 use nix::unistd::{close, read};
 use tempfile::{self, NamedTempFile};
 use std::io::prelude::*;
 use std::os::unix::fs;
 
 #[test]
+#[cfg(not(target_os = "redox"))]
 fn test_openat() {
     const CONTENTS: &[u8] = b"abcd";
     let mut tmp = NamedTempFile::new().unwrap();
@@ -28,6 +31,7 @@ fn test_openat() {
 }
 
 #[test]
+#[cfg(not(target_os = "redox"))]
 fn test_readlink() {
     let tempdir = tempfile::tempdir().unwrap();
     let src = tempdir.path().join("a");