From 40eb60295383d6a63e894e8fd894879c515e40d0 Mon Sep 17 00:00:00 2001 From: jk <47693+sectore@users.noreply.github.com> Date: Sat, 27 Sep 2025 20:03:48 +0200 Subject: [PATCH] tests --- src/widgets/clock_test.rs | 549 +++++++++++++++++++++++++++++++++++++- 1 file changed, 547 insertions(+), 2 deletions(-) diff --git a/src/widgets/clock_test.rs b/src/widgets/clock_test.rs index aee20f8..0278751 100644 --- a/src/widgets/clock_test.rs +++ b/src/widgets/clock_test.rs @@ -1,6 +1,6 @@ use crate::{ common::ClockTypeId, - duration::{ONE_DECI_SECOND, ONE_HOUR, ONE_MINUTE, ONE_SECOND}, + duration::{ONE_DAY, ONE_DECI_SECOND, ONE_HOUR, ONE_MINUTE, ONE_SECOND, ONE_YEAR}, widgets::clock::*, }; use std::time::Duration; @@ -23,6 +23,152 @@ fn test_type_id() { assert!(matches!(c.get_type_id(), ClockTypeId::Countdown)); } +#[test] +fn test_get_format_seconds() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: Duration::from_secs(5), + current_value: Duration::from_secs(5), + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + // S + assert_eq!(c.get_format(), Format::S); + // Ss + c.set_current_value(Duration::from_secs(15).into()); + assert_eq!(c.get_format(), Format::Ss); +} + +#[test] +fn test_get_format_minutes() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_MINUTE, + current_value: ONE_MINUTE, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + // MSs + assert_eq!(c.get_format(), Format::MSs); + // MmSs + c.set_current_value(Duration::from_secs(610).into()); // 10+ minutes + assert_eq!(c.get_format(), Format::MmSs); +} + +#[test] +fn test_get_format_hours() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_HOUR, + current_value: ONE_HOUR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + // HMmSS + assert_eq!(c.get_format(), Format::HMmSs); + // HhMmSs + c.set_current_value((10 * ONE_HOUR).into()); + assert_eq!(c.get_format(), Format::HhMmSs); +} + +#[test] +fn test_get_format_boundaries() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_SECOND, + current_value: ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // S + c.set_current_value(Duration::from_secs(9).into()); + assert_eq!(c.get_format(), Format::S); + // Ss + c.set_current_value((10 * ONE_SECOND).into()); + assert_eq!(c.get_format(), Format::Ss); + // Ss + c.set_current_value((59 * ONE_SECOND).into()); + assert_eq!(c.get_format(), Format::Ss); + // MSs + c.set_current_value(ONE_MINUTE.into()); + assert_eq!(c.get_format(), Format::MSs); + // HhMmSs + c.set_current_value((ONE_DAY.saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::HhMmSs); + // DHhMmSs + c.set_current_value(ONE_DAY.into()); + assert_eq!(c.get_format(), Format::DHhMmSs); + // DHhMmSs + c.set_current_value(((10 * ONE_DAY).saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::DHhMmSs); + // DdHhMmSs + c.set_current_value((10 * ONE_DAY).into()); + assert_eq!(c.get_format(), Format::DdHhMmSs); + // DdHhMmSs + c.set_current_value(((100 * ONE_DAY).saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::DdHhMmSs); + // DddHhMmSs + c.set_current_value((100 * ONE_DAY).into()); + assert_eq!(c.get_format(), Format::DddHhMmSs); + // DddHhMmSs + c.set_current_value((ONE_YEAR.saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::DddHhMmSs); + // YDddHhMmSs + c.set_current_value(ONE_YEAR.into()); + assert_eq!(c.get_format(), Format::YDddHhMmSs); + // YDddHhMmSs + c.set_current_value(((10 * ONE_YEAR).saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::YDddHhMmSs); + // YyDddHhMmSs + c.set_current_value((10 * ONE_YEAR).into()); + assert_eq!(c.get_format(), Format::YyDddHhMmSs); + // YyDddHhMmSs + c.set_current_value(((100 * ONE_YEAR).saturating_sub(ONE_SECOND)).into()); + assert_eq!(c.get_format(), Format::YyDddHhMmSs); + // YyyDddHhMmSs + c.set_current_value((100 * ONE_YEAR).into()); + assert_eq!(c.get_format(), Format::YyyDddHhMmSs); +} + +#[test] +fn test_get_format_days() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY, + current_value: ONE_DAY, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + // DHhMmSs + assert_eq!(c.get_format(), Format::DHhMmSs); + // DdHhMmSs + c.set_current_value((10 * ONE_DAY).into()); + assert_eq!(c.get_format(), Format::DdHhMmSs); + // DddHhMmSs + c.set_current_value((101 * ONE_DAY).into()); + assert_eq!(c.get_format(), Format::DddHhMmSs); +} + +#[test] +fn test_get_format_years() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + // YDddHhMmSs + assert_eq!(c.get_format(), Format::YDddHhMmSs); + // YyDddHhMmSs + c.set_current_value((10 * ONE_YEAR).into()); + assert_eq!(c.get_format(), Format::YyDddHhMmSs); + + c.set_current_value((100 * ONE_YEAR).into()); + assert_eq!(c.get_format(), Format::YyyDddHhMmSs); +} + #[test] fn test_default_edit_mode_hhmmss() { let mut c = ClockState::::new(ClockStateArgs { @@ -63,6 +209,249 @@ fn test_default_edit_mode_ss() { assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); } +#[test] +fn test_edit_up_stays_in_seconds() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_MINUTE - ONE_SECOND, + current_value: ONE_MINUTE - ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_up(); + // Edit mode should stay on seconds + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + +#[test] +fn test_edit_up_stays_in_minutes() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_HOUR - ONE_SECOND, + current_value: ONE_HOUR - ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); + c.edit_up(); + // Edit mode should stay on minutes + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_up_stays_in_hours() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY - ONE_SECOND, + current_value: ONE_DAY - ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_up(); + // Edit mode should stay on hours + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); +} + +#[test] +fn test_edit_up_stays_in_days() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR - ONE_DAY, + current_value: ONE_YEAR - ONE_DAY, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + c.edit_next(); // Hours + c.edit_next(); // Days + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_up(); + // Edit mode should stay on days + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); +} + +#[test] +fn test_edit_down_years_to_days() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + c.edit_next(); // Hours + c.edit_next(); // Days + c.edit_next(); // Years + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_down(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); +} + +#[test] +fn test_edit_down_days_to_hours() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY, + current_value: ONE_DAY, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + c.edit_next(); // Hours + c.edit_next(); // Days + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_down(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); +} + +#[test] +fn test_edit_down_hours_to_minutes() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_HOUR, + current_value: ONE_HOUR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + c.edit_next(); // Hours + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_down(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_down_minutes_to_seconds() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_MINUTE, + current_value: ONE_MINUTE, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); + c.edit_down(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + +#[test] +fn test_edit_next_ydddhhmmssd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on - should start at Minutes + c.toggle_edit(); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_hours_in_dhhmmss_format() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY + ONE_HOUR, + current_value: ONE_DAY + ONE_HOUR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // Should be in D HH:MM:SS format + assert_eq!(c.get_format(), Format::DHhMmSs); + + c.toggle_edit(); + c.edit_next(); // Move to Hours + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + + // Increment hours - should stay in Hours edit mode + c.edit_up(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + assert_eq!( + Duration::from(*c.get_current_value()), + ONE_DAY + 2 * ONE_HOUR + ); +} + +#[test] +fn test_edit_next_ydddhhmmss() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // toggle on - should start at Minutes + c.toggle_edit(); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_next_dhhmmssd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY, + current_value: ONE_DAY, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on - should start at Minutes (following existing pattern) + c.toggle_edit(); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + #[test] fn test_edit_next_hhmmssd() { let mut c = ClockState::::new(ClockStateArgs { @@ -78,6 +467,10 @@ fn test_edit_next_hhmmssd() { c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); @@ -100,6 +493,10 @@ fn test_edit_next_hhmmss() { c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); c.edit_next(); assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); @@ -159,6 +556,25 @@ fn test_edit_next_ssd() { assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); } +#[test] +fn test_edit_next_sd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_SECOND, + current_value: ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + #[test] fn test_edit_next_ss() { let mut c = ClockState::::new(ClockStateArgs { @@ -172,10 +588,103 @@ fn test_edit_next_ss() { // toggle on c.toggle_edit(); c.edit_next(); - println!("mode -> {:?}", c.get_mode()); assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); } +#[test] +fn test_edit_next_s() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_SECOND, + current_value: ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // toggle on + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_next(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + +#[test] +fn test_edit_prev_ydddhhmmssd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on - should start at Minutes + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_prev_ydddhhmmss() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_YEAR, + current_value: ONE_YEAR, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // toggle on - should start at Minutes + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Years, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + +#[test] +fn test_edit_prev_dhhmmssd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_DAY, + current_value: ONE_DAY, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on - should start at Minutes + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Days, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Hours, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Minutes, _))); +} + #[test] fn test_edit_prev_hhmmssd() { let mut c = ClockState::::new(ClockStateArgs { @@ -275,6 +784,25 @@ fn test_edit_prev_ssd() { assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); } +#[test] +fn test_edit_prev_sd() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_SECOND, + current_value: ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: true, + app_tx: None, + }); + + // toggle on + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Decis, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + #[test] fn test_edit_prev_ss() { let mut c = ClockState::::new(ClockStateArgs { @@ -292,6 +820,23 @@ fn test_edit_prev_ss() { assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); } +#[test] +fn test_edit_prev_s() { + let mut c = ClockState::::new(ClockStateArgs { + initial_value: ONE_SECOND, + current_value: ONE_SECOND, + tick_value: ONE_DECI_SECOND, + with_decis: false, + app_tx: None, + }); + + // toggle on + c.toggle_edit(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); + c.edit_prev(); + assert!(matches!(c.get_mode(), Mode::Editable(Time::Seconds, _))); +} + #[test] fn test_edit_up_ss() { let mut c = ClockState::::new(ClockStateArgs {