use rand::SeedableRng;
use rand::rngs::SmallRng;
use super::{
Charset, EngineFlags, MatrixState, TAIL_FADE_DISTANCE_LIMIT, VALUE_BAR, VALUE_DOT,
VALUE_LAMBDA, VALUE_SPACE,
};
fn seeded_rng() -> SmallRng {
SmallRng::seed_from_u64(42)
}
#[test]
fn initializes_with_minimum_dimensions_and_sentinels() {
let mut rng = seeded_rng();
let state = MatrixState::new(2, 2, &mut rng);
assert_eq!(state.width(), 10);
assert_eq!(state.height(), 10);
for col in (0..state.width()).step_by(2) {
assert_eq!(state.value_at(1, col), VALUE_SPACE);
}
}
#[test]
fn asynchronous_mode_skips_tick_one_updates() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(80, 24, &mut rng);
let baseline = state.clone();
let flags = EngineFlags {
asynchronous: true,
deep: false,
old_style: false,
dynamic_chars: false,
paused: false,
};
state.step(1, &flags, Charset::from_modes(false, false), &mut rng);
assert_eq!(state, baseline);
}
#[test]
fn paused_state_keeps_matrix_unchanged() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(80, 24, &mut rng);
let baseline = state.clone();
let flags = EngineFlags {
asynchronous: false,
deep: false,
old_style: false,
dynamic_chars: true,
paused: true,
};
state.step(4, &flags, Charset::from_modes(false, false), &mut rng);
assert_eq!(state, baseline);
}
#[test]
fn old_style_converts_dot_head_into_bar() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(80, 24, &mut rng);
let flags = EngineFlags {
asynchronous: false,
deep: false,
old_style: true,
dynamic_chars: false,
paused: false,
};
state.set_value(0, 0, VALUE_DOT);
state.step(4, &flags, Charset::from_modes(false, false), &mut rng);
assert_eq!(state.value_at(0, 0), VALUE_BAR);
}
#[test]
fn charset_changes_only_affect_symbols_generated_after_each_toggle() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(10, 10, &mut rng);
state.set_value(1, 0, 'A' as i32);
let flags = EngineFlags {
asynchronous: false,
deep: false,
old_style: false,
dynamic_chars: false,
paused: false,
};
state.step(4, &flags, Charset::from_modes(true, false), &mut rng);
state.step(
4,
&flags,
Charset::from_modes(false, false).with_lambda_mode(true),
&mut rng,
);
state.step(4, &flags, Charset::from_modes(false, false), &mut rng);
assert_eq!(state.value_at(1, 0), 'A' as i32);
assert!((0xff66..0xff9d).contains(&state.value_at(2, 0)));
assert_eq!(state.value_at(3, 0), VALUE_LAMBDA);
assert!((33..123).contains(&state.value_at(4, 0)));
}
#[test]
fn deep_mode_uses_smooth_fractional_motion_for_three_depth_planes() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(10, 10, &mut rng);
for (column, plane) in [(0, 1), (2, 2), (4, 3)] {
state.updates[column] = plane;
state.deep_progress[column] = 0;
state.spaces[column] = 10;
}
let flags = EngineFlags {
asynchronous: false,
deep: true,
old_style: false,
dynamic_chars: false,
paused: false,
};
let charset = Charset::from_modes(false, false);
let columns = [0, 2, 4];
let mut movement = [[false; 6]; 3];
for tick in 1..=6 {
let before = columns.map(|column| state.spaces[column]);
state.step(tick as u8, &flags, charset, &mut rng);
for (plane, column) in columns.into_iter().enumerate() {
movement[plane][tick - 1] = state.spaces[column] < before[plane];
}
}
assert_eq!(movement[0], [true; 6]);
assert_eq!(movement[1], [false, true, true, false, true, true]);
assert_eq!(movement[2], [false, true, false, true, false, true]);
}
#[test]
fn tail_distance_tracks_the_head_and_caps_the_fade_scan() {
let mut rng = seeded_rng();
let mut state = MatrixState::new(10, 10, &mut rng);
for row in 1..=8 {
state.set_value(row, 0, ('A' as usize + row) as i32);
}
state.set_head(8, 0, true);
assert_eq!(state.tail_distance_to_head(1, 0), TAIL_FADE_DISTANCE_LIMIT);
assert_eq!(state.tail_distance_to_head(5, 0), 3);
assert_eq!(state.tail_distance_to_head(6, 0), 2);
assert_eq!(state.tail_distance_to_head(7, 0), 1);
assert_eq!(state.tail_distance_to_head(8, 0), 0);
}