sim-logic 0.1.0

A code-first application and logic layer for Sim;Engine
Documentation
use std::time::Duration;

use sim_logic::prelude::*;

use super::support::*;

#[test]
fn complete_same_frame_gestures_use_each_edges_target_pointer_and_token() -> LogicResult {
    let mut runner = runner(false)?;
    let pressed = sample(20.0, 30.0, 800.0, 600.0)?;
    let released = sample(50.0, 60.0, 900.0, 650.0)?;
    advance(
        &mut runner,
        Duration::ZERO,
        &[
            InputEvent::pointer_moved(pressed),
            press(),
            InputEvent::pointer_moved(released),
            release(),
            motion(180.0, 40.0)?,
            press(),
            release(),
            motion(700.0, 500.0)?,
        ],
    )?;
    let observations = frame(&runner)?;
    assert_eq!(observations.len(), 4);
    assert_eq!(
        events(&runner)?,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
            (EventKind::Pressed, Target::Second),
            (EventKind::Clicked, Target::Second),
        ]
    );
    for entry in observations {
        let event = entry.event.ok_or("button event missing")?;
        assert!(entry.claimed);
        assert_eq!(event.pointer, entry.edge.pointer());
        assert_eq!(event.intent, entry.edge.intent());
    }
    assert_eq!(
        observations[0].event.ok_or("press missing")?.pointer,
        Some(pressed)
    );
    assert_eq!(
        observations[1].event.ok_or("click missing")?.pointer,
        Some(released)
    );
    assert_ne!(observations[0].edge.intent(), observations[1].edge.intent());
    assert_eq!(observations[0].captured, Some(Target::First));
    assert_eq!(observations[1].captured, None);
    assert_eq!(captured(&runner)?, None);
    assert_eq!(probe(&runner)?.background_presses, 0);
    assert_eq!(probe(&runner)?.background_releases, 0);
    Ok(())
}

#[test]
fn outside_press_remains_unclaimed_when_released_over_a_button() -> LogicResult {
    let mut runner = runner(false)?;
    advance(&mut runner, STEP, &[motion(500.0, 400.0)?, press()])?;
    assert_eq!(captured(&runner)?, None);
    advance(&mut runner, STEP, &[motion(20.0, 30.0)?, release()])?;
    assert!(events(&runner)?.is_empty());
    assert!(
        probe(&runner)?
            .frames
            .iter()
            .flatten()
            .all(|entry| !entry.claimed)
    );
    assert_eq!(probe(&runner)?.background_presses, 1);
    assert_eq!(probe(&runner)?.background_releases, 1);
    advance(&mut runner, STEP, &[press(), release()])?;
    assert_eq!(
        events(&runner)?,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
        ]
    );
    Ok(())
}

#[test]
fn captured_target_survives_motion_but_release_over_another_target_cancels() -> LogicResult {
    let mut runner = runner(false)?;
    advance(&mut runner, STEP, &[motion(20.0, 30.0)?, press()])?;
    advance(&mut runner, STEP, &[motion(180.0, 30.0)?])?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    advance(&mut runner, STEP, &[release()])?;
    let outside = frame(&runner)?[0];
    assert!(outside.claimed);
    assert_eq!(
        outside.event.ok_or("cancel missing")?.kind,
        EventKind::ReleasedOutside
    );
    assert_eq!(outside.event.ok_or("cancel missing")?.target, Target::First);
    assert_eq!(
        outside.event.ok_or("cancel missing")?.intent,
        outside.edge.intent()
    );
    assert_eq!(captured(&runner)?, None);

    advance(
        &mut runner,
        STEP,
        &[motion(20.0, 30.0)?, press(), motion(500.0, 400.0)?],
    )?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    advance(&mut runner, STEP, &[motion(50.0, 60.0)?, release()])?;
    assert_eq!(
        frame(&runner)?[0].event.ok_or("click missing")?.kind,
        EventKind::Clicked
    );
    assert_eq!(probe(&runner)?.background_releases, 0);
    Ok(())
}

#[test]
fn keyboard_alias_and_other_mouse_buttons_do_not_change_capture() -> LogicResult {
    let mut runner = runner(false)?;
    advance(
        &mut runner,
        STEP,
        &[
            motion(20.0, 30.0)?,
            press(),
            motion(180.0, 30.0)?,
            key(PhysicalKeyCode::Space, ButtonState::Pressed),
            InputEvent::mouse_button(MouseButton::Right, ButtonState::Pressed),
            InputEvent::mouse_button(MouseButton::Middle, ButtonState::Pressed),
            key(PhysicalKeyCode::Space, ButtonState::Released),
            InputEvent::mouse_button(MouseButton::Right, ButtonState::Released),
            InputEvent::mouse_button(MouseButton::Middle, ButtonState::Released),
        ],
    )?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    for entry in &frame(&runner)?[1..] {
        assert!(!entry.claimed);
        assert_eq!(entry.event, None);
        assert_eq!(entry.captured, Some(Target::First));
    }
    advance(&mut runner, STEP, &[motion(20.0, 30.0)?, release()])?;
    assert_eq!(
        frame(&runner)?[0].event.ok_or("click missing")?.kind,
        EventKind::Clicked
    );
    assert_eq!(
        runner
            .resource::<Interaction>()
            .ok_or("interaction missing")?
            .button
            .button(),
        MouseButton::Left
    );
    Ok(())
}

