Files
breeze/tests/break_engine_behavior.zi
T

572 lines
22 KiB
Ziran

// Workrave-style break engine, driven tick by tick through the pure BreakTick
// value function: activity-based timers, natural breaks, the prompt loop,
// skip and postpone, micro to rest promotion, the daily limit, operation
// modes, and reading mode.
#import "byte_text_linux"
#import "geometry"
#import, file "../src/breaks/break_types.zi";
#import, file "../src/breaks/break_rules.zi";
#import, file "../src/breaks/break_reminder_layout.zi";
#import, file "../src/breaks/break_activity.zi";
c :: #system_library "c";
write_out :: (descriptor: s32, data: *void, count: usize) -> s64 #foreign c "write";
failures: s32;
newline: [1]u8 = .[10];
expect :: (condition: bool, message: string) {
if condition { return }
failures += 1
copy: string = message
descriptor: *TextDescriptor = cast(*TextDescriptor)(*copy)
unused write_out(2, cast(*void)descriptor.data, descriptor.length)
unused write_out(2, cast(*void)*newline[0], cast(usize)1)
}
// The scenario driver over the value functions.
break_engine_init :: (e: *BreakEngine) { e.* = BreakInit() }
break_engine_tick :: (e: *BreakEngine, active: s32) { e.* = BreakTick(e.*, active) }
break_engine_skip :: (e: *BreakEngine, t: s32) { e.* = BreakSkip(e.*, t) }
break_engine_postpone :: (e: *BreakEngine, t: s32) { e.* = BreakPostpone(e.*, t) }
break_engine_force_break :: (e: *BreakEngine, t: s32) { e.* = BreakForce(e.*, t) }
break_engine_set_mode :: (e: *BreakEngine, mode: s32, duration_s: s32) {
e.* = BreakSetMode(e.*, mode, duration_s)
}
break_engine_set_day :: (e: *BreakEngine, day_key: s32) -> s32 {
result: BreakDayChange = BreakSetDay(e.*, day_key)
e.* = result.engine
return result.changed
}
break_engine_take_event :: (e: *BreakEngine, break_out: *s32) -> s32 {
result: BreakEventTake = BreakTakeEvent(e.*)
e.* = result.engine
if break_out != null { break_out.* = result.break_type }
return result.event
}
break_engine_active_break :: (e: *BreakEngine) -> s32 { return BreakActive(e.*) }
break_timer_next_due_s :: (e: *BreakEngine, t: s32) -> s32 { return BreakNextDueSeconds(e.*, t) }
break_engine_note_idle :: (e: *BreakEngine, idle_s: s32) -> s32 {
result: BreakIdleSample = BreakNoteIdle(e.*, idle_s)
e.* = result.engine
return result.took
}
// Advances one full second and returns the event raised during it.
step_second :: (e: *BreakEngine, active: s32, break_out: *s32) -> s32 {
i: s32 = 0
while i < 60 {
break_engine_tick(e, active)
i += 1
}
return break_engine_take_event(e, break_out)
}
run_seconds :: (e: *BreakEngine, seconds: s32, active: s32) {
brk: s32 = 0
i: s32 = 0
while i < seconds {
unused step_second(e, active, *brk)
i += 1
}
}
test_defaults_match_workrave :: () {
e: BreakEngine
break_engine_init(*e)
expect(e.timers[BREAK_MICRO].limit_s == 180 &&
e.timers[BREAK_MICRO].duration_s == 30 &&
e.timers[BREAK_MICRO].postpone_s == 150,
"micro defaults: 3 min / 30 s / 150 s")
expect(e.timers[BREAK_REST].limit_s == 2700 &&
e.timers[BREAK_REST].duration_s == 600 &&
e.timers[BREAK_REST].postpone_s == 180,
"rest defaults: 45 min / 10 min / 180 s")
expect(e.timers[BREAK_DAILY].limit_s == 14400 &&
e.timers[BREAK_DAILY].duration_s == 0 &&
e.timers[BREAK_DAILY].postpone_s == 1200,
"daily defaults: 4 h / no duration / 1200 s")
expect(e.timers[BREAK_MICRO].max_prompts == 0 &&
e.timers[BREAK_REST].max_prompts == 3 &&
e.timers[BREAK_DAILY].max_prompts == 3,
"micro opens directly; rest/daily max prompts default to 3")
expect(e.mode == BreakModeNormal, "mode defaults to normal")
expect(break_timer_next_due_s(*e, BREAK_MICRO) == 180,
"fresh micro timer due in 180 s")
}
test_active_time_prompts_at_limit :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 60
e.timers[BREAK_MICRO].max_prompts = 3
run_seconds(*e, 59, 1)
expect(e.timers[BREAK_MICRO].state == BreakStateRunning &&
e.timers[BREAK_MICRO].active_s == 59,
"no prompt before the limit")
ev = step_second(*e, 1, *brk)
expect(ev == BreakEventPrompt && brk == BREAK_MICRO,
"reaching the limit raises a prompt")
expect(e.timers[BREAK_MICRO].state == BreakStatePrompting,
"timer enters prompting")
expect(e.stats[BREAK_MICRO].prompts == 1, "prompt counted once")
}
test_input_resets_idle_and_natural_take :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
run_seconds(*e, 170, 1)
expect(e.timers[BREAK_MICRO].active_s == 170, "active time accrues")
run_seconds(*e, 29, 0)
expect(e.timers[BREAK_MICRO].idle_s == 29 &&
e.timers[BREAK_MICRO].state == BreakStateRunning,
"idle below duration does not take the break")
run_seconds(*e, 1, 1)
expect(e.timers[BREAK_MICRO].idle_s == 0,
"any input resets the idle counter")
run_seconds(*e, 29, 0)
ev = step_second(*e, 0, *brk)
expect(ev == BreakEventNatural && brk == BREAK_MICRO,
"idle for the duration takes the break naturally")
expect(e.stats[BREAK_MICRO].natural == 1, "natural break counted")
expect(e.timers[BREAK_MICRO].active_s == 0 &&
e.timers[BREAK_MICRO].state == BreakStateRunning,
"natural take resets the timer")
}
test_ignored_prompts_escalate_to_break :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].max_prompts = 3
ev = 0
s: s32 = 0
while s < 240 {
ev = step_second(*e, 1, *brk)
s += 1
}
expect(ev == BreakEventStart && brk == BREAK_MICRO,
"three ignored prompts force the break")
expect(e.timers[BREAK_MICRO].state == BreakStateBreaking,
"timer enters breaking after max prompts")
expect(e.stats[BREAK_MICRO].prompts == 1 &&
e.stats[BREAK_MICRO].repeated_prompts == 2,
"one prompt plus two repeats before forcing")
expect(e.stats[BREAK_MICRO].overdue_s >= 60,
"ignored time counts as overdue")
}
test_unignorable_break_forces_immediately :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].max_prompts = 0
run_seconds(*e, 179, 1)
ev = step_second(*e, 1, *brk)
expect(ev == BreakEventStart && e.timers[BREAK_MICRO].state == BreakStateBreaking,
"max_prompts 0 skips prompting entirely")
}
test_skip_and_postpone :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10
e.timers[BREAK_MICRO].max_prompts = 0
run_seconds(*e, 10, 1)
expect(e.timers[BREAK_MICRO].state == BreakStateBreaking, "break started")
break_engine_skip(*e, BREAK_MICRO)
ev = break_engine_take_event(*e, *brk)
expect(ev == BreakEventSkipped &&
e.timers[BREAK_MICRO].state == BreakStateRunning &&
e.timers[BREAK_MICRO].active_s == 0,
"skip resets the timer as if taken")
expect(e.stats[BREAK_MICRO].skipped == 1, "skip counted")
run_seconds(*e, 10, 1)
expect(e.timers[BREAK_MICRO].state == BreakStateBreaking, "break re-started")
break_engine_postpone(*e, BREAK_MICRO)
ev = break_engine_take_event(*e, *brk)
expect(ev == BreakEventPostponed &&
e.timers[BREAK_MICRO].state == BreakStateSnoozed &&
e.timers[BREAK_MICRO].snooze_s == 150,
"postpone snoozes for the postpone time")
expect(e.stats[BREAK_MICRO].postponed == 1, "postpone counted")
run_seconds(*e, 149, 0)
expect(e.timers[BREAK_MICRO].state == BreakStateSnoozed, "still snoozing")
ev = step_second(*e, 0, *brk)
expect(ev == BreakEventStart &&
e.timers[BREAK_MICRO].state == BreakStateBreaking,
"snooze expiry re-arms an un-ignorable break")
}
test_break_freezes_on_activity :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10
e.timers[BREAK_MICRO].max_prompts = 0
run_seconds(*e, 10, 1)
run_seconds(*e, 29, 1)
expect(e.timers[BREAK_MICRO].state == BreakStateBreaking &&
e.timers[BREAK_MICRO].idle_s == 0,
"activity during the break freezes progress")
run_seconds(*e, 29, 0)
ev = step_second(*e, 0, *brk)
expect(ev == BreakEventTaken && e.stats[BREAK_MICRO].taken == 1,
"idle for the duration completes the break")
expect(e.timers[BREAK_MICRO].active_s == 0 &&
e.timers[BREAK_MICRO].state == BreakStateRunning,
"taken break resets the timer")
}
test_micro_promotes_to_rest :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 60
e.timers[BREAK_MICRO].max_prompts = 3
e.timers[BREAK_REST].limit_s = 80
run_seconds(*e, 59, 1)
ev = step_second(*e, 1, *brk)
expect(ev == BreakEventStart && brk == BREAK_REST,
"rest break fires in place of a due micro break")
expect(e.timers[BREAK_REST].state == BreakStateBreaking,
"rest timer owns the window")
expect(e.timers[BREAK_MICRO].active_s == 0 &&
e.timers[BREAK_MICRO].state == BreakStateRunning,
"micro timer credited and reset")
expect(e.timers[BREAK_REST].lock_buttons_s == 0,
"ignorable micro leaves rest buttons unlocked")
// An un-ignorable micro promotion locks the rest window buttons.
break_engine_init(*e)
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 60
e.timers[BREAK_MICRO].max_prompts = 0
e.timers[BREAK_REST].limit_s = 80
run_seconds(*e, 60, 1)
expect(e.timers[BREAK_REST].state == BreakStateBreaking &&
e.timers[BREAK_REST].lock_buttons_s == e.timers[BREAK_REST].duration_s,
"un-ignorable micro locks the rest buttons")
}
test_daily_limit_skip_and_day_reset :: () {
e: BreakEngine
break_engine_init(*e)
e.timers[BREAK_MICRO].enabled = 0
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].limit_s = 60
run_seconds(*e, 60, 1)
expect(e.timers[BREAK_DAILY].state == BreakStatePrompting,
"daily limit prompts when reached")
run_seconds(*e, 60, 1)
expect(e.timers[BREAK_DAILY].state == BreakStateBreaking,
"daily limit breaks after ignored prompts")
break_engine_skip(*e, BREAK_DAILY)
expect(e.timers[BREAK_DAILY].skipped_today == 1 &&
e.timers[BREAK_DAILY].state == BreakStateRunning,
"skipping disables the daily limit for today")
run_seconds(*e, 1000, 1)
expect(e.timers[BREAK_DAILY].state == BreakStateRunning,
"skipped daily limit stays silent")
expect(break_engine_set_day(*e, 1) == 1, "day change reported")
expect(e.timers[BREAK_DAILY].skipped_today == 0 &&
e.timers[BREAK_DAILY].active_s == 0,
"day reset restores the daily limit")
expect(break_engine_set_day(*e, 1) == 0, "same day is a no-op")
run_seconds(*e, 60, 1)
expect(e.timers[BREAK_DAILY].state == BreakStatePrompting,
"daily limit runs again after the day reset")
}
test_quiet_suspended_and_timed_modes :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 60
e.timers[BREAK_MICRO].max_prompts = 3
break_engine_set_mode(*e, BreakModeQuiet, 0)
run_seconds(*e, 70, 1)
expect(e.timers[BREAK_MICRO].state == BreakStateRunning,
"quiet mode monitors but never prompts")
expect(e.stats[BREAK_MICRO].overdue_s == 11,
"quiet mode accrues overdue time")
break_engine_set_mode(*e, BreakModeNormal, 0)
ev = step_second(*e, 1, *brk)
expect(ev == BreakEventPrompt, "overdue break fires after quiet ends")
{
active_before: s32 = e.timers[BREAK_MICRO].active_s
usage_before: s32 = e.usage_today_s
break_engine_set_mode(*e, BreakModeSuspended, 0)
run_seconds(*e, 500, 1)
expect(e.timers[BREAK_MICRO].active_s == active_before &&
e.usage_today_s == usage_before,
"suspended mode stops monitoring entirely")
}
break_engine_set_mode(*e, BreakModeQuiet, 2)
unused step_second(*e, 1, *brk)
expect(e.mode == BreakModeQuiet, "timed mode still active")
ev = step_second(*e, 1, *brk)
expect(ev == BreakEventModeExpired && e.mode == BreakModeNormal,
"timed mode expires back to normal")
}
test_reading_mode :: () {
e: BreakEngine
brk: s32 = -1
ev: s32 = 0
break_engine_init(*e)
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10000
e.timers[BREAK_REST].limit_s = 10
e.timers[BREAK_REST].max_prompts = 0
e.reading_mode = 1
unused step_second(*e, 1, *brk) // first input latches reading
run_seconds(*e, 9, 0); // idle still counts as active
expect(e.timers[BREAK_REST].active_s == 10 && e.usage_today_s == 10,
"reading mode keeps timers running without input")
expect(e.timers[BREAK_REST].state == BreakStateBreaking,
"rest break started while reading")
expect(e.reading_active == 0, "reading latch cleared at rest break")
run_seconds(*e, 599, 0)
ev = step_second(*e, 0, *brk)
expect(ev == BreakEventTaken && e.stats[BREAK_REST].taken == 1,
"rest break completes once the user actually rests")
expect(e.usage_today_s == 10, "idle rest time is not usage")
}
test_micro_counts_toward_daily_limit :: () {
e: BreakEngine
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10
e.timers[BREAK_MICRO].duration_s = 5
e.timers[BREAK_MICRO].max_prompts = 3
e.timers[BREAK_DAILY].limit_s = 20
e.micro_counts_as_activity = 1
run_seconds(*e, 10, 1); // micro due -> prompting
run_seconds(*e, 5, 0); // idle -> natural take
expect(e.stats[BREAK_MICRO].natural == 1, "micro taken naturally")
expect(e.timers[BREAK_DAILY].active_s == 15,
"taken micro break counts toward the daily limit")
}
test_force_break_and_next_due :: () {
e: BreakEngine
brk: s32 = -1
break_engine_init(*e)
run_seconds(*e, 60, 1)
expect(break_timer_next_due_s(*e, BREAK_MICRO) == 120 &&
break_timer_next_due_s(*e, BREAK_REST) == 2640,
"next due reports active seconds remaining")
break_engine_force_break(*e, BREAK_REST)
expect(break_engine_take_event(*e, *brk) == BreakEventStart &&
brk == BREAK_REST &&
e.timers[BREAK_REST].state == BreakStateBreaking &&
e.timers[BREAK_REST].active_s == e.timers[BREAK_REST].limit_s,
"forced break opens the window immediately")
expect(break_engine_active_break(*e) == BREAK_REST,
"active break reports the breaking timer")
expect(break_timer_next_due_s(*e, BREAK_REST) == 0,
"breaking timer reports due now")
}
test_natural_take_latches_until_activity :: () {
e: BreakEngine
break_engine_init(*e)
e.timers[BREAK_REST].enabled = 0
e.timers[BREAK_DAILY].enabled = 0
// Three break-durations of continuous idle: exactly one natural take.
run_seconds(*e, 90, 0)
expect(e.stats[BREAK_MICRO].natural == 1 &&
e.timers[BREAK_MICRO].active_s == 0,
"one continuous idle period takes the break once")
run_seconds(*e, 5, 1); // input re-arms the natural break
run_seconds(*e, 30, 0); // a fresh idle period takes again
expect(e.stats[BREAK_MICRO].natural == 2,
"input re-arms the natural break")
}
test_rest_completion_resets_micro :: () {
e: BreakEngine
break_engine_init(*e)
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10000; // keep micro dormant
e.timers[BREAK_MICRO].duration_s = 600; // longer than the rest break
e.timers[BREAK_REST].limit_s = 10
e.timers[BREAK_REST].duration_s = 10
e.timers[BREAK_REST].max_prompts = 0
run_seconds(*e, 10, 1)
expect(e.timers[BREAK_REST].state == BreakStateBreaking,
"rest break window opens at its limit")
expect(e.timers[BREAK_MICRO].active_s == 10,
"micro accrues while the user works")
run_seconds(*e, 12, 0); // idle through the 10 s rest break
expect(e.timers[BREAK_REST].state == BreakStateRunning &&
e.stats[BREAK_REST].taken == 1,
"rest break completes on idle")
expect(e.timers[BREAK_MICRO].active_s == 0,
"completing a rest break resets the micro timer")
// micro idle_s re-accrues from zero after the reset while the user is * still away; that is expected, not a double take (the latch holds).
}
test_note_idle_resets_after_long_absence :: () {
e: BreakEngine
brk: s32 = -1
break_engine_init(*e)
e.timers[BREAK_DAILY].enabled = 0
e.timers[BREAK_MICRO].limit_s = 10000
e.timers[BREAK_REST].limit_s = 10000
run_seconds(*e, 20, 1)
expect(e.timers[BREAK_REST].active_s == 20 &&
e.timers[BREAK_MICRO].active_s == 20,
"activity accrues before the absence")
// The OS idle counter reports a 20 minute absence (beyond the catch-up * cap of the per-second ticks): both timers reset naturally, once.
expect(break_engine_note_idle(*e, 1200) == 1,
"long observed absence takes the breaks")
expect(e.stats[BREAK_MICRO].natural == 1 &&
e.stats[BREAK_REST].natural == 1,
"micro and rest both reset naturally")
expect(e.timers[BREAK_MICRO].active_s == 0 &&
e.timers[BREAK_REST].active_s == 0,
"timers reset after the natural break")
unused break_engine_take_event(*e, *brk)
expect(break_engine_note_idle(*e, 3000) == 0,
"the same idle period does not take twice")
run_seconds(*e, 1, 1); // input re-arms the latch
expect(break_engine_note_idle(*e, 1200) == 1,
"after input a new absence takes again")
unused break_engine_take_event(*e, *brk)
}
duration_is :: (seconds: s32, wanted: string) -> bool {
text: BreakDurationText = BreakFormatDuration(seconds)
return TextFromBytes(text.bytes[0:text.count]) == wanted
}
test_format_duration_formats_hours :: () {
expect(duration_is(59, "0:59"), "below an hour stays M:SS")
expect(duration_is(3599, "59:59"), "just under an hour stays M:SS")
expect(duration_is(3600, "1:00:00"), "hour boundary switches to H:MM:SS")
expect(duration_is(14400, "4:00:00"), "daily limit renders as H:MM:SS")
expect(duration_is(2147483647, "596523:14:07"),
"maximum signed seconds fits the duration buffer")
expect(duration_is(-5, "0:00"), "negative clamps to zero")
}
test_break_reminder_layout_separates_long_text :: () {
bounds: Rectangle = Rectangle.{10.0, 20.0, 180.0, 0.0}
layout := BreakReminderLayout(bounds, 96, 4.0)
separated := layout.bar.y >= layout.text.y + layout.text.height
inside := layout.text.x >= bounds.x && layout.bar.x >= bounds.x &&
layout.text.width >= 0.0 && layout.bar.width >= 0.0
complete := layout.height == 96 + 16 + 12
expect(separated && inside && complete,
"long reminder text keeps the progress bar on its own row")
}
test_typing_is_activity :: () {
e := BreakInit()
input: BreakActivityInput
input.idle_ms = -1
input.focused = true
last_input: s32 = -10000
// Longer than both rest durations, with keys and no pointer movement.
for frame: 0..60 * 700 - 1 {
input.frame = cast(s32)frame
input.key_pressed = frame % 15 == 0
sample := BreakSampleActivity(input, last_input)
last_input = sample.last_input_frame
expect(sample.active == 1, "continuous keys count as activity")
e = BreakTick(e, sample.active)
}
for timer: 0..1 {
expect(e.timers[timer].idle_s == 0,
"typing does not fill either rest meter")
expect(e.stats[timer].natural == 0,
"typing never completes a natural break")
}
input.key_pressed = false
input.frame += BreakFallbackInputTicks
expect(BreakSampleActivity(input, last_input).active == 0,
"rest resumes after typing stops")
input.pointer_active = true
expect(BreakSampleActivity(input, last_input).active == 1,
"pointer and keyboard activity use the same decision")
input.pointer_active = false
input.focused = false
input.idle_ms = 20
expect(BreakSampleActivity(input, last_input).active == 1,
"session-wide typing counts while Breeze is unfocused")
input.idle_ms = BreakActivityThresholdMs
expect(BreakSampleActivity(input, last_input).active == 0,
"session idle threshold starts rest")
}
#program_export
Check :: () -> s32 {
test_typing_is_activity()
test_defaults_match_workrave()
test_active_time_prompts_at_limit()
test_input_resets_idle_and_natural_take()
test_ignored_prompts_escalate_to_break()
test_unignorable_break_forces_immediately()
test_skip_and_postpone()
test_break_freezes_on_activity()
test_micro_promotes_to_rest()
test_daily_limit_skip_and_day_reset()
test_quiet_suspended_and_timed_modes()
test_reading_mode()
test_micro_counts_toward_daily_limit()
test_force_break_and_next_due()
test_natural_take_latches_until_activity()
test_rest_completion_resets_micro()
test_note_idle_resets_after_long_absence()
test_format_duration_formats_hours()
test_break_reminder_layout_separates_long_text()
return failures
}