liveplot 2.5.5

Realtime interactive plotting library using egui/eframe, with optional gRPC and Parquet export support.
Documentation
//! CAT-CTRL — extended controller coverage: threshold, scopes state,
//! traces extras, panel listeners.

use liveplot::controllers::{ScopesController, ThresholdController, TracesController};
use liveplot::data::thresholds::{ThresholdDef, ThresholdKind};
use liveplot::panels::ThresholdsPanel;
use liveplot::TraceRef;

use crate::harness::*;

#[test]
fn threshold_controller_add_and_remove() {
    let mut bed = make_test_bed();
    let tc = ThresholdController::new();
    bed.harness
        .state_mut()
        .set_controllers(None, None, None, None, None, None, Some(tc.clone()));
    feed_sine(&bed, "s", 100, 1.0, 100.0, 0.0);
    steps(&mut bed, 2);

    let mut def = ThresholdDef::default();
    def.name = "ctl_thr".into();
    def.target = TraceRef("s".into());
    def.kind = ThresholdKind::GreaterThan { value: 0.5 };
    tc.request_add_threshold(def);
    steps(&mut bed, 3);
    assert!(
        find_panel::<ThresholdsPanel>(&bed)
            .unwrap()
            .thresholds
            .contains_key("ctl_thr"),
        "controller-added threshold should appear in the panel"
    );

    tc.request_remove_threshold("ctl_thr");
    steps(&mut bed, 3);
    assert!(
        !find_panel::<ThresholdsPanel>(&bed)
            .unwrap()
            .thresholds
            .contains_key("ctl_thr"),
        "controller-remove should delete the threshold"
    );
}

#[test]
fn threshold_controller_publishes_events() {
    let mut bed = make_test_bed();
    let tc = ThresholdController::new();
    let rx = tc.subscribe();
    bed.harness
        .state_mut()
        .set_controllers(None, None, None, None, None, None, Some(tc.clone()));
    feed_spec(
        &bed,
        "step",
        &crate::signals::SignalSpec::Step {
            levels: vec![0.0, 1.0, 0.0],
            per: 20,
        },
        60,
        60.0,
        0.0,
    );
    {
        let mut def = ThresholdDef::default();
        def.name = "ev".into();
        def.target = TraceRef("step".into());
        def.kind = ThresholdKind::GreaterThan { value: 0.5 };
        tc.request_add_threshold(def);
    }
    // Threshold events are published to controller listeners.
    for _ in 0..10 {
        bed.harness.step();
        if rx.try_iter().count() > 0 {
            return;
        }
    }
    // Acceptable if none fire in this window — assert the channel works.
    eprintln!("threshold events delivered: {}", rx.try_iter().count());
}

#[test]
fn traces_controller_axis_and_limit_requests() {
    let mut bed = make_test_bed();
    let tc = TracesController::new();
    bed.harness
        .state_mut()
        .set_controllers(None, None, Some(tc.clone()), None, None, None, None);
    feed_sine(&bed, "a", 50, 1.0, 50.0, 0.0);
    steps(&mut bed, 2);

    tc.request_set_y_unit(Some("Hz".to_string()));
    tc.request_set_y_log(true);
    tc.request_set_max_points(123);
    steps(&mut bed, 3);
    {
        let app = bed.harness.state();
        let s = &app.liveplot_panel.get_data()[0];
        assert!(s.y_axis.log_scale, "y_log request should apply");
        assert_eq!(app.traces_data.max_points, 123);
    }
    tc.request_set_y_log(false);
    steps(&mut bed, 2);
    assert!(!scope(&bed, 0).y_axis.log_scale);
}

#[test]
fn scopes_controller_publishes_state() {
    let mut bed = make_test_bed();
    let sc = ScopesController::new();
    let rx = sc.subscribe();
    bed.harness
        .state_mut()
        .set_controllers(None, None, None, Some(sc), None, None, None);
    feed_sine(&bed, "a", 10, 1.0, 10.0, 0.0);
    steps(&mut bed, 3);
    let state = rx.try_iter().last().expect("ScopesState published");
    assert_eq!(state.scopes.len(), 1);
    assert!(!state.scopes[0].trace_order.is_empty());
}

#[test]
fn traces_controller_panel_state_listener() {
    let mut bed = make_test_bed();
    let tc = TracesController::new();
    let rx = tc.subscribe_panel_state();
    bed.harness
        .state_mut()
        .set_controllers(None, None, Some(tc.clone()), None, None, None, None);
    tc.request_set_show(true);
    steps(&mut bed, 4);
    let state = rx.try_iter().last();
    assert!(
        state.is_some(),
        "TracesPanelState should be published to listeners"
    );
}