matrixr 1.1.0

Animated Matrix-style terminal screensaver
Documentation
use std::time::{Duration, Instant};

use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers};

use super::{
    DEFAULT_RENDER_FPS, LOCK_MESSAGE_TEXT, LoopControl, MAX_RENDER_FPS, RuntimeState, TimedMessage,
    UNLOCK_MESSAGE_TEXT,
};
use crate::config::Config;
use crate::engine::Charset;
use crate::renderer::MessagePosition;

fn key(ch: char) -> KeyEvent {
    KeyEvent::new(KeyCode::Char(ch), KeyModifiers::NONE)
}

fn key_with_kind(ch: char, kind: KeyEventKind) -> KeyEvent {
    let mut key = key(ch);
    key.kind = kind;
    key
}

#[test]
fn russian_layout_hotkeys_follow_qwerty_key_positions() {
    for (russian, english) in [
        ('Ё', '~'),
        ('й', 'q'),
        ('В', 'D'),
        ('в', 'd'),
        ('а', 'f'),
        ('ф', 'a'),
        ('и', 'b'),
        ('И', 'B'),
        ('л', 'k'),
        ('щ', 'o'),
        ('Д', 'L'),
        ('т', 'n'),
        ('к', 'r'),
        ('ь', 'm'),
        ('з', 'p'),
        ('З', 'P'),
        ('с', 'c'),
        ('ч', 'x'),
    ] {
        assert_eq!(
            super::normalize_runtime_hotkey(russian, KeyModifiers::NONE),
            english
        );
    }

    for (russian, english) in [('"', '@'), ('№', '#'), (';', '$'), (':', '^'), ('?', '&')] {
        assert_eq!(
            super::normalize_runtime_hotkey(russian, KeyModifiers::SHIFT),
            english
        );
    }
    assert_eq!(
        super::normalize_runtime_hotkey(';', KeyModifiers::NONE),
        ';'
    );

    let mut runtime = RuntimeState::from_config(Config::default());
    assert_eq!(runtime.handle_key(key('В'), 24), LoopControl::RefreshRender);
    assert!(runtime.deep);
    assert_eq!(
        runtime.handle_key(key_with_kind('в', KeyEventKind::Repeat), 24),
        LoopControl::RefreshRender
    );
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS - 1);

    let mut blue = key(';');
    blue.modifiers = KeyModifiers::SHIFT;
    assert_eq!(runtime.handle_key(blue, 24), LoopControl::RefreshRender);
    assert_eq!(runtime.color, crate::color::MatrixColor::Blue);

    let mut ctrl_c = key('с');
    ctrl_c.modifiers = KeyModifiers::CONTROL;
    assert_eq!(runtime.handle_key(ctrl_c, 24), LoopControl::Quit);
}

fn message_text(runtime: &RuntimeState, now: Instant) -> Option<&str> {
    runtime.message_for_render(now).map(|message| message.0)
}

#[test]
fn lock_toggles_and_quit_behavior_follows_lock_state() {
    let mut runtime = RuntimeState::from_config(Config::default());

    assert_eq!(runtime.handle_key(key('L'), 24), LoopControl::RefreshRender);
    assert!(runtime.lock);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some(LOCK_MESSAGE_TEXT)
    );
    assert_eq!(runtime.handle_key(key('q'), 24), LoopControl::Continue);

    assert_eq!(runtime.handle_key(key('L'), 24), LoopControl::RefreshRender);
    assert!(!runtime.lock);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some(UNLOCK_MESSAGE_TEXT)
    );
    assert_eq!(runtime.handle_key(key('q'), 24), LoopControl::Quit);

    let config = Config {
        lock: true,
        ..Config::default()
    };
    let mut startup_locked = RuntimeState::from_config(config);
    assert!(startup_locked.lock);
    assert_eq!(
        message_text(&startup_locked, Instant::now()),
        Some(LOCK_MESSAGE_TEXT)
    );
    startup_locked.handle_key(key('L'), 24);
    assert!(!startup_locked.lock);
    assert_eq!(
        message_text(&startup_locked, Instant::now()),
        Some(UNLOCK_MESSAGE_TEXT)
    );
}

