use super::super::{ArrangeError, DriverKind, FanoutKind, GraphBuilder};
use crate::{
Context, Delivery,
operator::{Emitter, Operator},
};
macro_rules! declared {
($name:ident) => {
impl crate::Declared for $name {
const EFFECT: crate::Effect = crate::Effect::Pure;
type Channels = crate::Unchanneled;
type Mode = crate::Block;
type Options = ();
type Pair = crate::Buffered;
type Wires<O> = crate::Downstream<O>;
type Attribution<O> = ();
}
};
}
macro_rules! analyze_op {
($name:ident) => {
struct $name;
declared!($name);
impl Operator for $name {
type In = u8;
type Out = u8;
type Error = core::convert::Infallible;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<Self::In>,
_emitter: &mut Emitter<Self::Out>,
) -> Result<(), Self::Error> {
Ok(())
}
}
};
}
analyze_op!(A);
analyze_op!(B);
analyze_op!(C);
struct Head;
declared!(Head);
impl Operator for Head {
type In = ();
type Out = u8;
type Error = core::convert::Infallible;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<Self::In>,
_emitter: &mut Emitter<Self::Out>,
) -> Result<(), Self::Error> {
Ok(())
}
}
#[test]
fn issue_100_same_tier_chain_derives_distinct_layers() {
let mut g = GraphBuilder::new();
let a = g.source::<A>("a", DriverKind::Async);
let b = g.node::<B>("b", DriverKind::Async);
let c = g.node::<C>("c", DriverKind::Async);
g.edge(&a, &b, FanoutKind::Direct);
g.edge(&b, &c, FanoutKind::Direct);
let graph = g.validate().expect("chain validates");
assert_eq!(graph.layers().len(), 3);
assert_eq!(graph.layers()[0], vec![a.id()]);
assert_eq!(graph.layers()[1], vec![b.id()]);
assert_eq!(graph.layers()[2], vec![c.id()]);
assert!(graph.orphans().is_empty());
}
#[test]
fn broadcast_fanout_shares_a_layer() {
let mut g = GraphBuilder::new();
let h = g.source::<Head>("head", DriverKind::Async);
let b = g.node::<A>("b", DriverKind::Async);
let c = g.node::<B>("c", DriverKind::Async);
g.edge(&h, &b, FanoutKind::Broadcast);
g.edge(&h, &c, FanoutKind::Broadcast);
let graph = g.validate().expect("valid");
assert_eq!(graph.layers().len(), 2);
assert_eq!(graph.layers()[1], vec![b.id(), c.id()]); }
#[test]
fn cycle_is_rejected() {
let mut g = GraphBuilder::new();
let a = g.node::<A>("a", DriverKind::Async);
let b = g.node::<B>("b", DriverKind::Async);
g.edge(&a, &b, FanoutKind::Direct);
g.edge(&b, &a, FanoutKind::Direct);
let err = g.validate().expect_err("cycle rejected");
assert!(err.is_cycle());
}
#[test]
fn cycle_error_names_a_cycle_member_not_a_downstream_node() {
let mut g = GraphBuilder::new();
let d = g.node::<A>("d", DriverKind::Async); let a = g.node::<B>("a", DriverKind::Async);
let b = g.node::<C>("b", DriverKind::Async);
let c = g.node::<A>("c", DriverKind::Async);
g.edge(&a, &b, FanoutKind::Direct);
g.edge(&b, &c, FanoutKind::Direct);
g.edge(&c, &a, FanoutKind::Broadcast);
g.edge(&c, &d, FanoutKind::Broadcast);
let err = g.validate().expect_err("cycle rejected");
let ArrangeError::Cycle(cycle) = err else {
panic!("expected Cycle, got {err:?}");
};
let node = cycle.node();
assert!(
[a.id(), b.id(), c.id()].contains(&node),
"culprit {node} is not on the a→b→c→a cycle"
);
}
#[test]
fn diamond_with_skip_edge_layers_by_longest_path() {
let mut g = GraphBuilder::new();
let a = g.source::<Head>("a", DriverKind::Async);
let b = g.node::<A>("b", DriverKind::Async);
let c = g.node::<B>("c", DriverKind::Async);
let d = g.node::<C>("d", DriverKind::Async);
g.edge(&a, &b, FanoutKind::Broadcast);
g.edge(&a, &c, FanoutKind::Broadcast);
g.edge(&a, &d, FanoutKind::Broadcast);
g.edge(&b, &d, FanoutKind::Broadcast);
g.edge(&c, &d, FanoutKind::Broadcast);
let graph = g.validate().expect("diamond validates");
assert_eq!(
graph.layers(),
&[vec![a.id()], vec![b.id(), c.id()], vec![d.id()]]
);
assert!(graph.orphans().is_empty());
}
#[test]
fn direct_edge_cannot_fan_out() {
let mut g = GraphBuilder::new();
let h = g.source::<Head>("head", DriverKind::Async);
let b = g.node::<A>("b", DriverKind::Async);
let c = g.node::<B>("c", DriverKind::Async);
g.edge(&h, &b, FanoutKind::Direct);
g.edge(&h, &c, FanoutKind::Broadcast); let err = g.validate().expect_err("direct-fanout rejected");
assert!(err.is_direct_fanout());
}
#[test]
fn orphan_without_source_is_data_not_error() {
let mut g = GraphBuilder::new();
let a = g.node::<A>("a", DriverKind::Async);
let b = g.node::<B>("b", DriverKind::Async);
g.edge(&a, &b, FanoutKind::Direct);
let graph = g.validate().expect("valid even with orphans");
assert_eq!(graph.orphans(), &[a.id(), b.id()]);
assert_eq!(graph.layers(), &[vec![a.id()], vec![b.id()]]);
}
#[test]
fn cross_builder_handle_is_out_of_range_not_panic() {
let mut g = GraphBuilder::new();
let a = g.source::<A>("a", DriverKind::Async);
let mut other = GraphBuilder::new();
let _first = other.node::<A>("first", DriverKind::Async); let foreign = other.node::<B>("foreign", DriverKind::Async);
g.edge(&a, &foreign, FanoutKind::Broadcast);
let err = g.validate().expect_err("out-of-range endpoint rejected");
assert!(err.is_edge_endpoint_out_of_range());
}
#[test]
fn node_lookup_is_total_over_unbranded_ids() {
let mut g = GraphBuilder::new();
let a = g.source::<A>("a", DriverKind::Async);
let graph = g.validate().expect("valid");
assert_eq!(graph.node(a.id()).expect("declared node").name(), "a");
let mut other = GraphBuilder::new();
let _x = other.node::<A>("x", DriverKind::Async);
let foreign = other.node::<B>("foreign", DriverKind::Async); assert!(graph.node(foreign.id()).is_none());
}