Don't test on mips; replace unwrap for expect

1 files changed, 73 insertions, 60 deletions

diff --git a/test/test_fcntl.rs b/test/test_fcntl.rs
index 984b346d..7ea93f8e 100644
--- a/test/test_fcntl.rs
+++ b/test/test_fcntl.rs
@@ -1,12 +1,12 @@
-use nix::Error;
 use nix::errno::*;
-use nix::fcntl::{openat, open, OFlag, readlink, readlinkat, renameat};
+use nix::fcntl::{open, openat, readlink, readlinkat, renameat, OFlag};
 use nix::sys::stat::Mode;
 use nix::unistd::{close, read};
-use tempfile::{self, NamedTempFile};
+use nix::Error;
 use std::fs::File;
 use std::io::prelude::*;
 use std::os::unix::fs;
+use tempfile::{self, NamedTempFile};
 
 #[test]
 fn test_openat() {
@@ -14,13 +14,14 @@ fn test_openat() {
     let mut tmp = NamedTempFile::new().unwrap();
     tmp.write_all(CONTENTS).unwrap();
 
-    let dirfd = open(tmp.path().parent().unwrap(),
-                     OFlag::empty(),
-                     Mode::empty()).unwrap();
-    let fd = openat(dirfd,
-                    tmp.path().file_name().unwrap(),
-                    OFlag::O_RDONLY,
-                    Mode::empty()).unwrap();
+    let dirfd = open(tmp.path().parent().unwrap(), OFlag::empty(), Mode::empty()).unwrap();
+    let fd = openat(
+        dirfd,
+        tmp.path().file_name().unwrap(),
+        OFlag::O_RDONLY,
+        Mode::empty(),
+    )
+    .unwrap();
 
     let mut buf = [0u8; 1024];
     assert_eq!(4, read(fd, &mut buf).unwrap());
@@ -39,8 +40,10 @@ fn test_renameat() {
     let new_dir = tempfile::tempdir().unwrap();
     let new_dirfd = open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap();
-    assert_eq!(renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap_err(),
-               Error::Sys(Errno::ENOENT));
+    assert_eq!(
+        renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap_err(),
+        Error::Sys(Errno::ENOENT)
+    );
     close(old_dirfd).unwrap();
     close(new_dirfd).unwrap();
     assert!(new_dir.path().join("new").exists());
@@ -53,14 +56,14 @@ fn test_readlink() {
     let dst = tempdir.path().join("b");
     println!("a: {:?}, b: {:?}", &src, &dst);
     fs::symlink(&src.as_path(), &dst.as_path()).unwrap();
-    let dirfd = open(tempdir.path(),
-                     OFlag::empty(),
-                     Mode::empty()).unwrap();
+    let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let expected_dir = src.to_str().unwrap();
 
     assert_eq!(readlink(&dst).unwrap().to_str().unwrap(), expected_dir);
-    assert_eq!(readlinkat(dirfd, "b").unwrap().to_str().unwrap(), expected_dir);
-
+    assert_eq!(
+        readlinkat(dirfd, "b").unwrap().to_str().unwrap(),
+        expected_dir
+    );
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -125,8 +128,15 @@ mod linux_android {
 
         let (rd, wr) = pipe().unwrap();
         let mut offset: loff_t = 5;
-        let res = splice(tmp.as_raw_fd(), Some(&mut offset),
-            wr, None, 2, SpliceFFlags::empty()).unwrap();
+        let res = splice(
+            tmp.as_raw_fd(),
+            Some(&mut offset),
+            wr,
+            None,
+            2,
+            SpliceFFlags::empty(),
+        )
+        .unwrap();
 
         assert_eq!(2, res);
 
@@ -201,11 +211,12 @@ mod linux_android {
     }
 
     #[test]
+    #[cfg(not(target_arch = "mips"))]
     fn test_ofd_locks() {
         let tmp = NamedTempFile::new().unwrap();
 
         let fd = tmp.as_raw_fd();
-        let inode = fstat(fd).unwrap().st_ino as usize;
+        let inode = fstat(fd).expect("fstat failed").st_ino as usize;
 
         let mut flock = libc::flock {
             l_type: libc::F_WRLCK as libc::c_short,
@@ -213,29 +224,31 @@ mod linux_android {
             l_start: 0,
             l_len: 0,
             l_pid: 0,
-            #[cfg(target_arch="mips")]
-            l_sysid: 0,
-            #[cfg(target_arch="mips")]
-            pad: [0; 4],
         };
-        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).unwrap();
-        assert_eq!(Some(("OFDLCK".to_string(), "WRITE".to_string())), lock_info(inode));
+        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).expect("write lock failed");
+        assert_eq!(
+            Some(("OFDLCK".to_string(), "WRITE".to_string())),
+            lock_info(inode)
+        );
 
         flock.l_type = libc::F_UNLCK as libc::c_short;
-        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).unwrap();
+        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).expect("write unlock failed");
         assert_eq!(None, lock_info(inode));
 
         flock.l_type = libc::F_RDLCK as libc::c_short;
-        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).unwrap();
-        assert_eq!(Some(("OFDLCK".to_string(), "READ".to_string())), lock_info(inode));
+        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).expect("read lock failed");
+        assert_eq!(
+            Some(("OFDLCK".to_string(), "READ".to_string())),
+            lock_info(inode)
+        );
 
         flock.l_type = libc::F_UNLCK as libc::c_short;
-        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).unwrap();
+        fcntl(fd, FcntlArg::F_OFD_SETLKW(&flock)).expect("read unlock failed");
         assert_eq!(None, lock_info(inode));
     }
 
     fn lock_info(inode: usize) -> Option<(String, String)> {
-        let file = File::open("/proc/locks").unwrap();
+        let file = File::open("/proc/locks").expect("open /proc/locks failed");
         let buf = BufReader::new(file);
 
         for line in buf.lines() {
@@ -246,27 +259,29 @@ mod linux_android {
             let ino_parts: Vec<_> = parts[5].split(':').collect();
             let ino: usize = ino_parts[2].parse().unwrap();
             if ino == inode {
-                return Some((lock_type.to_string(), lock_access.to_string()))
+                return Some((lock_type.to_string(), lock_access.to_string()));
             }
         }
         None
     }
 }
 
