hsmc/hsmc/tests/det_lateral.rs

#![allow(dead_code)]
//! Deterministic-flow tests for LATERAL transitions (target not on active path).
//!
//! Spec section "Transitioning to a sibling (or anywhere not on your active path)":
//!   The standard case. LCA is somewhere strictly above both current and
//!   target. Exit up to LCA, enter down to target, default-descend if the
//!   target has children.
//!
//! Also pins down that the LCA itself is **not** exited or re-entered.

#![cfg(all(feature = "tokio", feature = "journal"))]
#![allow(unexpected_cfgs)]

use hsmc::{statechart, ActionKind, TraceEvent};

#[derive(Default)]
pub struct Ctx;

#[derive(Debug, Clone)]
pub enum Ev {
    GoB,
    GoC,
    GoD,
    GoE,
    Halt,
}

// Hierarchy:
//   Root
//   ├── Parent
//   │   ├── A (default)
//   │   └── B
//   ├── C
//   └── D
//       └── E
statechart! {
    Lat {
        context: Ctx;
        events:  Ev;
        default(Parent);
        terminate(Halt);

        state Parent {
            entry: p_in;
            exit:  p_out;
            default(A);
            state A {
                entry: a_in;
                exit:  a_out;
                on(GoB) => B;
                on(GoC) => C;
                on(GoD) => D;
                on(GoE) => E;
            }
            state B {
                entry: b_in;
                exit:  b_out;
                on(GoC) => C;
            }
        }
        state C {
            entry: c_in;
            exit:  c_out;
        }
        state D {
            entry: d_in;
            exit:  d_out;
            default(E);
            state E {
                entry: e_in;
                exit:  e_out;
            }
        }
    }
}

impl LatActions for LatActionContext<'_> {
    async fn p_in(&mut self)  {}
    async fn p_out(&mut self) {}
    async fn a_in(&mut self)  {}
    async fn a_out(&mut self) {}
    async fn b_in(&mut self)  {}
    async fn b_out(&mut self) {}
    async fn c_in(&mut self)  {}
    async fn c_out(&mut self) {}
    async fn d_in(&mut self)  {}
    async fn d_out(&mut self) {}
    async fn e_in(&mut self)  {}
    async fn e_out(&mut self) {}
}

// State ids: 0=Root, 1=Parent, 2=A, 3=B, 4=C, 5=D, 6=E.
const SR: u16 = 0;
const SP: u16 = 1;
const SA: u16 = 2;
const SB: u16 = 3;
const SC: u16 = 4;
const SD: u16 = 5;
const SE: u16 = 6;
// Action ids in declaration order: 0=p_in, 1=p_out, 2=a_in, 3=a_out,
// 4=b_in, 5=b_out, 6=c_in, 7=c_out, 8=d_in, 9=d_out, 10=e_in, 11=e_out.
const A_P_IN: u16 = 0;
const A_P_OUT: u16 = 1;
const A_A_IN: u16 = 2;
const A_A_OUT: u16 = 3;
const A_B_IN: u16 = 4;
const A_B_OUT: u16 = 5;
const A_C_IN: u16 = 6;
const A_C_OUT: u16 = 7;
const A_D_IN: u16 = 8;
const A_D_OUT: u16 = 9;
const A_E_IN: u16 = 10;
const A_E_OUT: u16 = 11;
// Event ids in first-seen order: 0=GoB, 1=GoC, 2=GoD, 3=GoE, 4=Halt.
const E_GOB: u16 = 0;
const E_GOC: u16 = 1;
const E_GOD: u16 = 2;
const E_GOE: u16 = 3;

fn entry(state: u16, action: u16) -> TraceEvent {
    TraceEvent::ActionInvoked { state, action, kind: ActionKind::Entry }
}
fn exit_(state: u16, action: u16) -> TraceEvent {
    TraceEvent::ActionInvoked { state, action, kind: ActionKind::Exit }
}
#[allow(dead_code)]
fn handler(state: u16, action: u16) -> TraceEvent {
    TraceEvent::ActionInvoked { state, action, kind: ActionKind::Handler }
}

// Initial descent: Root → Parent → A.
fn initial_descent() -> Vec<TraceEvent> {
    vec![
        TraceEvent::Started { chart_hash: Lat::<8>::CHART_HASH },
        TraceEvent::Entered { state: SR },
        TraceEvent::Entered { state: SP },
        entry(SP, A_P_IN),
        TraceEvent::Entered { state: SA },
        entry(SA, A_A_IN),
    ]
}

