Depend on futures-util instead of futures

tests/timing/concurrent_access.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{task, DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
@@ -32,7 +32,8 @@ async fn test_concurrent_result_retrieval() -> DagResult<()> {
         .collect();
 
     // Execute the DAG
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Now try to get results concurrently from multiple threads
     let mut get_handles = Vec::new();
@@ -83,7 +84,8 @@ async fn test_simultaneous_dag_building_and_execution() -> DagResult<()> {
     tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
 
     // Execute the DAG
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Get the additional tasks
     let additional_tasks = build_handle.await.unwrap();
@@ -97,7 +99,8 @@ async fn test_simultaneous_dag_building_and_execution() -> DagResult<()> {
     // (they need another run cycle)
     if building_complete.load(Ordering::SeqCst) {
         // Run again for the new tasks
-        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+            .await?;
 
         // Now they should have results
         for (i, task) in additional_tasks.iter().enumerate() {
@@ -139,7 +142,8 @@ async fn test_concurrent_dependency_resolution() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Check all completed
     assert_eq!(resolution_counter.load(Ordering::SeqCst), 101);
@@ -212,7 +216,8 @@ async fn test_read_write_race_patterns() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify readers saw their writer's data
     for reader in &readers {
@@ -265,7 +270,8 @@ async fn test_atomic_counter_races() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Final counter should be 200 * 100 = 20000
     assert_eq!(counter.load(Ordering::SeqCst), 20000);
@@ -299,7 +305,8 @@ async fn test_multiple_dag_runners_interaction() -> DagResult<()> {
                 })
                 .collect();
 
-            dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+            dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                .await?;
 
             // Collect results
             let mut results = Vec::new();

tests/timing/interleaving.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{task, DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 use tokio::sync::Barrier;
@@ -58,7 +58,8 @@ async fn test_forced_interleaving_with_barriers() -> DagResult<()> {
         ))
         .depends_on((t1, t2, t3));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     assert_eq!(dag.get(collector)?, 6);
 
@@ -186,7 +187,8 @@ async fn test_alternating_execution_pattern() -> DagResult<()> {
             .depends_on(chain_b);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Check alternating pattern
     let event_list = events.lock().clone();
@@ -262,7 +264,8 @@ async fn test_layered_interleaving() -> DagResult<()> {
         })
         .depends_on((&layer2[0], &layer2[1]));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Sum of 0+1+2+3 = 6
     assert_eq!(dag.get(layer3)?, 6);
@@ -368,7 +371,8 @@ async fn test_cross_branch_synchronization() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(a, b): (&i32, &i32)| a + b))
         .depends_on((&a2, &b2));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     assert_eq!(dag.get(merge)?, 13); // 2 + 11