test: update tests/examples/benches

tests/dependencies/tuples.rs

@@ -5,7 +5,7 @@ use dagx_test::task_fn;
 
 #[tokio::test]
 async fn test_two_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
     let b = dag.add_task(task_fn::<(), _, _>(|_: ()| 20));
@@ -13,16 +13,17 @@ async fn test_two_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
         .depends_on((a, b));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 30);
+    assert_eq!(output.get(sum)?, 30);
     Ok(())
 }
 
 #[tokio::test]
 async fn test_three_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
     let b = dag.add_task(task_fn::<(), _, _>(|_: ()| 2));
@@ -33,19 +34,20 @@ async fn test_three_dependencies() -> DagResult<()> {
         ))
         .depends_on((a, b, c));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 6);
+    assert_eq!(output.get(sum)?, 6);
     Ok(())
 }
 
 #[tokio::test]
 async fn test_four_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=4)
-        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
     let sum = dag
@@ -54,19 +56,20 @@ async fn test_four_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3]));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 10); // 1+2+3+4
+    assert_eq!(output.get(sum)?, 10); // 1+2+3+4
     Ok(())
 }
 
 #[tokio::test]
 async fn test_five_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=5)
-        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
     let sum = dag
@@ -75,19 +78,20 @@ async fn test_five_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4]));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 15); // 1+2+3+4+5
+    assert_eq!(output.get(sum)?, 15); // 1+2+3+4+5
     Ok(())
 }
 
 #[tokio::test]
 async fn test_six_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=6)
-        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
     let sum = dag
@@ -96,19 +100,20 @@ async fn test_six_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 21); // 1+2+3+4+5+6
+    assert_eq!(output.get(sum)?, 21); // 1+2+3+4+5+6
     Ok(())
 }
 
 #[tokio::test]
 async fn test_seven_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=7)
-        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
     let sum = dag
@@ -121,19 +126,20 @@ async fn test_seven_dependencies() -> DagResult<()> {
             &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6],
         ));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 28); // 1+2+3+4+5+6+7
+    assert_eq!(output.get(sum)?, 28); // 1+2+3+4+5+6+7
     Ok(())
 }
 
 #[tokio::test]
 async fn test_eight_dependencies() -> DagResult<()> {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=8)
-        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
     let sum = dag
@@ -146,9 +152,10 @@ async fn test_eight_dependencies() -> DagResult<()> {
             &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6], &deps[7],
         ));
 
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await?;
 
-    assert_eq!(dag.get(sum)?, 36); // Sum of 1..=8
+    assert_eq!(output.get(sum)?, 36); // Sum of 1..=8
     Ok(())
 }