// Compare actual vs expected and report first mismatch.
fn assert_journal(actual: &[TraceEvent], expected: &[TraceEvent]) {
    let mismatch = actual.iter().zip(expected.iter())
        .position(|(a, e)| a != e);
    if let Some(i) = mismatch {
        panic!(
            "journal mismatch at index {}\n  actual:   {:?}\n  expected: {:?}\n  full actual: {:#?}",
            i, actual[i], expected[i], actual
        );
    }
    assert_eq!(actual.len(), expected.len(),
        "journal length mismatch: actual {} vs expected {}\n  full actual: {:#?}",
        actual.len(), expected.len(), actual);
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_a_to_b_lca_is_parent() {
    // Spec: A → B (siblings under Parent). LCA = Parent. Parent is not exited
    // or re-entered.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoB).await;
        let actual = m.take_journal();

        let mut expected = initial_descent();
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SA, event: E_GOB },
            TraceEvent::TransitionFired { from: Some(SA), to: SB },
            exit_(SA, A_A_OUT),
            TraceEvent::Exited { state: SA },
            TraceEvent::Entered { state: SB },
            entry(SB, A_B_IN),
        ]);
        assert_journal(&actual, &expected);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_a_to_c_exits_parent() {
    // A → C: A is inside Parent, C is sibling of Parent. LCA = Root.
    // Exit A, exit Parent. Enter C.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoC).await;
        let actual = m.take_journal();

        let mut expected = initial_descent();
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SA, event: E_GOC },
            TraceEvent::TransitionFired { from: Some(SA), to: SC },
            exit_(SA, A_A_OUT),
            TraceEvent::Exited { state: SA },
            exit_(SP, A_P_OUT),
            TraceEvent::Exited { state: SP },
            TraceEvent::Entered { state: SC },
            entry(SC, A_C_IN),
        ]);
        assert_journal(&actual, &expected);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_target_with_children_default_descends() {
    // A → D: D has child E (default). After entering D, default-descend to E.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoD).await;
        let actual = m.take_journal();

        let mut expected = initial_descent();
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SA, event: E_GOD },
            TraceEvent::TransitionFired { from: Some(SA), to: SD },
            exit_(SA, A_A_OUT),
            TraceEvent::Exited { state: SA },
            exit_(SP, A_P_OUT),
            TraceEvent::Exited { state: SP },
            TraceEvent::Entered { state: SD },
            entry(SD, A_D_IN),
            TraceEvent::Entered { state: SE },
            entry(SE, A_E_IN),
        ]);
        assert_journal(&actual, &expected);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_to_deeply_nested_target() {
    // A → E (E is the leaf of D's default chain). The target itself is the leaf
    // so default-descent doesn't add another level — but D is entered along the way.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoE).await;
        let actual = m.take_journal();

        let mut expected = initial_descent();
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SA, event: E_GOE },
            TraceEvent::TransitionFired { from: Some(SA), to: SE },
            exit_(SA, A_A_OUT),
            TraceEvent::Exited { state: SA },
            exit_(SP, A_P_OUT),
            TraceEvent::Exited { state: SP },
            TraceEvent::Entered { state: SD },
            entry(SD, A_D_IN),
            TraceEvent::Entered { state: SE },
            entry(SE, A_E_IN),
        ]);
        assert_journal(&actual, &expected);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_chained_transitions() {
    // A → B → C: two consecutive transitions. Each independently records its
    // exits and entries.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoB).await;
        let _ = m.dispatch(Ev::GoC).await;
        let actual = m.take_journal();

        let mut expected = initial_descent();
        // A → B
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SA, event: E_GOB },
            TraceEvent::TransitionFired { from: Some(SA), to: SB },
            exit_(SA, A_A_OUT),
            TraceEvent::Exited { state: SA },
            TraceEvent::Entered { state: SB },
            entry(SB, A_B_IN),
        ]);
        // B → C (LCA = Root, so Parent exits too).
        expected.extend(vec![
            TraceEvent::EventDelivered { handler_state: SB, event: E_GOC },
            TraceEvent::TransitionFired { from: Some(SB), to: SC },
            exit_(SB, A_B_OUT),
            TraceEvent::Exited { state: SB },
            exit_(SP, A_P_OUT),
            TraceEvent::Exited { state: SP },
            TraceEvent::Entered { state: SC },
            entry(SC, A_C_IN),
        ]);
        assert_journal(&actual, &expected);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_lca_stays_active() {
    // A → B: Parent (the LCA) must NOT appear in any Exited or Entered event.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoB).await;
        let j = m.take_journal();
        // After initial Entered(Parent), Parent must not appear again.
        let parent_events: Vec<&TraceEvent> = j.iter().skip(3).filter(|e| matches!(
            e,
            TraceEvent::Entered { state: SP } | TraceEvent::Exited { state: SP }
        )).collect();
        assert!(parent_events.is_empty(),
            "LCA Parent must not be re-entered or exited; got: {:?}", parent_events);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_exit_inner_then_outer() {
    // A → C: exit A first (deeper), then Parent (outer).
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoC).await;
        let exits: Vec<u16> = m.journal().iter().filter_map(|e| match e {
            TraceEvent::Exited { state } => Some(*state),
            _ => None,
        }).collect();
        // First exit must be A (deeper), then Parent (outer).
        assert_eq!(&exits[..2], &[SA, SP], "exits must be inner-to-outer");
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_entry_outer_then_inner() {
    // A → D where D has child E: enter D first, then E.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoD).await;
        let entries: Vec<u16> = m.journal().iter().skip_while(|e| !matches!(
            e,
            TraceEvent::TransitionFired { .. }
        )).filter_map(|e| match e {
            TraceEvent::Entered { state } => Some(*state),
            _ => None,
        }).collect();
        assert_eq!(&entries, &[SD, SE], "entries on the way down must be outer-to-inner");
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_no_default_when_target_is_leaf() {
    // A → C where C is a leaf: no default-descent, journal stops at C.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoC).await;
        let last_entered: Vec<u16> = m.journal().iter().filter_map(|e| match e {
            TraceEvent::Entered { state } => Some(*state),
            _ => None,
        }).collect();
        // Initial: Root, Parent, A. After GoC: C. No further entries.
        assert_eq!(last_entered, vec![SR, SP, SA, SC]);
    }).await;
}

#[tokio::test(flavor = "current_thread")]
async fn det_lateral_event_delivered_records_handler_state() {
    // The handler for GoB lives on A. EventDelivered.handler_state = A.
    tokio::task::LocalSet::new().run_until(async {
        let mut m = Lat::new(Ctx);
        let _ = m.dispatch(Ev::GoB).await;
        let delivered = m.journal().iter().find(|e| matches!(
            e, TraceEvent::EventDelivered { event: E_GOB, .. }
        ));
        assert!(matches!(
            delivered,
            Some(TraceEvent::EventDelivered { handler_state: SA, event: E_GOB })
        ), "got: {:?}", delivered);
    }).await;
}