Update tests, examples, benches

tests/task_patterns/combined.rs

@@ -3,6 +3,7 @@ use crate::common::task_fn;
 // Comprehensive test showing all three patterns working together
 
 use dagx::*;
+use futures::FutureExt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -52,11 +53,9 @@ async fn test_all_three_task_patterns() {
     // Pattern 3: Mutable accumulation
     let accumulated = dag.add_task(MutableAccumulator(10)).depends_on(doubled); // 10 + 16 = 26
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(sum).unwrap(), 8);
     assert_eq!(dag.get(doubled).unwrap(), 16);
@@ -97,11 +96,9 @@ async fn test_parallel_execution() {
         }
     }));
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // All three tasks should have run
     assert_eq!(counter.load(Ordering::SeqCst), 3);
@@ -120,11 +117,9 @@ async fn test_task_fn_with_captured_state() {
         .add_task(task_fn(move |x: i32| async move { x * multiplier }))
         .depends_on(&base);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(scaled).unwrap(), 35);
 }

tests/task_patterns/readonly.rs

@@ -3,6 +3,7 @@ use crate::common::task_fn;
 // These tests verify the read-only state pattern using &self
 
 use dagx::*;
+use futures::FutureExt;
 
 // Read-only state tasks
 struct ReadOnlyValue(i32);
@@ -42,11 +43,9 @@ async fn test_readonly_state_basic() {
 
     let value = dag.add_task(ReadOnlyValue(42));
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(value).unwrap(), 42);
 }
 
@@ -58,11 +57,9 @@ async fn test_readonly_state_with_input() {
     let input = dag.add_task(task_fn(|_: ()| async { 5 }));
     let result = dag.add_task(ReadOnlyMultiplier(7)).depends_on(&input);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(result).unwrap(), 35);
 }
 
@@ -87,11 +84,9 @@ async fn test_readonly_state_multiple_uses() {
     };
     let result2 = dag.add_task(config2).depends_on(&input2);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(result1).unwrap(), 35); // (10 * 3) + 5
     assert_eq!(dag.get(result2).unwrap(), 65); // (20 * 3) + 5
 }

tests/task_patterns/stateless.rs

@@ -1,5 +1,6 @@
 // Stateless task pattern tests
 use crate::common::task_fn;
+use futures::FutureExt;
 
 use dagx::*;
 
@@ -85,11 +86,9 @@ async fn test_stateless_basic() {
     let y = dag.add_task(task_fn(|_: ()| async { 20 }));
     let sum = dag.add_task(StatelessAdd).depends_on((&x, &y));
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(sum).unwrap(), 30);
 }
 
@@ -101,11 +100,9 @@ async fn test_stateless_single_input() {
     let input = dag.add_task(task_fn(|_: ()| async { 21 }));
     let doubled = dag.add_task(StatelessDouble).depends_on(&input);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(doubled).unwrap(), 42);
 }
 
@@ -116,11 +113,9 @@ async fn test_stateless_no_input() {
 
     let source = dag.add_task(StatelessSource);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(source).unwrap(), 42);
 }
 
@@ -137,11 +132,9 @@ async fn test_stateless_multiple_inputs() {
         .add_task(StatelessFormat)
         .depends_on((&num, &text, &flag));
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     assert_eq!(dag.get(result).unwrap(), "test: 42 (true)");
 }
 
@@ -178,11 +171,9 @@ async fn test_stateless_mixed_with_stateful() {
     // Stateful counter
     let counted = dag.add_task(Counter::new(10)).depends_on(product);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(product).unwrap(), 15);
     assert_eq!(dag.get(counted).unwrap(), 25); // 10 + 15
@@ -198,11 +189,9 @@ async fn test_stateless_chain() {
     let step2 = dag.add_task(StatelessInc).depends_on(step1);
     let step3 = dag.add_task(StatelessInc).depends_on(step2);
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(step1).unwrap(), 1);
     assert_eq!(dag.get(step2).unwrap(), 2);
@@ -221,11 +210,9 @@ async fn test_stateless_parallel() {
         })
         .collect();
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(tasks[0]).unwrap(), 1);
     assert_eq!(dag.get(tasks[1]).unwrap(), 4);
@@ -244,11 +231,9 @@ async fn test_stateless_with_string_types() {
 
     let greeting = dag.add_task(StatelessConcat).depends_on((&hello, &world));
 
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     assert_eq!(dag.get(greeting).unwrap(), "Hello, World!");
 }