cleanup sleeps (#53)

src/client/client.rs

@@ -444,11 +444,13 @@ impl Client {
                 options: ClientOptions)
                 -> Result<(Self, ClientStatus), JackErr> {
         let _ = *CREATE_OR_DESTROY_CLIENT_MUTEX.lock().unwrap();
+        sleep_on_test();
         let mut status_bits = 0;
         let client = unsafe {
             let client_name = ffi::CString::new(client_name).unwrap();
             j::jack_client_open(client_name.as_ptr(), options.bits(), &mut status_bits)
         };
+        sleep_on_test();
         let status = ClientStatus::from_bits(status_bits).unwrap_or(ClientStatus::empty());
         if client.is_null() {
             Err(JackErr::ClientError(status))
@@ -470,16 +472,21 @@ impl Client {
         let _ = *CREATE_OR_DESTROY_CLIENT_MUTEX.lock().unwrap();
         unsafe {
             let handler_ptr = try!(register_callbacks(handler, self.client, self.as_ptr()));
+            sleep_on_test();
             if handler_ptr.is_null() {
                 Err(JackErr::CallbackRegistrationError)
             } else {
                 let res = j::jack_activate(self.client);
+                for _ in 0..3 {
+                    sleep_on_test();
+                }
                 match res {
                     0 => {
                         let Client { client } = self;
 
                         // Don't run destructor -- we want the client to stay open
                         mem::forget(self);
+                        sleep_on_test();
 
                         Ok(ActiveClient {
                             client: client,
@@ -563,6 +570,7 @@ impl<JH: JackHandler> ActiveClient<JH> {
             // Prevent destructor from running, as this would cause double-deactivation
             mem::forget(self);
 
+            sleep_on_test();
             let res = match j::jack_deactivate(client) {
                 // We own the handler post-deactivation
                 0 => Ok(Box::from_raw(handler)),
@@ -571,8 +579,10 @@ impl<JH: JackHandler> ActiveClient<JH> {
                 // without more information about the error condition
                 _ => Err(JackErr::ClientDeactivationError),
             };
+            sleep_on_test();
 
             let callback_res = clear_callbacks(client);
+            sleep_on_test();
 
             match (res, callback_res) {
                 (Ok(handler_ptr), Ok(())) => {
@@ -582,6 +592,7 @@ impl<JH: JackHandler> ActiveClient<JH> {
                 (Err(err), _) | (_, Err(err)) => {
                     // We've invalidated the client, so it must be closed
                     j::jack_client_close(client);
+                    sleep_on_test();
                     Err(err)
                 }
             }
@@ -593,16 +604,13 @@ impl<JH: JackHandler> ActiveClient<JH> {
 impl Drop for Client {
     fn drop(&mut self) {
         let _ = *CREATE_OR_DESTROY_CLIENT_MUTEX.lock().unwrap();
-        #[cfg(test)]
-        {
-            use jack_utils::default_sleep;
-            default_sleep();
-        }
+
         debug_assert!(!self.client.is_null()); // Rep invariant
 
         // Client isn't active, so no need to deactivate
 
         let res = unsafe { j::jack_client_close(self.client) }; // close the client
+        sleep_on_test();
         assert_eq!(res, 0);
         self.client = ptr::null_mut();
     }
@@ -616,11 +624,22 @@ impl<JH: JackHandler> Drop for ActiveClient<JH> {
             debug_assert!(!self.client.is_null()); // Rep invariant
 
             j::jack_deactivate(self.client); // result doesn't matter
+            sleep_on_test();
             drop(Box::from_raw(self.handler)); // drop the handler
 
             let res = j::jack_client_close(self.client); // close the client
+            sleep_on_test();
             assert_eq!(res, 0);
             self.client = ptr::null_mut();
         }
     }
 }
+
+#[cfg(test)]
+use jack_utils;
+
+#[inline(always)]
+pub fn sleep_on_test() {
+    #[cfg(test)]
+    jack_utils::default_sleep();
+}

src/jack_utils.rs

@@ -29,20 +29,13 @@ pub unsafe fn collect_strs(ptr: *const *const i8) -> Vec<String> {
 }
 
 // Sleeps for a short while.
+#[inline(always)]
 #[cfg(test)]
 pub fn default_sleep() {
     use std::{thread, time};
     thread::sleep(time::Duration::from_millis(400));
 }
 
-// Sleeps for a longer while than `default_sleep()`.
-#[cfg(test)]
-pub fn default_longer_sleep() {
-    for _ in 0..5 {
-        default_sleep();
-    }
-}
-
 #[cfg(test)]
 use callbacks;
 #[cfg(test)]

src/lib.rs

@@ -48,6 +48,6 @@ pub mod prelude {
 }
 
 #[cfg(test)]
-pub use jack_utils::{default_longer_sleep, default_sleep};
+pub use jack_utils::default_sleep;
 #[cfg(test)]
 mod test;

src/test/test_client.rs

@@ -2,9 +2,7 @@ use prelude::*;
 use jack_utils::*;
 
 fn open_test_client(name: &str) -> (Client, ClientStatus) {
-    default_sleep();
     let ret = Client::open(name, client_options::NO_START_SERVER).unwrap();
-    default_sleep();
     ret
 }
 
@@ -21,7 +19,6 @@ fn client_can_open() {
 #[test]
 #[should_panic]
 fn client_fails_to_open_with_large_name() {
-    default_sleep();
     let name = (0..*CLIENT_NAME_SIZE + 1)
         .map(|_| "a")
         .collect::<Vec<&str>>()
@@ -43,7 +40,6 @@ fn client_can_be_named() {
 fn client_can_activate() {
     let (c, _) = open_test_client("client_can_activate");
     let _ac = c.activate(DummyHandler).unwrap();
-    default_sleep();
 }
 
 #[test]
@@ -61,9 +57,7 @@ fn client_can_set_buffer_size() {
 fn client_can_deactivate() {
     let (c, _) = open_test_client("client_can_deactivate");
     let a = c.activate(DummyHandler).unwrap();
-    default_sleep();
     a.deactivate().unwrap();
-    default_sleep();
 }
 
 #[test]

src/test/test_client_cback.rs

@@ -56,14 +56,12 @@ impl JackHandler for Counter {
 }
 
 fn open_test_client(name: &str) -> Client {
-    default_sleep();
     Client::open(name, client_options::NO_START_SERVER).unwrap().0
 }
 
 fn active_test_client(name: &str) -> (ActiveClient<Counter>) {
     let c = open_test_client(name);
     let ac = c.activate(Counter::default()).unwrap();
-    default_longer_sleep();
     ac
 }
 
@@ -99,7 +97,6 @@ fn client_cback_calls_buffer_size() {
 #[test]
 fn client_cback_calls_after_client_registered() {
     let ac = active_test_client("client_cback_cacr");
-    default_longer_sleep();
     let _other_client = open_test_client("client_cback_cacr_other");
     let counter = ac.deactivate().unwrap().1;
     assert_eq!(*counter.registered_client_history.lock().unwrap(),
@@ -110,10 +107,8 @@ fn client_cback_calls_after_client_registered() {
 #[test]
 fn client_cback_calls_after_client_unregistered() {
     let ac = active_test_client("client_cback_cacu");
-    default_longer_sleep();
     let other_client = open_test_client("client_cback_cacu_other");
     drop(other_client);
-    default_longer_sleep();
     let counter = ac.deactivate().unwrap().1;
     assert_eq!(*counter.registered_client_history.lock().unwrap(),
                vec!["client_cback_cacu_other"],
@@ -137,7 +132,6 @@ fn client_cback_reports_xruns() {
     let mut counter = Counter::default();
     counter.induce_xruns = true;
     let ac = c.activate(counter).unwrap();
-    default_longer_sleep();
     let counter = ac.deactivate().unwrap().1;
     assert!(*counter.xruns_count.lock().unwrap() > 0,
             "No xruns encountered.");
@@ -148,7 +142,6 @@ fn client_cback_calls_port_registered() {
     let mut ac = active_test_client("client_cback_cpr");
     let _pa = ac.register_port("pa", AudioInSpec::default()).unwrap();
     let _pb = ac.register_port("pb", AudioInSpec::default()).unwrap();
-    default_sleep();
     let counter = ac.deactivate().unwrap().1;
     assert_eq!(counter.port_register_history.lock().unwrap().len(),
                2,
@@ -162,10 +155,8 @@ fn client_cback_calls_port_unregistered() {
     let mut ac = active_test_client("client_cback_cpr");
     let _pa = ac.register_port("pa", AudioInSpec::default()).unwrap();
     let _pb = ac.register_port("pb", AudioInSpec::default()).unwrap();
-    default_sleep();
     _pa.unregister().unwrap();
     _pb.unregister().unwrap();
-    default_sleep();
     let counter = ac.deactivate().unwrap().1;
     assert_eq!(counter.port_register_history.lock().unwrap().len(),
                2,

src/test/test_port_audio.rs

@@ -1,9 +1,7 @@
 use prelude::*;
-use jack_utils::*;
 use std::sync::mpsc::channel;
 
 fn open_test_client(name: &str) -> Client {
-    default_sleep();
     Client::open(name, client_options::NO_START_SERVER).unwrap().0
 }
 
@@ -35,12 +33,10 @@ fn port_audio_can_read_write() {
         JackControl::Continue
     };
     let ac = c.activate(ProcessHandler::new(process_callback)).unwrap();
-    default_longer_sleep();
     ac.connect_ports_by_name("port_audio_crw:oa", "port_audio_crw:ia")
         .unwrap();
     ac.connect_ports_by_name("port_audio_crw:ob", "port_audio_crw:ib")
         .unwrap();
-    default_longer_sleep();
     assert!(did_succeed.iter().any(|b| b),
             "input port does not have expected data");
     ac.deactivate().unwrap();

src/test/test_port_midi.rs

@@ -4,7 +4,6 @@ use std::sync::mpsc::channel;
 use std::sync::Mutex;
 
 fn open_test_client(name: &str) -> Client {
-    default_sleep();
     Client::open(name, client_options::NO_START_SERVER).unwrap().0
 }
 
@@ -42,7 +41,6 @@ fn port_midi_can_read_write() {
 
     // activate
     let ac = c.activate(ProcessHandler::new(process_callback)).unwrap();
-    default_longer_sleep();
 
     // connect ports to each other
     ac.connect_ports_by_name("port_audio_crw:oa", "port_audio_crw:ia")
@@ -51,7 +49,7 @@ fn port_midi_can_read_write() {
         .unwrap();
 
     // check correctness
-    default_longer_sleep();
+    default_sleep();
     assert!(did_succeed.iter().any(|b| b),
             "input port does not have expected data");
     ac.deactivate().unwrap();
@@ -76,10 +74,8 @@ fn port_midi_can_get_max_event_size() {
 
     // activate
     let ac = c.activate(ProcessHandler::new(process_callback)).unwrap();
-    default_longer_sleep();
 
     // check correctness
-    default_longer_sleep();
     assert!(*PMCGMES_MAX_EVENT_SIZE.lock().unwrap() > 0);
     ac.deactivate().unwrap();
 }
@@ -113,10 +109,8 @@ fn port_midi_cant_execeed_max_event_size() {
 
     // activate
     let ac = c.activate(ProcessHandler::new(process_callback)).unwrap();
-    default_longer_sleep();
 
     // check correctness
-    default_longer_sleep();
     assert_eq!(*PMCEMES_DID_EXCEED.lock().unwrap(),
                Some(JackErr::NotEnoughSpace));
     ac.deactivate().unwrap();