#[test]
fn cancellation_is_claimed_and_never_confirms_then_a_new_gesture_can_click() -> LogicResult {
    for (event, reason) in [
        (
            InputEvent::PointerLeft,
            InputCancellationReason::PointerLeft,
        ),
        (InputEvent::FocusLost, InputCancellationReason::FocusLost),
    ] {
        let mut runner = runner(false)?;
        advance(
            &mut runner,
            STEP,
            &[
                motion(20.0, 30.0)?,
                key(PhysicalKeyCode::Space, ButtonState::Pressed),
                press(),
                event,
                motion(180.0, 30.0)?,
                press(),
                release(),
            ],
        )?;
        assert_eq!(
            events(&runner)?,
            [
                (EventKind::Pressed, Target::First),
                (EventKind::InputCancelled(reason), Target::First),
                (EventKind::Pressed, Target::Second),
                (EventKind::Clicked, Target::Second),
            ]
        );
        let cancellation = frame(&runner)?
            .iter()
            .find(|entry| {
                entry
                    .event
                    .is_some_and(|event| event.kind == EventKind::InputCancelled(reason))
            })
            .ok_or("cancellation missing")?;
        assert!(cancellation.claimed);
        assert_eq!(cancellation.captured, None);
        assert_eq!(
            cancellation.event.ok_or("cancellation missing")?.intent,
            cancellation.edge.intent()
        );
        assert_eq!(cancellation.edge.pointer(), None);
        assert_eq!(probe(&runner)?.background_releases, 0);
    }
    Ok(())
}

#[test]
fn invalidation_suppresses_release_even_after_the_same_target_is_enabled_again() -> LogicResult {
    let mut runner = runner(false)?;
    advance(&mut runner, STEP, &[motion(20.0, 30.0)?, press()])?;
    advance(
        &mut runner,
        STEP,
        &[
            key(PhysicalKeyCode::KeyD, ButtonState::Pressed),
            key(PhysicalKeyCode::KeyD, ButtonState::Released),
            key(PhysicalKeyCode::KeyD, ButtonState::Pressed),
            key(PhysicalKeyCode::KeyN, ButtonState::Pressed),
            press(),
        ],
    )?;
    assert_eq!(captured(&runner)?, None);
    assert_eq!(
        probe(&runner)?.explicit_cancellations,
        [Some(Target::First), None]
    );
    advance(&mut runner, STEP, &[release()])?;
    assert!(frame(&runner)?[0].claimed);
    assert_eq!(frame(&runner)?[0].event, None);
    assert_eq!(probe(&runner)?.background_releases, 0);
    advance(&mut runner, STEP, &[press(), release()])?;
    assert_eq!(
        events(&runner)?,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
        ]
    );
    Ok(())
}

#[test]
fn cancelling_idle_or_outside_state_does_not_claim_background_gestures() -> LogicResult {
    let mut runner = runner(false)?;
    advance(
        &mut runner,
        STEP,
        &[
            key(PhysicalKeyCode::KeyD, ButtonState::Pressed),
            key(PhysicalKeyCode::KeyD, ButtonState::Released),
            motion(500.0, 400.0)?,
            press(),
            key(PhysicalKeyCode::KeyD, ButtonState::Pressed),
            release(),
        ],
    )?;
    assert_eq!(probe(&runner)?.explicit_cancellations, [None, None]);
    assert!(events(&runner)?.is_empty());
    assert_eq!(probe(&runner)?.background_presses, 1);
    assert_eq!(probe(&runner)?.background_releases, 1);
    Ok(())
}

#[test]
fn missing_or_outside_press_positions_cannot_be_overridden_by_a_caller_target() -> LogicResult {
    let mut runner = runner(true)?;
    advance(
        &mut runner,
        STEP,
        &[press(), motion(20.0, 30.0)?, release()],
    )?;
    assert!(events(&runner)?.is_empty());
    for (x, y) in [(-1.0, 30.0), (800.0, 30.0), (20.0, -1.0), (20.0, 600.0)] {
        advance(
            &mut runner,
            STEP,
            &[motion(x, y)?, press(), motion(20.0, 30.0)?, release()],
        )?;
        assert!(
            frame(&runner)?
                .iter()
                .all(|entry| !entry.claimed && entry.event.is_none())
        );
    }
    assert!(events(&runner)?.is_empty());
    advance(&mut runner, STEP, &[press(), release()])?;
    assert_eq!(
        events(&runner)?,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
        ]
    );
    Ok(())
}

#[test]
fn outside_release_is_cancelled_even_when_the_caller_returns_the_captured_target() -> LogicResult {
    let mut runner = runner(true)?;
    for (x, y) in [(-1.0, 30.0), (800.0, 30.0), (20.0, -1.0), (20.0, 600.0)] {
        advance(
            &mut runner,
            STEP,
            &[motion(20.0, 30.0)?, press(), motion(x, y)?, release()],
        )?;
        let release = frame(&runner)?[1];
        assert!(release.claimed);
        assert_eq!(
            release.event.ok_or("cancellation missing")?.kind,
            EventKind::ReleasedOutside
        );
        assert_eq!(release.captured, None);
    }
    Ok(())
}