diff --git a/src/tests/client.rs b/src/tests/client.rs
index ab822f5b..8c88246c 100644
--- a/src/tests/client.rs
+++ b/src/tests/client.rs
@@ -11,19 +11,22 @@ fn client_can_open() {
     assert_ne!(client.uuid_string(), "");
     assert_ne!(client.uuid(), 0);
     let cpu_load = client.cpu_load();
-    assert!(cpu_load > 0.0, "client.cpu_load() = {}", cpu_load);
+    assert!(cpu_load >= 0.0, "client.cpu_load() = {}", cpu_load);
 }
 
 #[test]
 fn time_is_montonically_increasing() {
-    let t0 = DEFAULT_TEST_CLIENT.time();
-    let frames0 = DEFAULT_TEST_CLIENT.frames_since_cycle_start();
-    let frame_time0 = DEFAULT_TEST_CLIENT.frame_time();
+    let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
+    let ac = client.activate_async((), ()).unwrap();
+    let client = ac.as_client();
+    let t0 = client.time();
+    let frames0 = client.frames_since_cycle_start();
+    let frame_time0 = client.frame_time();
 
     std::thread::sleep(std::time::Duration::from_millis(50));
-    assert_ne!(DEFAULT_TEST_CLIENT.time(), t0);
-    assert_ne!(DEFAULT_TEST_CLIENT.frames_since_cycle_start(), frames0);
-    assert_ne!(DEFAULT_TEST_CLIENT.frame_time(), frame_time0);
+    assert_ne!(client.time(), t0);
+    assert_ne!(client.frames_since_cycle_start(), frames0);
+    assert_ne!(client.frame_time(), frame_time0);
 }
 
 #[test]
diff --git a/src/tests/time.rs b/src/tests/time.rs
index 6632d23a..42ac2c3e 100644
--- a/src/tests/time.rs
+++ b/src/tests/time.rs
@@ -1,14 +1,40 @@
 use approx::assert_abs_diff_eq;
 
+use crate::contrib::ClosureProcessHandler;
+
+fn active_client() -> crate::AsyncClient<(), impl crate::ProcessHandler> {
+    let (client, _) = crate::Client::new("", crate::ClientOptions::empty()).unwrap();
+    let (send, recv) = std::sync::mpsc::sync_channel(1);
+    let ac = client
+        .activate_async(
+            (),
+            ClosureProcessHandler::new(move |_, _| {
+                send.try_send(()).ok();
+                crate::Control::Continue
+            }),
+        )
+        .unwrap();
+    recv.recv_timeout(std::time::Duration::from_secs(1))
+        .unwrap();
+    ac
+}
+
 #[test]
 fn frame_and_time_are_convertable() {
-    let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
-    assert_eq!(client.time_to_frames(client.frames_to_time(0)), 0);
+    let ac = active_client();
+    let client = ac.as_client();
+    let frame_time = client.frame_time();
+    assert_abs_diff_eq!(
+        client.time_to_frames(client.frames_to_time(frame_time)) as f64,
+        frame_time as f64,
+        epsilon = 1.0,
+    );
 }
 
 #[test]
 fn one_frame_duration_is_inverse_of_sample_rate() {
-    let (client, _) = crate::Client::new("", crate::ClientOptions::empty()).unwrap();
+    let ac = active_client();
+    let client = ac.as_client();
     let sample_rate = client.sample_rate();
     assert_abs_diff_eq!(
         (client.frames_to_time(sample_rate as _) - client.frames_to_time(0)) as f64,
@@ -19,9 +45,11 @@ fn one_frame_duration_is_inverse_of_sample_rate() {
 
 #[test]
 fn one_second_is_sample_rate_frames() {
-    let (client, _) = crate::Client::new("", crate::ClientOptions::empty()).unwrap();
-    let t0 = client.time_to_frames(0);
-    let t1 = client.time_to_frames(1_000_000);
+    let ac = active_client();
+    let client = ac.as_client();
+    let now = client.time();
+    let t0 = client.time_to_frames(now);
+    let t1 = client.time_to_frames(now + 1_000_000);
     assert_abs_diff_eq!(
         (t1 - t0) as f64,
         client.sample_rate() as f64,