From 2b0e1eaaa706d227e547b9f4ce947da33f4b7ed1 Mon Sep 17 00:00:00 2001 From: Waozi Date: Thu, 19 Nov 2026 00:27:33 -0300 Subject: [PATCH] Fix PC break idle detection and automatic resets --- src/app/application_update.zi | 4 +- src/breaks/app_breaks.zi | 54 ++++++++------------------- src/breaks/break_activity.zi | 58 ++++++++++++++++------------- src/breaks/break_rules.zi | 43 +++++++++++++++++----- src/platform/app_host.zi | 6 +++ tests/break_activity_x11.zi | 31 ++++++++++++---- tests/break_activity_x11_test.py | 63 +++++++++++++++++++++++--------- tests/break_activity_x11_test.sh | 7 ++-- tests/break_engine_behavior.zi | 50 ++++++++++++++++++++----- tests/break_engine_zi_test.sh | 2 +- 10 files changed, 204 insertions(+), 114 deletions(-) diff --git a/src/app/application_update.zi b/src/app/application_update.zi index 5fff0b3cf..fbf56e1a9 100644 --- a/src/app/application_update.zi +++ b/src/app/application_update.zi @@ -148,7 +148,9 @@ updateapp :: (app: *InnerBreeze) { } // Mini mode is only the practices: no break or reminder prompts. if !AppMiniMode() { - app_breaks_update(app) + #if !#defined(DESKTOP_HOST) { + app_breaks_update(app) + } if app_notifications_tick(app) { save_settings(app) } diff --git a/src/breaks/app_breaks.zi b/src/breaks/app_breaks.zi index 50628c3e5..be7d93882 100644 --- a/src/breaks/app_breaks.zi +++ b/src/breaks/app_breaks.zi @@ -217,11 +217,11 @@ break_persist_daily_state :: (app: *InnerBreeze) { } break_fallback_pointer_seen :: () -> bool { - wheel := cast(s32)(HostWheel().y * 1000.0f) - if wheel != 0 { - return true - } - return HostPointerMoved() + wheel := HostWheel() + primary := HostPointer() + secondary := HostSecondaryPointer() + return wheel.x != 0.0 || wheel.y != 0.0 || HostPointerMoved() || + primary.pressed || primary.released || secondary.pressed || secondary.released } break_fallback_key_seen :: () -> bool { @@ -528,8 +528,7 @@ app_breaks_note_lifecycle :: (app: *InnerBreeze, paused: bool) { if app.breaks_enabled != 0 && practice_active(app) == null { app_breaks_observe_absence(app, -1, 0) } else { - app.break_absence_clock.initialized = false - app.break_absence_clock.idle_seconds = 0.0 + app.break_absence_clock = .{} } app.break_lifecycle_paused = paused } @@ -545,15 +544,11 @@ app_breaks_update :: (app: *InnerBreeze) { // A running practice session is deliberate rest: freeze break // scheduling until it ends so no prompt pops over the session. The // elapsed-time base is dropped so no catch-up burst runs afterwards. - if practice_active(app) != null { + if app.breaks_enabled == 0 || practice_active(app) != null { app.break_last_update_time = 0.0f - app.break_absence_clock.initialized = false - app.break_absence_clock.idle_seconds = 0.0 - return - } - if app.breaks_enabled == 0 { - app.break_absence_clock.initialized = false - app.break_absence_clock.idle_seconds = 0.0 + app.break_tick_pending = 0.0f + app.break_fallback_last_input = 0 + app.break_absence_clock = .{} return } @@ -564,7 +559,7 @@ app_breaks_update :: (app: *InnerBreeze) { elapsed: float32 = 0.0f ticks: s32 = 0 - app.break_input_active = active + app.break_input_active = ifx active == 1 then 1 else 0 app_breaks_observe_absence(app, idle_ms, active) @@ -591,19 +586,6 @@ app_breaks_update :: (app: *InnerBreeze) { } app.break_tick_pending = pending - cast(float32)ticks - // The activity sample only says whether input happened within the last - // BreakActivityThresholdMs - it cannot vouch for a longer stall (occluded - // or hidden window, system suspend, a slow frame). Credit at most one - // second of the batch to the live sample; older catch-up ticks run as - // idle so time away from the machine never counts toward the next break. - active_ticks: s32 = 0 - if active != 0 { - active_ticks = BreakTicksPerSecond - if active_ticks > ticks { - active_ticks = ticks - } - } - day := break_day_key() if day > 0 { prior_day := app.breaks.day_key @@ -617,17 +599,11 @@ app_breaks_update :: (app: *InnerBreeze) { } } - { - i: s32 = 0 - while i < ticks { - - sample_active := ifx (i >= ticks - active_ticks) then (active) else (0) - app.breaks = BreakTick(app.breaks, sample_active) - app.break_stats_flush_s += 1 - - i += 1 - } + if app.breaks.reading_active == 0 && idle_ms >= 0 { + idle_ms -= app.break_absence_clock.reading_idle_ms } + app.breaks = BreakTickDesktop(app.breaks, ticks, active, idle_ms) + app.break_stats_flush_s += ticks if app.break_stats_flush_s >= BreakStatsFlushS { app.break_stats_flush_s = 0 storage_break_flush_day(*app.breaks) diff --git a/src/breaks/break_activity.zi b/src/breaks/break_activity.zi index 12644cbf6..54bdcab83 100644 --- a/src/breaks/break_activity.zi +++ b/src/breaks/break_activity.zi @@ -1,5 +1,6 @@ BreakActivityThresholdMs :: 1000 BreakFallbackInputTicks :: 90 +BreakActivityUnknown :: -1 BreakActivityInput :: struct { idle_ms: s64 @@ -19,7 +20,7 @@ BreakAbsenceClock :: struct { elapsed_seconds: float64 frame_seconds: float64 idle_seconds: float64 - ignore_os_idle: bool + reading_idle_ms: s64 } BreakAbsenceSample :: struct { @@ -28,34 +29,37 @@ BreakAbsenceSample :: struct { known_away: bool } -// Observe absence before consuming the returning input. A frame stall may -// contain a whole break, even when the wake-up key reset the OS idle counter. -// Keep fractional seconds so an unavailable OS counter also works at any FPS. +// The session counter proves awake idle time. The difference between the +// two clocks covers suspend even if returning input reset the session counter. BreakObserveAbsence :: (clock: BreakAbsenceClock, elapsed_seconds: float64, frame_seconds: float64, idle_ms: s64, active: s32, backgrounded: bool, reading: bool) -> BreakAbsenceSample { result: BreakAbsenceSample result.clock = clock - if reading { - result.clock.idle_seconds = 0.0 - result.clock.ignore_os_idle = true - } gap: float64 = 0.0 - if clock.initialized && elapsed_seconds >= clock.elapsed_seconds { + suspended: float64 = 0.0 + if clock.initialized && elapsed_seconds >= clock.elapsed_seconds && + frame_seconds >= clock.frame_seconds { gap = elapsed_seconds - clock.elapsed_seconds frame_gap := frame_seconds - clock.frame_seconds - result.known_away = gap > frame_gap + 2.0 + if gap > frame_gap + 2.0 { + suspended = gap - frame_gap + } } - result.known_away = result.known_away || backgrounded - observed := result.clock.idle_seconds - if active == 0 || backgrounded { - observed += gap - } else if gap > 2.0 { - observed += gap + result.known_away = suspended > 0.0 || backgrounded + observed := suspended + if active == 1 || (idle_ms >= 0 && idle_ms < clock.reading_idle_ms) { + result.clock.reading_idle_ms = 0 } - if idle_ms >= 0 && !result.clock.ignore_os_idle { - os_idle := cast(float64)idle_ms / 1000.0 - if gap <= 2.0 || os_idle > observed { + if backgrounded { + observed = clock.idle_seconds + gap + } else if reading && !result.known_away { + if idle_ms >= 0 { + result.clock.reading_idle_ms = idle_ms + } + } else if idle_ms >= result.clock.reading_idle_ms { + os_idle := cast(float64)(idle_ms - result.clock.reading_idle_ms) / 1000.0 + if os_idle > observed { observed = os_idle } } @@ -63,10 +67,7 @@ BreakObserveAbsence :: (clock: BreakAbsenceClock, elapsed_seconds: float64, observed = 2147483647.0 } result.idle_seconds = cast(s32)observed - result.clock.idle_seconds = ifx active != 0 && !backgrounded then 0.0 else observed - if active != 0 { - result.clock.ignore_os_idle = false - } + result.clock.idle_seconds = ifx backgrounded then observed else 0.0 result.clock.elapsed_seconds = elapsed_seconds result.clock.frame_seconds = frame_seconds result.clock.initialized = elapsed_seconds >= 0.0 @@ -83,12 +84,19 @@ BreakSampleActivity :: (input: BreakActivityInput, sample.active = ifx input.idle_ms < BreakActivityThresholdMs then 1 else 0 return sample } + sample.active = BreakActivityUnknown if !input.focused { + sample.last_input_frame = 0 return sample } + // Store frame + 1 so that zero means no observed local input at startup. + frame := input.frame + 1 if input.key_pressed || input.pointer_active { - sample.last_input_frame = input.frame + sample.last_input_frame = frame + } + if sample.last_input_frame > 0 && frame >= sample.last_input_frame && + frame - sample.last_input_frame < BreakFallbackInputTicks { + sample.active = 1 } - sample.active = ifx input.frame - sample.last_input_frame < BreakFallbackInputTicks then 1 else 0 return sample } diff --git a/src/breaks/break_rules.zi b/src/breaks/break_rules.zi index 3399f281a..0a4ca4465 100644 --- a/src/breaks/break_rules.zi +++ b/src/breaks/break_rules.zi @@ -296,12 +296,15 @@ BreakStep :: (engine: BreakEngine, break_type: s32, if break_type == BREAK_DAILY && engine.timers[break_type].skipped_today != 0 { return engine } + if is_active == BreakActivityUnknown && engine.timers[break_type].state != BreakStateBreaking { + engine.timers[break_type].idle_s = 0 + } if owner >= 0 && owner != break_type { - if is_active != 0 { + if is_active == 1 { engine.timers[break_type].idle_s = 0 engine.timers[break_type].idle_latched = 0 - } else if engine.timers[break_type].idle_latched == 0 && engine.timers[break_type].duration_s > 0 { + } else if is_active == 0 && engine.timers[break_type].idle_latched == 0 && engine.timers[break_type].duration_s > 0 { engine.timers[break_type].idle_s += 1 if engine.timers[break_type].idle_s >= engine.timers[break_type].duration_s { @@ -312,7 +315,7 @@ BreakStep :: (engine: BreakEngine, break_type: s32, } if engine.timers[break_type].state == BreakStateRunning { - if is_active != 0 { + if is_active == 1 { engine.timers[break_type].active_s += 1 engine.timers[break_type].idle_s = 0 engine.timers[break_type].idle_latched = 0 @@ -320,7 +323,7 @@ BreakStep :: (engine: BreakEngine, break_type: s32, engine.timers[break_type].limit_s { engine = BreakDue(engine, break_type) } - } else if engine.timers[break_type].idle_latched == 0 { + } else if is_active == 0 && engine.timers[break_type].idle_latched == 0 { engine.timers[break_type].idle_s += 1 if engine.timers[break_type].duration_s > 0 && engine.timers[break_type].idle_s >= engine.timers[break_type].duration_s { @@ -332,10 +335,10 @@ BreakStep :: (engine: BreakEngine, break_type: s32, if engine.timers[break_type].state == BreakStatePrompting { engine.stats[break_type].overdue_s += 1 - if is_active != 0 { + if is_active == 1 { engine.timers[break_type].idle_s = 0 engine.timers[break_type].idle_latched = 0 - } else if engine.timers[break_type].idle_latched == 0 { + } else if is_active == 0 && engine.timers[break_type].idle_latched == 0 { engine.timers[break_type].idle_s += 1 if engine.timers[break_type].duration_s > 0 && engine.timers[break_type].idle_s >= engine.timers[break_type].duration_s { @@ -415,13 +418,13 @@ BreakTick :: (engine: BreakEngine, active: s32) -> BreakEngine { reading: s32 = 0 if engine.reading_mode != 0 { - if active != 0 { + if active == 1 { engine.reading_active = 1 } reading = engine.reading_active } - is_active: s32 = 0 - if active != 0 || reading != 0 { + is_active := active + if active == 1 || (active == 0 && reading != 0) { is_active = 1 engine.usage_today_s += 1 } @@ -442,6 +445,28 @@ BreakTick :: (engine: BreakEngine, active: s32) -> BreakEngine { return engine } +BreakTickDesktop :: (engine: BreakEngine, ticks: s32, + active: s32, idle_ms: s64) -> BreakEngine { + // A sample only describes the end of a batch. Avoid filling the work or + // rest meters with an unsampled interval after a long render stall. + observed_ticks: s32 = 0 + if active == 1 { + observed_ticks = BreakTicksPerSecond + } else if active == 0 && idle_ms > BreakActivityThresholdMs { + // Limit milliseconds before multiplying, including for large OS counters. + idle_after_grace := idle_ms - BreakActivityThresholdMs + observed_ticks = ticks + if idle_after_grace < cast(s64)ticks * 1000 { + observed_ticks = cast(s32)(idle_after_grace * BreakTicksPerSecond / 1000) + } + } + for tick: 0..ticks - 1 { + sample := ifx tick >= ticks - observed_ticks then active else BreakActivityUnknown + engine = BreakTick(engine, sample) + } + return engine +} + #program_export BreakNoteIdle :: (engine: BreakEngine, idle_s: s32) -> BreakIdleSample { diff --git a/src/platform/app_host.zi b/src/platform/app_host.zi index 72ed3f52d..7c8c1c2e6 100644 --- a/src/platform/app_host.zi +++ b/src/platform/app_host.zi @@ -353,6 +353,12 @@ app_frame :: (argument: *void) { width := HostWindowWidth() height := HostWindowHeight() + #if #defined(DESKTOP_HOST) { + // The timer also runs when the current screen or drawing is blocked. + if !AppMiniMode() { + app_breaks_update(app) + } + } app_route_transition_advance(app, HostSeconds()) #if #defined(DESKTOP_HOST) { TextInputBeginFrame() diff --git a/tests/break_activity_x11.zi b/tests/break_activity_x11.zi index 151aa549b..07c3dd851 100644 --- a/tests/break_activity_x11.zi +++ b/tests/break_activity_x11.zi @@ -2,31 +2,46 @@ #import, file "../src/breaks/break_types.zi"; #import, file "../src/breaks/break_activity.zi"; #import, file "../src/breaks/break_rules.zi"; +#import, file "../src/platform/break_clock.zi"; engine: BreakEngine; -initialized: bool; +clock: BreakAbsenceClock; +pending_ticks: float64; active: s32; #program_export Sample :: () -> s64 { - if !initialized { - initialized = true + if !clock.initialized { engine = BreakInit() + // Keep a real idle integration test fast without touching app defaults. + engine.timers[BREAK_MICRO].duration_s = 4 + engine.timers[BREAK_REST].duration_s = 6 } input: BreakActivityInput input.idle_ms = IdleMilliseconds() // This host has no focused app window and receives no local input events. - sample := BreakSampleActivity(input, -10000) + sample := BreakSampleActivity(input, 0) active = sample.active - for tick: 0..BreakTicksPerSecond - 1 { - engine = BreakTick(engine, active) + now := BreakElapsedSeconds() + if clock.initialized { + pending_ticks += (now - clock.elapsed_seconds) * cast(float64)BreakTicksPerSecond } + observed := BreakObserveAbsence(clock, now, now, input.idle_ms, active, false, false) + clock = observed.clock + engine = BreakNoteAbsence(engine, observed).engine + ticks := cast(s32)pending_ticks + pending_ticks -= cast(float64)ticks + engine = BreakTickDesktop(engine, ticks, active, input.idle_ms) return input.idle_ms } #program_export Activity :: () -> s32 { return active } #program_export -MicroIdle :: () -> s32 { return engine.timers[BREAK_MICRO].idle_s } +MicroWork :: () -> s32 { return engine.timers[BREAK_MICRO].active_s } #program_export -RestIdle :: () -> s32 { return engine.timers[BREAK_REST].idle_s } +RestWork :: () -> s32 { return engine.timers[BREAK_REST].active_s } +#program_export +MicroNatural :: () -> s32 { return engine.stats[BREAK_MICRO].natural } +#program_export +RestNatural :: () -> s32 { return engine.stats[BREAK_REST].natural } diff --git a/tests/break_activity_x11_test.py b/tests/break_activity_x11_test.py index f16f9a697..54d8cd895 100644 --- a/tests/break_activity_x11_test.py +++ b/tests/break_activity_x11_test.py @@ -26,32 +26,59 @@ def main(): probe.stdin.flush() assert select.select([probe.stdout], [], [], 5)[0], "probe timed out" values = tuple(map(int, probe.stdout.readline().split())) - assert len(values) == 4 and values[0] >= 0, values + assert len(values) == 6 and values[0] >= 0, values return values + def wait_for(predicate, timeout): + deadline = time.monotonic() + timeout + while True: + values = sample() + if predicate(values): + return values + assert time.monotonic() < deadline, values + time.sleep(0.1) + + def start_typing(): + return subprocess.Popen(["xdotool", "type", "--delay", "45", + "continuous keyboard activity " * 3]) + try: window = subprocess.check_output( ["xdotool", "search", "--sync", "--onlyvisible", "--name", title], text=True, timeout=10).splitlines()[0] subprocess.run(["xdotool", "windowfocus", "--sync", window], check=True) - time.sleep(1.6) - idle = sample() - assert idle[1] == 0 and idle[2] > 0 and idle[3] > 0, idle - typing = subprocess.Popen(["xdotool", "type", "--delay", "35", - "continuous keyboard activity " * 6]) - # Allow the shared OS sampler's 500 ms cache to refresh. - time.sleep(0.65) - samples = 0 + subprocess.run(["xdotool", "key", "space"], check=True) + typing = start_typing() + working = wait_for(lambda values: values[1] == 1 and values[2] >= 2, 5) + assert working[2] == working[3] and working[4:] == (0, 0), working while typing.poll() is None: - values = sample() - assert values[1:] == (1, 0, 0), values - samples += 1 - time.sleep(0.15) - assert typing.wait() == 0 and samples >= 15, samples - time.sleep(1.6) - stopped = sample() - assert stopped[1] == 0 and stopped[2] > 0 and stopped[3] > 0, stopped - print(f"Private Xvfb typing: {samples} active samples; both rest meters stayed at 0; idle resumed after typing stopped") + time.sleep(0.1) + sample() + assert typing.wait() == 0 + + short = wait_for(lambda values: values[0] >= 1500, 3) + assert short[0] < 4000 and short[1] == 0, short + assert short[2] >= working[2] and short[2] == short[3] and short[4:] == (0, 0), short + typing = start_typing() + returned = wait_for(lambda values: values[1] == 1 and values[2] > short[2], 4) + assert returned[2] == returned[3] and returned[4:] == (0, 0), returned + while typing.poll() is None: + time.sleep(0.1) + sample() + assert typing.wait() == 0 + + micro = wait_for(lambda values: values[4] == 1, 7) + assert micro[0] >= 4000 and micro[1] == 0, micro + assert micro[2] == 0 and micro[3] >= returned[3] and micro[5] == 0, micro + rest = wait_for(lambda values: values[5] == 1, 4) + assert rest[0] >= 6000 and rest[1:] == (0, 0, 0, 1, 1), rest + continued = wait_for(lambda values: values[0] >= 7000, 3) + assert continued[1:] == rest[1:], continued + + typing = start_typing() + restarted = wait_for(lambda values: values[1] == 1 and values[2] >= 1, 5) + assert restarted[2] == restarted[3] and restarted[4:] == (1, 1), restarted + print("Private Xvfb: typing elsewhere accrued work, short idle preserved it, each full rest reset once, and typing resumed work") finally: for process in (typing, probe, other): if process is not None and process.poll() is None: diff --git a/tests/break_activity_x11_test.sh b/tests/break_activity_x11_test.sh index 0db06a8d5..1061f5c51 100644 --- a/tests/break_activity_x11_test.sh +++ b/tests/break_activity_x11_test.sh @@ -15,17 +15,18 @@ int main(void) { while (getchar() != EOF) { long long idle = Sample(); - printf("%lld %d %d %d\n", idle, Activity(), MicroIdle(), RestIdle()); + printf("%lld %d %d %d %d %d\n", idle, Activity(), MicroWork(), + RestWork(), MicroNatural(), RestNatural()); fflush(stdout); } return 0; } C "${CC:-cc}" -std=c11 -D_DEFAULT_SOURCE -I"$root/build/packages/ziran/include" \ - -I"$work/c" "$work/c"/*.c -ldl -o "$work/test" + -I"$work/c" "$work/c"/*.c -ldl -lm -o "$work/test" # Scrub the owner's session before creating a new private display and auth file. env -u DISPLAY -u WAYLAND_DISPLAY -u XAUTHORITY -u DBUS_SESSION_BUS_ADDRESS \ - -u SESSION_MANAGER -u GDK_DISPLAY YUE_DESKTOP_RECOVERY=0 \ + -u SESSION_MANAGER -u GDK_DISPLAY HARMONY_DESKTOP_RECOVERY=0 YUE_DESKTOP_RECOVERY=0 \ TMPDIR="$work/runtime" xvfb-run -a -s '-screen 0 800x600x24 -nolisten tcp' \ env XDG_SESSION_TYPE=x11 DBUS_SESSION_BUS_ADDRESS=invalid: \ python3 "$root/tests/break_activity_x11_test.py" "$work/test" diff --git a/tests/break_engine_behavior.zi b/tests/break_engine_behavior.zi index 4be5d9b6b..0ba65c4ad 100644 --- a/tests/break_engine_behavior.zi +++ b/tests/break_engine_behavior.zi @@ -514,7 +514,9 @@ test_typing_is_activity :: () { input: BreakActivityInput input.idle_ms = -1 input.focused = true - last_input: s32 = -10000 + last_input: s32 = 0 + expect(BreakSampleActivity(input, last_input).active == BreakActivityUnknown, + "opening a focused window without input proves neither work nor rest") // Longer than both rest durations, with keys and no pointer movement. for frame: 0..60 * 700 - 1 { input.frame = cast(s32)frame @@ -532,8 +534,8 @@ test_typing_is_activity :: () { } input.key_pressed = false input.frame += BreakFallbackInputTicks - expect(BreakSampleActivity(input, last_input).active == 0, - "rest resumes after typing stops") + expect(BreakSampleActivity(input, last_input).active == BreakActivityUnknown, + "silence in one app is unknown when the session idle source is missing") input.pointer_active = true expect(BreakSampleActivity(input, last_input).active == 1, "pointer and keyboard activity use the same decision") @@ -547,14 +549,36 @@ test_typing_is_activity :: () { "session idle threshold starts rest") } +test_desktop_tick_batch_needs_input_evidence :: () { + e := BreakInit() + e.timers[BREAK_MICRO].active_s = 20 + e.timers[BREAK_REST].active_s = 20 + e.timers[BREAK_MICRO].idle_s = e.timers[BREAK_MICRO].duration_s - 1 + // A stalled app cannot know what happened while the user was elsewhere. + e = BreakTickDesktop(e, 300 * BreakTicksPerSecond, BreakActivityUnknown, -1) + expect(e.timers[BREAK_MICRO].active_s == 20 && e.timers[BREAK_MICRO].idle_s == 0 && + e.stats[BREAK_MICRO].natural == 0 && e.usage_today_s == 0, + "unavailable session idle adds neither work nor rest") + e = BreakTickDesktop(e, 300 * BreakTicksPerSecond, 0, 1900) + expect(e.timers[BREAK_MICRO].active_s == 20 && e.stats[BREAK_MICRO].natural == 0, + "a recent short idle reading cannot turn an awake stall into a break") + e = BreakTickDesktop(e, 300 * BreakTicksPerSecond, 1, 10) + expect(e.timers[BREAK_MICRO].active_s == 21 && e.timers[BREAK_REST].active_s == 21 && + e.stats[BREAK_MICRO].natural == 0 && e.usage_today_s == 1, + "returning input resumes one second of work without false catch-up rest") +} + test_absence_clock_credits_lock_suspend_and_background :: () { clock: BreakAbsenceClock first := BreakObserveAbsence(clock, 100.0, 10.0, -1, 1, false, false) - locked := BreakObserveAbsence(first.clock, 700.0, 610.0, 0, 1, false, false) + busy := BreakObserveAbsence(first.clock, 700.0, 610.0, 0, 1, false, false) + expect(busy.idle_seconds == 0, + "a long awake render stall with recent PC input cannot prove rest") + locked := BreakObserveAbsence(first.clock, 700.0, 610.0, 600000, 0, false, false) expect(locked.idle_seconds == 600, - "returning input does not erase a ten minute locked-window gap") - expect(locked.clock.idle_seconds == 0.0, - "returning input starts a new absence") + "a ten minute session idle reading proves rest across a render stall") + returned := BreakObserveAbsence(locked.clock, 701.0, 611.0, 0, 1, false, false) + expect(returned.idle_seconds == 0, "returning input ends the absence") engine := BreakInit() engine.timers[BREAK_MICRO].active_s = 120 engine.timers[BREAK_REST].active_s = 2400 @@ -563,6 +587,11 @@ test_absence_clock_credits_lock_suspend_and_background :: () { taken.engine.timers[BREAK_MICRO].active_s == 0, "a full absence resets both timers beyond the catch-up cap") + briefly_suspended := BreakObserveAbsence(first.clock, 700.0, 590.0, 0, 1, false, false) + expect(briefly_suspended.known_away && briefly_suspended.idle_seconds == 20 && + BreakNoteAbsence(engine, briefly_suspended).took == 0, + "only the suspended part of a long frame gap counts as known rest") + suspended := BreakObserveAbsence(first.clock, 700.0, 10.0, 0, 1, false, true) engine.reading_mode = 1 engine.reading_active = 1 @@ -586,10 +615,10 @@ test_absence_clock_credits_lock_suspend_and_background :: () { now := 100.0 + cast(float64)half_second / 2.0 fallback = BreakObserveAbsence(fallback.clock, now, now - 90.0, -1, 0, false, false) } - expect(fallback.idle_seconds == 600, - "fractional frame intervals accumulate without an OS idle service") + expect(fallback.idle_seconds == 0, + "missing OS input evidence cannot complete a rest") backward := BreakObserveAbsence(fallback.clock, 1.0, 1.0, -1, 1, false, false) - expect(backward.idle_seconds == 600 && backward.clock.idle_seconds == 0.0, + expect(backward.idle_seconds == 0 && backward.clock.idle_seconds == 0.0, "a clock reset neither invents time nor prevents the next absence") long_idle := BreakObserveAbsence(first.clock, 101.0, 11.0, 3000000000, 0, false, false) expect(long_idle.idle_seconds == 3000000, @@ -632,6 +661,7 @@ test_idle_completes_snoozed_and_open_breaks :: () { #program_export Check :: () -> s32 { test_absence_clock_credits_lock_suspend_and_background() + test_desktop_tick_batch_needs_input_evidence() test_idle_completes_snoozed_and_open_breaks() test_typing_is_activity() test_defaults_match_workrave() diff --git a/tests/break_engine_zi_test.sh b/tests/break_engine_zi_test.sh index ee23d856c..cf53bde8c 100755 --- a/tests/break_engine_zi_test.sh +++ b/tests/break_engine_zi_test.sh @@ -23,6 +23,6 @@ int main(void) return result == 0 ? 0 : 1; } C -"${CC:-cc}" -std=c11 -I"$include" -I"$work/c" "$work/c"/*.c -o "$work/test" +"${CC:-cc}" -std=c11 -I"$include" -I"$work/c" "$work/c"/*.c -lm -o "$work/test" env -u DISPLAY -u WAYLAND_DISPLAY "$work/test" echo "break engine Ziran test passed"