swaits/dagx
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update tests, examples, benches

Browse Source
This commit is contained in:
TechnoPorg committed 2026-02-11 22:01:50 +01:00
1 parent 0137296fb4
commit 86787b3a0d
71 files changed
+1791 -3547
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/dependencies/resolution.rs
+45 -48
View File
@@ -1,7 +1,7 @@
//! Tests for dependency resolution order and transitive dependencies
use crate::common::task_fn;
use dagx::{DagResult, DagRunner, TaskHandle};
use dagx::{task, DagResult, DagRunner, TaskHandle};
use futures::FutureExt;
use std::sync::{Arc, Mutex};
@@ -12,72 +12,69 @@ async fn test_dependency_resolution_order() -> DagResult<()> {
let execution_log = Arc::new(Mutex::new(Vec::new()));
struct ATask {
log: Arc<Mutex<Vec<(&'static str, i32)>>>,
}
#[task]
impl ATask {
async fn run(&self) -> i32 {
self.log.lock().unwrap().push(("A_start", 0));
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
self.log.lock().unwrap().push(("A_end", 1));
1
}
}
// Create a chain: A -> B -> C -> D -> E
let a = {
let log = execution_log.clone();
dag.add_task(task_fn(move |_: ()| {
let log = log.clone();
async move {
log.lock().unwrap().push(("A_start", 0));
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
log.lock().unwrap().push(("A_end", 1));
1
}
}))
};
let a = dag.add_task(ATask {
log: execution_log.clone(),
});
let b = {
let log = execution_log.clone();
dag.add_task(task_fn(move |x: i32| {
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let log = log.clone();
async move {
log.lock().unwrap().push(("B_start", x));
assert_eq!(x, 1, "B should receive 1 from A");
log.lock().unwrap().push(("B_end", x + 1));
x + 1
}
log.lock().unwrap().push(("B_start", x));
assert_eq!(x, 1, "B should receive 1 from A");
log.lock().unwrap().push(("B_end", x + 1));
x + 1
}))
.depends_on(a)
};
let c = {
let log = execution_log.clone();
dag.add_task(task_fn(move |x: i32| {
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let log = log.clone();
async move {
log.lock().unwrap().push(("C_start", x));
assert_eq!(x, 2, "C should receive 2 from B");
log.lock().unwrap().push(("C_end", x + 1));
x + 1
}
log.lock().unwrap().push(("C_start", x));
assert_eq!(x, 2, "C should receive 2 from B");
log.lock().unwrap().push(("C_end", x + 1));
x + 1
}))
.depends_on(b)
};
let d = {
let log = execution_log.clone();
dag.add_task(task_fn(move |x: i32| {
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let log = log.clone();
async move {
log.lock().unwrap().push(("D_start", x));
assert_eq!(x, 3, "D should receive 3 from C");
log.lock().unwrap().push(("D_end", x + 1));
x + 1
}
log.lock().unwrap().push(("D_start", x));
assert_eq!(x, 3, "D should receive 3 from C");
log.lock().unwrap().push(("D_end", x + 1));
x + 1
}))
.depends_on(c)
};
let e = {
let log = execution_log.clone();
dag.add_task(task_fn(move |x: i32| {
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let log = log.clone();
async move {
log.lock().unwrap().push(("E_start", x));
assert_eq!(x, 4, "E should receive 4 from D");
log.lock().unwrap().push(("E_end", x + 1));
x + 1
}
log.lock().unwrap().push(("E_start", x));
assert_eq!(x, 4, "E should receive 4 from D");
log.lock().unwrap().push(("E_end", x + 1));
x + 1
}))
.depends_on(d)
};
@@ -108,12 +105,12 @@ async fn test_transitive_dependencies() -> DagResult<()> {
// A -> B -> C (creates transitive A -> C relationship)
let dag = DagRunner::new();
let a: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 10 })).into();
let a: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 10)).into();
let b = dag
.add_task(task_fn(|x: i32| async move { x * 2 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
.depends_on(a);
let c = dag
.add_task(task_fn(|x: i32| async move { x + 5 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
.depends_on(b);
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -129,12 +126,12 @@ async fn test_transitive_dependencies() -> DagResult<()> {
async fn test_deep_chain_50_levels() -> DagResult<()> {
let dag = DagRunner::new();
let first = dag.add_task(task_fn(|_: ()| async { 0 }));
let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 0));
let mut handles = vec![first.into()];
for _i in 1..=50 {
let next = dag
.add_task(task_fn(move |x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + 1))
.depends_on(handles.last().unwrap());
handles.push(next);
}
@@ -149,12 +146,12 @@ async fn test_deep_chain_50_levels() -> DagResult<()> {
async fn test_deep_chain_200_levels() -> DagResult<()> {
let dag = DagRunner::new();
let first = dag.add_task(task_fn(|_: ()| async { 1 }));
let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
let mut current = first.into();
for _ in 0..200 {
current = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
.depends_on(current);
}
tests/dependencies/single.rs
+19 -17
View File
@@ -8,9 +8,9 @@ use futures::FutureExt;
async fn test_single_dependency() -> DagResult<()> {
let dag = DagRunner::new();
let source = dag.add_task(task_fn(|_: ()| async { 42 }));
let source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
let dependent = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
.depends_on(source);
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -25,21 +25,23 @@ async fn test_dependency_data_flow() -> DagResult<()> {
let dag = DagRunner::new();
let source: TaskHandle<_> = dag
.add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }))
.add_task(task_fn::<(), _, _>(|_: ()| vec![1, 2, 3, 4, 5]))
.into();
let sum = dag
.add_task(task_fn(|v: Vec<i32>| async move { v.iter().sum::<i32>() }))
.add_task(task_fn::<Vec<_>, _, _>(|v: &Vec<i32>| {
v.iter().sum::<i32>()
}))
.depends_on(source);
let product = dag
.add_task(task_fn(
|v: Vec<i32>| async move { v.iter().product::<i32>() },
))
.add_task(task_fn::<Vec<_>, _, _>(|v: &Vec<i32>| {
v.iter().product::<i32>()
}))
.depends_on(source);
let final_result = dag
.add_task(task_fn(|(s, p): (i32, i32)| async move { s + p }))
.add_task(task_fn::<(i32, i32), _, _>(|(s, p): (&i32, &i32)| s + p))
.depends_on((&sum, &product));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -56,14 +58,14 @@ async fn test_dependencies_with_different_types() -> DagResult<()> {
// Test that dependencies with different types work correctly
let dag = DagRunner::new();
let int_source = dag.add_task(task_fn(|_: ()| async { 42 }));
let string_source = dag.add_task(task_fn(|_: ()| async { "hello".to_string() }));
let bool_source = dag.add_task(task_fn(|_: ()| async { true }));
let int_source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
let string_source = dag.add_task(task_fn::<(), _, _>(|_: ()| "hello".to_string()));
let bool_source = dag.add_task(task_fn::<(), _, _>(|_: ()| true));
let combined = dag
.add_task(task_fn(|(i, s, b): (i32, String, bool)| async move {
format!("{}: {} ({})", s, i, b)
}))
.add_task(task_fn::<(i32, String, bool), _, _>(
|(i, s, b): (&i32, &String, &bool)| format!("{}: {} ({})", s, i, b),
))
.depends_on((int_source, string_source, bool_source));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -77,12 +79,12 @@ async fn test_shared_dependencies() -> DagResult<()> {
// Test that a single node can be a dependency for multiple downstream nodes
let dag = DagRunner::new();
let shared: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
let shared: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
// Create 10 tasks that all depend on the shared node
let dependents: Vec<_> = (0..10)
.map(|i| {
dag.add_task(task_fn(move |x: i32| async move { x * (i + 1) }))
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x * (i + 1)))
.depends_on(shared)
})
.collect();
@@ -103,7 +105,7 @@ async fn test_multiple_source_nodes() -> DagResult<()> {
let dag = DagRunner::new();
let sources: Vec<_> = (0..20)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 10 })))
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 10)))
.collect();
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
tests/dependencies/tuples.rs
+27 -29
View File
@@ -8,10 +8,10 @@ use futures::FutureExt;
async fn test_two_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let a = dag.add_task(task_fn(|_: ()| async { 10 }));
let b = dag.add_task(task_fn(|_: ()| async { 20 }));
let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
let b = dag.add_task(task_fn::<(), _, _>(|_: ()| 20));
let sum = dag
.add_task(task_fn(|(x, y): (i32, i32)| async move { x + y }))
.add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
.depends_on((a, b));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -24,12 +24,12 @@ async fn test_two_dependencies() -> DagResult<()> {
async fn test_three_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let a = dag.add_task(task_fn(|_: ()| async { 1 }));
let b = dag.add_task(task_fn(|_: ()| async { 2 }));
let c = dag.add_task(task_fn(|_: ()| async { 3 }));
let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
let b = dag.add_task(task_fn::<(), _, _>(|_: ()| 2));
let c = dag.add_task(task_fn::<(), _, _>(|_: ()| 3));
let sum = dag
.add_task(task_fn(
|(x, y, z): (i32, i32, i32)| async move { x + y + z },
.add_task(task_fn::<(i32, i32, i32), _, _>(
|(x, y, z): (&i32, &i32, &i32)| x + y + z,
))
.depends_on((a, b, c));
@@ -44,13 +44,13 @@ async fn test_four_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let deps: Vec<_> = (1..=4)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
.collect();
let sum = dag
.add_task(task_fn(|(a, b, c, d): (i32, i32, i32, i32)| async move {
a + b + c + d
}))
.add_task(task_fn::<(i32, i32, i32, i32), _, _>(
|(a, b, c, d): (&i32, &i32, &i32, &i32)| a + b + c + d,
))
.depends_on((&deps[0], &deps[1], &deps[2], &deps[3]));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -64,12 +64,12 @@ async fn test_five_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let deps: Vec<_> = (1..=5)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
.collect();
let sum = dag
.add_task(task_fn(
|(a, b, c, d, e): (i32, i32, i32, i32, i32)| async move { a + b + c + d + e },
.add_task(task_fn::<(i32, i32, i32, i32, i32), _, _>(
|(a, b, c, d, e): (&i32, &i32, &i32, &i32, &i32)| a + b + c + d + e,
))
.depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4]));
@@ -84,16 +84,14 @@ async fn test_six_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let deps: Vec<_> = (1..=6)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
.collect();
let sum = dag.add_task(task_fn(
|(a, b, c, d, e, f): (i32, i32, i32, i32, i32, i32)| async move {
a + b + c + d + e + f
}
)).depends_on((
&deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]
));
let sum = dag
.add_task(task_fn::<(i32, i32, i32, i32, i32, i32), _, _>(
|(a, b, c, d, e, f): (&i32, &i32, &i32, &i32, &i32, &i32)| a + b + c + d + e + f,
))
.depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -106,12 +104,12 @@ async fn test_seven_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let deps: Vec<_> = (1..=7)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
.collect();
let sum = dag
.add_task(task_fn(
|(a, b, c, d, e, f, g): (i32, i32, i32, i32, i32, i32, i32)| async move {
.add_task(task_fn::<(i32, i32, i32, i32, i32, i32, i32), _, _>(
|(a, b, c, d, e, f, g): (&i32, &i32, &i32, &i32, &i32, &i32, &i32)| {
a + b + c + d + e + f + g
},
))
@@ -130,12 +128,12 @@ async fn test_eight_dependencies() -> DagResult<()> {
let dag = DagRunner::new();
let deps: Vec<_> = (1..=8)
.map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
.map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into())
.collect();
let sum = dag
.add_task(task_fn(
|(a, b, c, d, e, f, g, h): (i32, i32, i32, i32, i32, i32, i32, i32)| async move {
.add_task(task_fn::<(i32, i32, i32, i32, i32, i32, i32, i32), _, _>(
|(a, b, c, d, e, f, g, h): (&i32, &i32, &i32, &i32, &i32, &i32, &i32, &i32)| {
a + b + c + d + e + f + g + h
},
))