CancellableFuture: Some cleanups and few more tests

examples/Cargo.toml

@@ -9,7 +9,8 @@ version.workspace = true
 futures = "0.3"
 futures-channel = "0.3"
 futures-util = "0.3"
-glib.workspace = true
+libc = "0.2"
+glib = { workspace = true, features = ["futures"] }
 gio.workspace = true
 
 [dependencies.async-tls]

examples/gio_futures_await/main.rs

@@ -1,30 +1,43 @@
-use std::str;
-
 use futures::prelude::*;
 use gio::prelude::*;
 use glib::clone;
 
 fn main() {
     let c = glib::MainContext::default();
-    let l = glib::MainLoop::new(Some(&c), false);
-
     let file = gio::File::for_path("Cargo.toml");
+    let cancellable = gio::Cancellable::new();
 
     let future = clone!(
         #[strong]
-        l,
+        cancellable,
         async move {
             match read_file(file).await {
                 Ok(()) => (),
                 Err(err) => eprintln!("Got error: {err}"),
             }
-            l.quit();
+            cancellable.cancel();
         }
     );
 
-    c.spawn_local(future);
+    #[cfg(unix)]
+    let cancel_future = clone!(
+        #[strong]
+        cancellable,
+        async move {
+            glib::unix_signal_future(libc::SIGINT).await;
+            eprintln!("Ctrl+C pressed, operation will be stopped!");
+            cancellable.cancel();
+        }
+    );
+    #[cfg(not(unix))]
+    let cancel_future = async move {};
 
-    l.run();
+    let _ = c
+        .block_on(c.spawn_local(gio::CancellableFuture::new(
+            futures_util::future::join(future, cancel_future),
+            cancellable,
+        )))
+        .expect("futures must be executed");
 }
 
 /// Throughout our chained futures, we convert all errors to strings

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();
     }
 }