cancellable: Avoid using unneeded channel to run tests

There's no need to use a channel, we can just block on the spawning
future

Author: 3v1n0

gio/src/cancellable.rs

@@ -214,15 +214,11 @@ mod tests {
     fn cancellable_future_delayed() {
         let ctx = glib::MainContext::new();
         let c = Cancellable::new();
-        let (tx, rx) = oneshot::channel();
-        {
+        let future = {
             let c = c.clone();
-            ctx.spawn_local(async move {
-                c.future().await;
-                tx.send(()).unwrap();
-            });
-        }
+            ctx.spawn_local(c.future())
+        };
         std::thread::spawn(move || c.cancel()).join().unwrap();
-        ctx.block_on(rx).unwrap();
+        ctx.block_on(future).unwrap();
     }
 }

gio/src/cancellable_future.rs

@@ -141,52 +141,46 @@ impl Display for Cancelled {
 
 #[cfg(test)]
 mod tests {
-    use futures_channel::oneshot;
+    use std::time::Duration;
 
     use super::{Cancellable, CancellableFuture, Cancelled};
-    use crate::prelude::*;
+    use crate::{prelude::*, spawn_blocking};
 
     #[test]
     fn cancellable_future_ok() {
         let ctx = glib::MainContext::new();
         let c = Cancellable::new();
-        let (tx, rx) = oneshot::channel();
 
-        {
+        let future = {
             ctx.spawn_local(async {
                 let cancellable_future = CancellableFuture::new(async { 42 }, c);
                 assert!(!cancellable_future.is_cancelled());
 
                 let result = cancellable_future.await;
                 assert!(matches!(result, Ok(42)));
+            })
+        };
 
-                tx.send(()).unwrap();
-            });
-        }
-
-        ctx.block_on(rx).unwrap()
+        ctx.block_on(future).unwrap()
     }
 
     #[test]
     fn cancellable_future_cancel() {
         let ctx = glib::MainContext::new();
         let c = Cancellable::new();
-        let (tx, rx) = oneshot::channel();
 
-        {
+        let future = {
             let c = c.clone();
             ctx.spawn_local(async move {
                 let cancellable_future = CancellableFuture::new(std::future::pending::<()>(), c);
 
                 let result = cancellable_future.await;
                 assert!(matches!(result, Err(Cancelled)));
-
-                tx.send(()).unwrap();
-            });
-        }
+            })
+        };
 
         std::thread::spawn(move || c.cancel()).join().unwrap();
 
-        ctx.block_on(rx).unwrap();
+        ctx.block_on(future).unwrap();
     }
 }