Clean up test case

diff --git a/tests/run-pass/sync.rs b/tests/run-pass/sync.rs
index 6a0b41d5f6a7902c948797e581ec7fc439475fad..8c92b47fb276c50c9a59a04138e150eaefe39af1 100644 (file)
--- a/tests/run-pass/sync.rs
+++ b/tests/run-pass/sync.rs
@@ -3,45 +3,33 @@
 
 #![feature(rustc_private)]
 
-use std::sync;
+use std::sync::{Mutex, RwLock, TryLockError};
 
 extern crate libc;
 
 fn main() {
-    let m = sync::Mutex::new(0);
+    let m = Mutex::new(0);
     {
         let _guard = m.lock();
-        let try_lock_error = m.try_lock().unwrap_err();
-        if let sync::TryLockError::Poisoned(e) = try_lock_error {
-            panic!("{}", e);
-        }
+        assert!(m.try_lock().unwrap_err().would_block());
     }
     drop(m.try_lock().unwrap());
     drop(m);
 
     #[cfg(not(target_os = "windows"))] // TODO: implement RwLock on Windows
     {
-        let rw = sync::RwLock::new(0);
+        let rw = RwLock::new(0);
         {
             let _read_guard = rw.read().unwrap();
             drop(rw.read().unwrap());
             drop(rw.try_read().unwrap());
-            let try_lock_error = rw.try_write().unwrap_err();
-            if let sync::TryLockError::Poisoned(e) = try_lock_error {
-                panic!("{}", e);
-            }
+            assert!(rw.try_write().unwrap_err().would_block());
         }
 
         {
             let _write_guard = rw.write().unwrap();
-            let try_lock_error = rw.try_read().unwrap_err();
-            if let sync::TryLockError::Poisoned(e) = try_lock_error {
-                panic!("{}", e);
-            }
-            let try_lock_error = rw.try_write().unwrap_err();
-            if let sync::TryLockError::Poisoned(e) = try_lock_error {
-                panic!("{}", e);
-            }
+            assert!(rw.try_read().unwrap_err().would_block());
+            assert!(rw.try_write().unwrap_err().would_block());
         }
 
         // need to go a layer deeper and test the behavior of libc functions, because
@@ -58,24 +46,35 @@ fn main() {
             assert_eq!(libc::pthread_mutex_destroy(&mut mutex as *mut _), 0);
         }
 
+        let rw = std::cell::UnsafeCell::new(libc::PTHREAD_RWLOCK_INITIALIZER);
         unsafe {
-            let mut rw: libc::pthread_rwlock_t = std::mem::zeroed();
-            assert_eq!(libc::pthread_rwlock_init(&mut rw as *mut _, std::ptr::null_mut()), 0);
+            assert_eq!(libc::pthread_rwlock_rdlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_rdlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_unlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_tryrdlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_unlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_trywrlock(rw.get()), libc::EBUSY);
+            assert_eq!(libc::pthread_rwlock_unlock(rw.get()), 0);
+
+            assert_eq!(libc::pthread_rwlock_wrlock(rw.get()), 0);
+            assert_eq!(libc::pthread_rwlock_tryrdlock(rw.get()), libc::EBUSY);
+            assert_eq!(libc::pthread_rwlock_trywrlock(rw.get()), libc::EBUSY);
+            assert_eq!(libc::pthread_rwlock_unlock(rw.get()), 0);
 
-            assert_eq!(libc::pthread_rwlock_rdlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_rdlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_unlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_tryrdlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_unlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_trywrlock(&mut rw as *mut _), libc::EBUSY);
-            assert_eq!(libc::pthread_rwlock_unlock(&mut rw as *mut _), 0);
+            assert_eq!(libc::pthread_rwlock_destroy(rw.get()), 0);
+        }
+    }
+}
 
-            assert_eq!(libc::pthread_rwlock_wrlock(&mut rw as *mut _), 0);
-            assert_eq!(libc::pthread_rwlock_tryrdlock(&mut rw as *mut _), libc::EBUSY);
-            assert_eq!(libc::pthread_rwlock_trywrlock(&mut rw as *mut _), libc::EBUSY);
-            assert_eq!(libc::pthread_rwlock_unlock(&mut rw as *mut _), 0);
+trait TryLockErrorExt<T> {
+    fn would_block(&self) -> bool;
+}
 
-            assert_eq!(libc::pthread_rwlock_destroy(&mut rw as *mut _), 0);
+impl<T> TryLockErrorExt<T> for TryLockError<T> {
+    fn would_block(&self) -> bool {
+        match self {
+            TryLockError::WouldBlock => true,
+            TryLockError::Poisoned(_) => false,
         }
     }
 }