fix: change where TaskHandle is borrowed to prevent repeat output fetches

tests/parallelism/spawning.rs

@@ -33,7 +33,7 @@ async fn test_spawner_actually_spawns_tasks() -> DagResult<()> {
 
     // Verify all tasks were spawned
     for (i, task) in tasks.into_iter().enumerate() {
-        assert_eq!(output.get(task)?, i as i32);
+        assert_eq!(output.get(task), i as i32);
     }
 
     // The spawner should have been called once for each task

tests/parallelism/threads.rs

@@ -68,7 +68,7 @@ async fn test_concurrent_execution_with_atomic_counter() -> DagResult<()> {
 
     // Verify all tasks completed
     for (i, task) in tasks.into_iter().enumerate() {
-        assert_eq!(output.get(task)?, i);
+        assert_eq!(output.get(task), i);
     }
 
     // Check that we achieved real parallelism
@@ -135,7 +135,7 @@ async fn test_massive_parallel_fanout() -> DagResult<()> {
     }
 
     // Create 1000 tasks all depending on the same source
-    let tasks: Vec<_> = (0..1000)
+    let mut tasks: Vec<_> = (0..1000)
         .map(|i| {
             dag.add_task(FanoutTask {
                 comp: completed.clone(),
@@ -143,7 +143,7 @@ async fn test_massive_parallel_fanout() -> DagResult<()> {
                 curr: current.clone(),
                 idx: i,
             })
-            .depends_on(source)
+            .depends_on(&source)
         })
         .collect();
 
@@ -157,9 +157,9 @@ async fn test_massive_parallel_fanout() -> DagResult<()> {
     assert_eq!(completed.load(Ordering::SeqCst), 1000);
 
     // Check some results
-    assert_eq!(output.get(tasks[0])?, 1);
-    assert_eq!(output.get(tasks[500])?, 501);
-    assert_eq!(output.get(tasks[999])?, 1000);
+    assert_eq!(output.get(tasks.remove(999)), 1000);
+    assert_eq!(output.get(tasks.remove(500)), 501);
+    assert_eq!(output.get(tasks.remove(0)), 1);
 
     let max_seen = max_concurrent.load(Ordering::SeqCst);
     println!(

tests/parallelism/timing.rs

@@ -40,7 +40,7 @@ async fn test_parallel_execution_speedup() -> DagResult<()> {
 
     // Verify all tasks completed
     for (i, task) in tasks.into_iter().enumerate() {
-        assert_eq!(output.get(task)?, i);
+        assert_eq!(output.get(task), i);
     }
 
     // If tasks ran sequentially: 10 * 50ms = 500ms
@@ -125,7 +125,7 @@ async fn test_layers_execute_in_parallel() -> DagResult<()> {
                 idx: i,
                 timing: layer_timing.clone(),
             })
-            .depends_on(source)
+            .depends_on(&source)
         })
         .collect();
 
@@ -140,14 +140,14 @@ async fn test_layers_execute_in_parallel() -> DagResult<()> {
                 a + b + c
             },
         ))
-        .depends_on((layer1[0], layer1[1], layer1[2]))
+        .depends_on((&layer1[0], &layer1[1], &layer1[2]))
     };
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(output.get(final_task)?, 33); // (0+1) + (10+1) + (20+1)
+    assert_eq!(output.get(final_task), 33); // (0+1) + (10+1) + (20+1)
 
     // Analyze timing
     let timing = layer_timing.lock().unwrap();