#[test]
fn auto_lock_message_hides_after_timeout() {
    let mut runtime = RuntimeState::from_config(Config::default());

    runtime.handle_key(key('L'), 24);
    let now = Instant::now();
    assert_eq!(message_text(&runtime, now), Some(LOCK_MESSAGE_TEXT));

    runtime.transient_message = Some(TimedMessage {
        text: LOCK_MESSAGE_TEXT.to_owned(),
        visible_until: now - Duration::from_millis(1),
        position: MessagePosition::Center,
    });
    assert_eq!(message_text(&runtime, now), None);
}

#[test]
fn classic_toggle_updates_charset_used_for_future_symbols() {
    let mut runtime = RuntimeState::from_config(Config::default());

    assert_eq!(runtime.handle_key(key('c'), 24), LoopControl::RefreshRender);
    assert!(runtime.classic);
    assert_eq!(runtime.charset(), Charset::from_modes(true, false));

    assert_eq!(runtime.handle_key(key('c'), 24), LoopControl::RefreshRender);
    assert!(!runtime.classic);
    assert_eq!(runtime.charset(), Charset::from_modes(false, false));
}

#[test]
fn lambda_toggle_updates_charset_used_for_future_symbols() {
    let mut runtime = RuntimeState::from_config(Config::default());

    assert_eq!(runtime.handle_key(key('m'), 24), LoopControl::RefreshRender);
    assert!(runtime.lambda_mode);
    assert_eq!(
        runtime.charset(),
        Charset::from_modes(false, false).with_lambda_mode(true)
    );

    assert_eq!(runtime.handle_key(key('m'), 24), LoopControl::RefreshRender);
    assert!(!runtime.lambda_mode);
    assert_eq!(runtime.charset(), Charset::from_modes(false, false));
}

#[test]
fn default_runtime_values_keep_speed_mode_four_and_use_sixty_fps() {
    let runtime = RuntimeState::from_config(Config::default());

    assert_eq!(runtime.update_delay, 4);
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS);
}

#[test]
fn uppercase_d_toggles_deep_mode_without_replacing_lowercase_fps_control() {
    let mut runtime = RuntimeState::from_config(Config {
        deep: true,
        ..Config::default()
    });

    assert_eq!(runtime.handle_key(key('D'), 24), LoopControl::RefreshRender);
    assert!(!runtime.deep);

    assert_eq!(runtime.handle_key(key('D'), 24), LoopControl::RefreshRender);
    assert!(runtime.engine_flags().deep);
    assert!(runtime.render_options(None).deep);
    assert_eq!(message_text(&runtime, Instant::now()), Some("Deep: on"));

    let initial_fps = runtime.render_fps;
    assert_eq!(runtime.handle_key(key('d'), 24), LoopControl::RefreshRender);
    assert!(runtime.deep);
    assert_eq!(runtime.render_fps, initial_fps - 1);
}

#[test]
fn fps_hotkeys_adjust_by_one_and_clamp_to_supported_range() {
    let mut runtime = RuntimeState::from_config(Config::default());

    runtime.handle_key(key('d'), 24);
    assert_eq!(runtime.render_fps, 59);
    runtime.handle_key(key('f'), 24);
    assert_eq!(runtime.render_fps, 60);

    runtime.render_fps = 1;
    assert_eq!(runtime.handle_key(key('d'), 24), LoopControl::RefreshRender);
    assert_eq!(runtime.render_fps, 1);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some("FPS: 1 (d-/f+)")
    );

    runtime.render_fps = MAX_RENDER_FPS;
    assert_eq!(runtime.handle_key(key('f'), 24), LoopControl::RefreshRender);
    assert_eq!(runtime.render_fps, MAX_RENDER_FPS);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some("FPS: 120 (d-/f+)")
    );
}