-#[cfg(any(target_os = "linux",
-          target_os = "android",
-          target_os = "emscripten",
-          target_os = "fuchsia",
-          any(target_os = "wasi", target_env = "wasi"),
-          target_env = "uclibc",
-          target_env = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    any(target_os = "wasi", target_env = "wasi"),
+    target_env = "uclibc",
+    target_env = "freebsd"
+))]
 mod test_posix_fadvise {
 
-    use tempfile::NamedTempFile;
-    use std::os::unix::io::{RawFd, AsRawFd};
     use nix::errno::Errno;
     use nix::fcntl::*;
     use nix::unistd::pipe;
+    use std::os::unix::io::{AsRawFd, RawFd};
+    use tempfile::NamedTempFile;
 
     #[test]
     fn test_success() {
@@ -280,25 +295,30 @@ mod test_posix_fadvise {
     #[test]
     fn test_errno() {
         let (rd, _wr) = pipe().unwrap();
-        let errno = posix_fadvise(rd as RawFd, 0, 100, PosixFadviseAdvice::POSIX_FADV_WILLNEED)
-                                 .unwrap();
+        let errno =
+            posix_fadvise(rd as RawFd, 0, 100, PosixFadviseAdvice::POSIX_FADV_WILLNEED).unwrap();
         assert_eq!(errno, Errno::ESPIPE as i32);
     }
 }
 
-#[cfg(any(target_os = "linux",
-          target_os = "android",
-          target_os = "emscripten",
-          target_os = "fuchsia",
-          any(target_os = "wasi", target_env = "wasi"),
-          target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    any(target_os = "wasi", target_env = "wasi"),
+    target_os = "freebsd"
+))]
 mod test_posix_fallocate {
 
-    use tempfile::NamedTempFile;
-    use std::{io::Read, os::unix::io::{RawFd, AsRawFd}};
     use nix::errno::Errno;
     use nix::fcntl::*;
     use nix::unistd::pipe;
+    use std::{
+        io::Read,
+        os::unix::io::{AsRawFd, RawFd},
+    };
+    use tempfile::NamedTempFile;
 
     #[test]
     fn success() {
@@ -330,15 +350,8 @@ mod test_posix_fallocate {
         let err = posix_fallocate(rd as RawFd, 0, 100).unwrap_err();
         use nix::Error::Sys;
         match err {
-            Sys(Errno::EINVAL)
-                | Sys(Errno::ENODEV)
-                | Sys(Errno::ESPIPE)
-                | Sys(Errno::EBADF) => (),
-            errno =>
-                panic!(
-                    "unexpected errno {}",
-                    errno,
-                ),
+            Sys(Errno::EINVAL) | Sys(Errno::ENODEV) | Sys(Errno::ESPIPE) | Sys(Errno::EBADF) => (),
+            errno => panic!("unexpected errno {}", errno,),
         }
     }
 }