Fix PC break idle detection and automatic resets

This commit is contained in:
waozi committed 2026-11-19 00:27:33 -03:00
1 parent 15109142ef
commit 2b0e1eaaa7
10 files changed
+204 -114

No files matched your search

+3 -1
View File
@@ -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)
}
+15 -39
View File
@@ -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)
+33 -25
View File
@@ -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
}
+34 -9
View File
@@ -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 {
+6
View File
@@ -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()
+23 -8
View File
@@ -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 }
+45 -18
View File
@@ -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:
+4 -3
View File
@@ -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"
+40 -10
View File
@@ -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()
+1 -1
View File
@@ -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"