#[test]
fn key_repeat_is_limited_to_fps_controls_and_release_is_ignored() {
    let mut runtime = RuntimeState::from_config(Config::default());

    assert_eq!(
        runtime.handle_key(key_with_kind('d', KeyEventKind::Repeat), 24),
        LoopControl::RefreshRender
    );
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS - 1);
    assert_eq!(
        runtime.handle_key(key_with_kind('f', KeyEventKind::Repeat), 24),
        LoopControl::RefreshRender
    );
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS);

    for ch in ['c', 'm', 'r', 'p', 'L', 'D'] {
        assert_eq!(
            runtime.handle_key(key_with_kind(ch, KeyEventKind::Repeat), 24),
            LoopControl::Continue
        );
    }
    assert!(!runtime.classic);
    assert!(!runtime.lambda_mode);
    assert!(!runtime.rainbow);
    assert!(!runtime.paused);
    assert!(!runtime.lock);

    for ch in ['f', 'q', 'c'] {
        assert_eq!(
            runtime.handle_key(key_with_kind(ch, KeyEventKind::Release), 24),
            LoopControl::Continue
        );
    }
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS);
    assert!(!runtime.classic);
}

#[test]
fn runtime_changes_update_values_and_top_right_status() {
    let mut runtime = RuntimeState::from_config(Config::default());

    runtime.handle_key(key('f'), 24);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some("FPS: 61 (d-/f+)")
    );
    assert_eq!(
        runtime
            .transient_message
            .as_ref()
            .map(|message| message.position),
        Some(MessagePosition::TopRight)
    );

    runtime.handle_key(key('7'), 24);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some("Speed: 7 (0-9)")
    );

    runtime.handle_key(key('a'), 24);
    assert!(runtime.asynchronous);
    assert_eq!(
        message_text(&runtime, Instant::now()),
        Some("Asynchronous: on")
    );

    runtime.handle_key(key('r'), 24);
    assert!(runtime.rainbow);
    assert_eq!(message_text(&runtime, Instant::now()), Some("Rainbow: on"));
    runtime.handle_key(key('r'), 24);
    assert!(!runtime.rainbow);
    assert_eq!(message_text(&runtime, Instant::now()), Some("Rainbow: off"));
}

#[test]
fn speed_and_fps_hotkeys_change_only_their_own_setting() {
    let mut runtime = RuntimeState::from_config(Config::default());

    runtime.handle_key(key('7'), 24);
    assert_eq!(runtime.update_delay, 7);
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS);

    runtime.handle_key(key('0'), 24);
    assert_eq!(runtime.update_delay, 0);
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS);

    runtime.handle_key(key('d'), 24);
    assert_eq!(runtime.update_delay, 0);
    assert_eq!(runtime.render_fps, DEFAULT_RENDER_FPS - 1);
}

#[test]
fn shortcuts_popup_interactions() {
    let mut runtime = RuntimeState::from_config(Config::default());
    let rows = 7;
    let named_key = |code| KeyEvent::new(code, KeyModifiers::NONE);

    runtime.handle_key(key('~'), rows);
    runtime.handle_key(
        KeyEvent::new_with_kind(KeyCode::Down, KeyModifiers::NONE, KeyEventKind::Repeat),
        rows,
    );
    assert_eq!(runtime.shortcuts_scroll, Some(1));

    runtime.handle_key(named_key(KeyCode::End), rows);
    assert_eq!(
        runtime.shortcuts_scroll,
        Some(crate::help::popup_max_scroll(rows))
    );
    runtime.handle_key(key('~'), rows);
    assert_eq!(runtime.shortcuts_scroll, None);

    runtime.handle_key(key('~'), rows);
    runtime.handle_key(named_key(KeyCode::Esc), rows);
    assert_eq!(runtime.shortcuts_scroll, None);

    runtime.handle_key(key('~'), rows);
    runtime.handle_key(key('r'), rows);
    assert!(runtime.rainbow);
    assert_eq!(runtime.shortcuts_scroll, None);
}