feat: dagrunner, initial version

tests/runtimes/async_std.rs

@@ -0,0 +1,64 @@
+//! Runtime compatibility tests for async-std
+
+use dagx::{DagRunner, Task};
+use crate::common::task_fn;
+
+struct Value(i32);
+#[dagx::task]
+impl Value {
+    async fn run(&mut self) -> i32 {
+        self.0
+    }
+}
+
+struct Add;
+#[dagx::task]
+impl Add {
+    async fn run(&mut self, a: &i32, b: &i32) -> i32 {
+        a + b
+    }
+}
+
+#[async_std::test]
+async fn test_basic_dag_async_std() {
+    let dag = DagRunner::new();
+
+    let x = dag.add_task(Value(2));
+    let y = dag.add_task(Value(3));
+    let sum = dag.add_task(Add).depends_on((&x, &y));
+
+    dag.run(|fut| { async_std::task::spawn(fut); }).await.unwrap();
+
+    assert_eq!(dag.get(sum).unwrap(), 5);
+}
+
+#[async_std::test]
+async fn test_parallel_execution_async_std() {
+    let dag = DagRunner::new();
+
+    let tasks: Vec<_> = (0..10)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 2 })))
+        .collect();
+
+    dag.run(|fut| { async_std::task::spawn(fut); }).await.unwrap();
+
+    for (i, task) in tasks.iter().enumerate() {
+        assert_eq!(dag.get(task).unwrap(), i * 2);
+    }
+}
+
+#[async_std::test]
+async fn test_complex_dependencies_async_std() {
+    let dag = DagRunner::new();
+
+    let a = dag.add_task(Value(10));
+    let b = dag.add_task(Value(20));
+    let sum = dag.add_task(Add).depends_on((&a, &b));
+    let double = dag
+        .add_task(task_fn(|x: i32| async move { x * 2 }))
+        .depends_on(sum);
+
+    dag.run(|fut| { async_std::task::spawn(fut); }).await.unwrap();
+
+    assert_eq!(dag.get(double).unwrap(), 60);
+}