VoyagerXHF's picture
Upload folder using huggingface_hub (part 4)
41dfd8d verified
Raw History Blame Contribute Delete
40.9 kB
#!/usr/bin/env python3
"""COMPUTATION module — FastTimes (intermittent-fasting tracker).
CORE FUNCTION here is the fasting TIMER and the derived AGGREGATES. This app has
no calculator; its "input -> output" surface is:
* a goal cell tapped -> a live timer that either COUNTS DOWN ("Remaining",
timed goal) or COUNTS UP ("Elapsed Time", Open Fast); the timer VALUE is a
computed HH:MM:SS that changes over time.
* a timed goal -> a computed "Started" and "End Time" pair, End = Start + goal
duration (Test 1 Hour: End = Start + 1h; Test Timer 10s: Started == End).
* a timed goal reaching its target -> the value MODE flips: "Remaining"
-> "Total Time", the goal name -> "Goal Reached!", and the value then counts
UP; the "End Time" label -> "Goal".
* saving completed fasts -> integer AGGREGATES: the Dashboard "Fasts" count
(0 -> 1 -> 2), the Statistics "Total Fasts" ("1"/completed) and "Consistency"
("100%"/goals met when the goal was met), the History "August Summary"
"Total Fasts", and a duration formatted \\d+h \\d+m.
Every asserted number/relationship was OBSERVED on the running original (see the
module docstring values above), never read from source or computed by hand. Wall-
clock-dependent values are asserted as RELATIONSHIPS (decreasing / increasing /
+1h offset / count deltas) and PATTERNS, with tolerance — the debug Test Timer's
~10s initial remaining is the only near-literal, and it carries a wide tolerance.
CEDES to sibling lanes: whether a screen is reachable -> navigation; a control's
checked/selected/enabled bit -> states; the mere EXISTENCE of a saved record (as
opposed to its numeric aggregate) -> interaction; a non-computed content string
-> text; the view-tree shape / drawn arcs -> structure (but the arc/chart that
ENCODES a value visually is a legitimate VLM here).
VLM budget for this lane = 4 (a value made visual, unreadable from the dump): the
active-fast circular progress RING (partially filled proportional to elapsed), the
FULL green ring at goal-reached, the statistics BAR CHART (bars of differing
heights), and the statistics stat-card cluster showing the computed numbers.
Compose renders as android.view.View / TextView with NO resource-ids, so every
target and read-back key is a visible text / content-desc / bounds-located node.
SAFETY: never taps "Delete" / "Delete Fast"; every exploratory tap is safe.
Run: python3 test_android_computation.py <PACKAGE> <RESULTS_DIR>
"""
import os
import re
import sys
import time
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from android_testgen_kit import * # noqa: F403,E402
require_kit(1)
RESULTS_DIR = sys.argv[2] if len(sys.argv) > 2 else RESULTS_DIR # noqa: F405
_HMS = re.compile(r"^\d{1,2}:\d{2}:\d{2}$") # HH:MM:SS timer value
_DUR = re.compile(r"\b(\d+)h\s+(\d+)m\b") # "0h 2m" duration
_CLOCK = re.compile(r"(\d{1,2}):(\d{2})\s*([AP]M)", re.I) # "3:41 PM"
# ── Portable launcher (LeakCanary registers a 2nd LAUNCHER activity; monkey opens
# it ~half the time). Resolve THIS package's real MainActivity at runtime. ──────
def _main_component():
out = adb_shell("cmd", "package", "query-activities", "--brief",
"-a", "android.intent.action.MAIN",
"-c", "android.intent.category.LAUNCHER")
cands = [l.strip() for l in out.splitlines() if (PACKAGE + "/") in l]
good = [c for c in cands if "leakcanary" not in c.lower()]
return (good or cands or [""])[0]
def open_main():
"""Force-stop then launch the REAL MainActivity (never LeakCanary)."""
force_stop()
comp = _main_component()
if comp:
adb_shell("am", "start", "-n", comp)
else:
launch_app()
settle("launch")
wait_for_foreground()
if "leakcanary" in get_current_activity().lower() and comp:
adb_shell("am", "start", "-n", comp)
settle("launch")
def open_main_clear():
"""Virgin state: wipe data (no active fast, empty history), then open Main."""
clear_data()
open_main()
# ── Domain helpers ───────────────────────────────────────────────────────────
def _dismiss_notif_rationale():
"""The first-run "Notification Preferences" rationale appears on the first goal
tap after clear_data(). Dismiss it non-destructively (choice is irrelevant to
the computations under test). Returns True if it was shown."""
nodes = ui()
if not find_node(nodes, text="Notification Preferences"):
return False
for label in ("No Notifications", "Skip", "Not Now", "Enable Notifications"):
n = find_node(nodes, text=label)
if n and is_safe(n):
tap_node(n)
settle("tap")
return True
return False
def _on_dashboard(nodes=None):
nodes = ui() if nodes is None else nodes
return find_node(nodes, text="Set your goal") is not None
def _start_goal(cell_text):
"""From a CLEAN dashboard, tap a goal cell by name and land on the ACTIVE-FAST
card (desc='End Fast'). Handles the first-run notification rationale. Returns
True on success."""
cell = find_node(ui(), text=cell_text)
if not cell:
return False
tap_node(cell)
settle("tap")
_dismiss_notif_rationale()
if find_node(ui(), content_desc="End Fast"):
return True
cell = find_node(ui(), text=cell_text) # rationale may have eaten the tap
if cell:
tap_node(cell)
settle("tap")
_dismiss_notif_rationale()
return find_node(ui(), content_desc="End Fast") is not None
def _timer_value(nodes=None):
"""The active-fast card's live HH:MM:SS value (a TextView matching ^\\d\\d:..).
Returns the string, or None. There is exactly one such node on the card."""
nodes = ui() if nodes is None else nodes
for n in nodes:
t = n.get("text", "").strip()
if _HMS.match(t):
return t
return None
def _hms_to_secs(t):
try:
h, m, s = (int(x) for x in t.split(":"))
return h * 3600 + m * 60 + s
except Exception:
return None
def _card_label(nodes=None):
"""Which mode-label is showing on the active-fast card: 'Remaining' /
'Elapsed Time' / 'Total Time'. Returns the first found, else ''."""
nodes = ui() if nodes is None else nodes
for lbl in ("Remaining", "Elapsed Time", "Total Time"):
if find_node(nodes, text=lbl):
return lbl
return ""
def _value_under_label(nodes, label_text, want, max_dy=170):
"""Read the stat VALUE that sits directly BELOW a card label and is x-aligned
with it (the FastTimes stat-card pattern: label / big-value / subtitle). `want`
is a predicate on the candidate text. Returns the matching text or None.
Used for the Dashboard 'Fasts' count and the Statistics/History 'Total Fasts'
and 'Consistency' cards, whose numbers have no id and no distinct text anchor —
only their position under the label identifies them."""
lbl = find_node(nodes, text=label_text)
if not lbl or "_bounds" not in lbl:
return None
lx = lbl["_center"][0]
ly2 = lbl["_bounds"][3]
best = None
for n in nodes:
t = n.get("text", "").strip()
b = n.get("_bounds")
if not b or not t or not want(t):
continue
if b[1] >= ly2 and (b[1] - ly2) < max_dy and abs(n["_center"][0] - lx) < 150:
if best is None or b[1] < best[1]:
best = (t, b[1])
return best[0] if best else None
def _fasts_count(nodes=None):
"""The integer under the Dashboard 'Fasts' stat blob. Returns int or None."""
nodes = ui() if nodes is None else nodes
v = _value_under_label(nodes, "Fasts", lambda t: t.isdigit())
return int(v) if v is not None else None
def _wait_goal_reached(polls=18):
"""Poll until the Test Timer flips to 'Goal Reached!' (~10s). Bounded so a slow
emulator never hangs. Returns whether it flipped."""
for _ in range(polls):
if find_node(ui(), text="Goal Reached!"):
return True
settle("tap")
return False
def _modal_star_views():
"""The 5 clickable rating-star Views in the 'Fast Complete!' summary modal:
empty-text clickable android.view.View nodes in one horizontal row. x-sorted."""
nodes = ui()
clk = [n for n in nodes
if n.get("class", "").endswith("view.View")
and n.get("clickable") == "true"
and not n.get("text", "").strip()
and not n.get("content-desc", "").strip()
and "_bounds" in n]
stars = []
for n in clk:
x1, y1, x2, y2 = n["_bounds"]
w, h = x2 - x1, y2 - y1
if w < 40 or h < 40:
continue
if 0.6 <= w / h <= 1.7:
stars.append(n)
if len(stars) < 5:
return []
stars.sort(key=lambda n: n["_center"][1])
rows, cur = [], [stars[0]]
for n in stars[1:]:
if abs(n["_center"][1] - cur[-1]["_center"][1]) <= 30:
cur.append(n)
else:
rows.append(cur)
cur = [n]
rows.append(cur)
row = max(rows, key=len)
row.sort(key=lambda n: n["_center"][0])
return row
def save_test_timer_fast():
"""Complete + SAVE one Test Timer fast from a clean dashboard (rating 4 stars),
landing back on the Dashboard with the fast persisted. Returns True on success.
This produces a GOAL-MET completed fast, which is what makes Consistency 100%."""
if not _start_goal("Test Timer"):
return False
_wait_goal_reached()
ef = find_node(ui(), content_desc="End Fast")
if not ef:
return False
tap_node(ef)
settle("tap")
stars = _modal_star_views()
if len(stars) >= 4:
tap_node(stars[3]) # 4th star
settle("tap")
save = find_node(ui(), text="Save")
if not save or not tap_node(save):
return False
settle("tap")
return _on_dashboard()
def _end_active_no_save():
"""Tap End Fast then BACK out of the summary WITHOUT saving (keeps history
clean). Best-effort cleanup only."""
ef = find_node(ui(), content_desc="End Fast")
if ef:
tap_node(ef)
settle("tap")
back()
settle("tap")
# ── Named depth helpers (the and_reach_* NAME backs a depth>=1 claim; each body is
# a real, PROVEN surface jump — target appeared, source vanished). ──────────────
def and_reach_statistics():
"""Dashboard -> Statistics ('Performance'). Proven: 'Trends' appears, the goal
card 'Set your goal' vanishes. Counts one surface (jump_kind='reach')."""
n = find_node(ui(), content_desc="Go to Statistics")
if not n:
return False
return and_reach_surface(n, "Trends", "Set your goal")
def and_reach_history():
"""Dashboard -> History pane. Proven: 'August 2026' appears, 'Set your goal'
vanishes. Counts one surface."""
n = find_node(ui(), content_desc="Go to History")
if not n:
return False
return and_reach_surface(n, "August 2026", "Set your goal")
# ═══════════════════════════════════════════════════════════════════════════════
# (1) COUNTDOWN — a timed goal's "Remaining" value DECREASES over time
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_countdown_decreases",))
def test_countdown_decreases():
"""Start 'Test 1 Hour' (a 1h timed goal): the card shows label 'Remaining' and a
HH:MM:SS value that COUNTS DOWN. Read it twice ~3s apart and assert the second
is strictly LESS than the first (and the initial value is just under 01:00:00,
proving it started from the goal and is decrementing). The 1h window is used
(not the 10s Test Timer) so the read is not racing the goal-reached flip."""
open_main_clear()
started = _start_goal("Test 1 Hour")
if not started:
record("computation_countdown_decreases", False,
"feature_missing: could not start the 'Test 1 Hour' timed goal "
"('End Fast' card not shown)",
depth=0, jump_kind="value",
expect="Remaining value decreases over ~3s (e.g. 00:59:57 -> 00:59:54)")
return
n1 = ui()
label = _card_label(n1)
v1 = _timer_value(n1)
time.sleep(3)
v2 = _timer_value(ui())
s1 = _hms_to_secs(v1) if v1 else None
s2 = _hms_to_secs(v2) if v2 else None
# initial remaining is just under the 1h goal (allow slack for start latency)
fresh_ok = s1 is not None and 3480 <= s1 <= 3600 # 58:00 .. 60:00
decreased = s1 is not None and s2 is not None and s2 < s1
ok = (label == "Remaining") and fresh_ok and decreased
record("computation_countdown_decreases", bool(ok),
"" if ok else (f"behavior_wrong: label={label!r} remaining did not count "
f"down (v1={v1!r} -> v2={v2!r}); expected label 'Remaining' "
f"and a strictly decreasing HH:MM:SS near 01:00:00"),
depth=0, jump_kind="value",
expect=f"label 'Remaining'; value decreases over ~3s (saw {v1} -> {v2})")
_end_active_no_save()
# ═══════════════════════════════════════════════════════════════════════════════
# (2) COUNT-UP — Open Fast's "Elapsed Time" value INCREASES over time
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_countup_increases",))
def test_countup_increases():
"""Start 'Open Fast' (infinite goal): the card shows label 'Elapsed Time' and a
HH:MM:SS value that COUNTS UP, and there is NO 'End Time' line. Read the value
twice ~3s apart and assert the second is strictly GREATER than the first."""
open_main_clear()
started = _start_goal("Open Fast")
if not started:
record("computation_countup_increases", False,
"feature_missing: could not start 'Open Fast' ('End Fast' card not "
"shown)",
depth=0, jump_kind="value",
expect="Elapsed Time value increases over ~3s (e.g. 00:00:03 -> "
"00:00:06)")
return
n1 = ui()
label = _card_label(n1)
no_end_time = find_node(n1, text="End Time") is None # Open Fast has none
v1 = _timer_value(n1)
time.sleep(3)
v2 = _timer_value(ui())
s1 = _hms_to_secs(v1) if v1 else None
s2 = _hms_to_secs(v2) if v2 else None
increased = s1 is not None and s2 is not None and s2 > s1
ok = (label == "Elapsed Time") and no_end_time and increased
record("computation_countup_increases", bool(ok),
"" if ok else (f"behavior_wrong: label={label!r} elapsed did not count up "
f"(v1={v1!r} -> v2={v2!r}) / an 'End Time' line was present "
f"({not no_end_time}); expected 'Elapsed Time' counting up "
f"with no End Time"),
depth=0, jump_kind="value",
expect=f"label 'Elapsed Time', no End Time; value increases over ~3s "
f"(saw {v1} -> {v2})")
_end_active_no_save()
# ═══════════════════════════════════════════════════════════════════════════════
# (3) FRESH TEST TIMER — initial 'Remaining' is ~10s (> 0 and <= 00:00:10)
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_test_timer_initial_10s",
"computation_test_timer_initial_10s_vlm"))
def test_test_timer_initial_remaining():
"""The debug 'Test Timer' goal is 10 seconds: immediately after starting it the
'Remaining' value must be > 0 and <= ~10s (allow a small +slack for start
latency, cap at 13s). This pins the debug constant WITH tolerance rather than a
hard literal. The partially-filled progress RING (a value made visual) is the
paired VLM."""
open_main_clear()
started = _start_goal("Test Timer")
if not started:
record("computation_test_timer_initial_10s", False,
"feature_missing: could not start 'Test Timer' ('End Fast' card not "
"shown)",
depth=0, jump_kind="value",
expect="initial Remaining > 0 and <= ~00:00:10")
vlm_assert("computation_test_timer_initial_10s",
"Is a large timer value shown in the centre with a coloured "
"circular progress ring or arc drawn around it? Answer YES or NO.",
RESULTS_DIR, tag="shape", depth=0, jump_kind="value")
return
n1 = ui()
label = _card_label(n1)
v1 = _timer_value(n1)
s1 = _hms_to_secs(v1) if v1 else None
ok = (label in ("Remaining", "Total Time")) and s1 is not None and 0 < s1 <= 13
record("computation_test_timer_initial_10s", bool(ok),
"" if ok else (f"behavior_wrong: fresh Test Timer remaining={v1!r} "
f"(label={label!r}); expected a value > 0 and <= ~10s "
f"(cap 13s)"),
depth=0, jump_kind="value",
expect=f"fresh Test Timer 'Remaining' > 0 and <= ~00:00:10 (saw {v1})")
# VLM (value-made-visual): a partially filled ring encodes the elapsed fraction.
vlm_assert("computation_test_timer_initial_10s",
"Is a large timer value (like 00:00:10) shown in the centre of the "
"card with a coloured circular progress ring or arc drawn around it? "
"Answer YES or NO.",
RESULTS_DIR, tag="shape", depth=0, jump_kind="value")
_end_active_no_save()
# ═══════════════════════════════════════════════════════════════════════════════
# (4) GOAL-REACHED TRANSITION — 'Remaining' -> 'Total Time' + 'Goal Reached!',
# then the value counts UP (the VALUE MODE flips)
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_goal_reached_transition",
"computation_goal_reached_transition_vlm"))
def test_goal_reached_transition():
"""Start Test Timer with label 'Remaining' (counting down); after ~10s the value
MODE flips: the goal name becomes 'Goal Reached!', the label becomes 'Total
Time', and the value then COUNTS UP from the goal. Assert the before ('Remaining'
present, 'Goal Reached!'/'Total Time' absent) -> after ('Goal Reached!' +
'Total Time' present) transition AND that the post-goal value increases. The
FULL green ring at goal-reached is the paired VLM."""
open_main_clear()
started = _start_goal("Test Timer")
if not started:
record("computation_goal_reached_transition", False,
"feature_missing: could not start 'Test Timer'",
depth=0, jump_kind="transition",
expect="'Remaining' -> 'Total Time' + 'Goal Reached!'; then value "
"counts up")
vlm_assert("computation_goal_reached_transition",
"Is a fully-closed bright green circular ring drawn around the "
"timer (indicating the fasting goal was reached)? Answer YES or NO.",
RESULTS_DIR, tag="color", depth=0, jump_kind="transition")
return
before = ui()
remaining_before = (_card_label(before) == "Remaining"
and find_node(before, text="Goal Reached!") is None
and find_node(before, text="Total Time") is None)
flipped = _wait_goal_reached()
after = ui()
reached = (flipped
and find_node(after, text="Goal Reached!") is not None
and find_node(after, text="Total Time") is not None)
# after reaching, the value counts UP
v1 = _timer_value(after)
time.sleep(3)
v2 = _timer_value(ui())
s1 = _hms_to_secs(v1) if v1 else None
s2 = _hms_to_secs(v2) if v2 else None
counts_up = s1 is not None and s2 is not None and s2 > s1
ok = remaining_before and reached and counts_up
record("computation_goal_reached_transition", bool(ok),
"" if ok else ("behavior_wrong: the Test Timer did not flip 'Remaining' "
"-> 'Total Time'/'Goal Reached!'" if not reached
else f"behavior_wrong: after goal-reached the value did not "
f"count up (v1={v1!r} -> v2={v2!r})"),
depth=0, jump_kind="transition",
expect=f"label 'Remaining' -> 'Total Time' + 'Goal Reached!' shown; then "
f"value counts up (saw {v1} -> {v2})")
# VLM (value-made-visual): the ring is fully closed & green once the goal is met.
vlm_assert("computation_goal_reached_transition",
"Is a fully-closed bright green circular ring drawn all the way around "
"the timer (indicating the fasting goal was reached), rather than a "
"partially-filled arc? Answer YES or NO.",
RESULTS_DIR, tag="color", depth=0, jump_kind="transition")
_end_active_no_save()
# ═══════════════════════════════════════════════════════════════════════════════
# (5) START / END TIME — both render; End >= Start; Test 1 Hour End = Start + 1h
# ═══════════════════════════════════════════════════════════════════════════════
def _clock_minutes(nodes, label_text):
"""Read the 'Today, H:MM PM' timestamp under a card label ('Started'/'End Time')
and return minutes-since-midnight (0..1439), or None. Parses the first
H:MM AM/PM in the value node directly below the label."""
val = _value_under_label(nodes, label_text, lambda t: _CLOCK.search(t) is not None)
if not val:
return None
m = _CLOCK.search(val)
if not m:
return None
h, mm, ap = int(m.group(1)), int(m.group(2)), m.group(3).upper()
h = h % 12
if ap == "PM":
h += 12
return h * 60 + mm
@and_test(expects=("computation_end_time_offset",))
def test_start_end_time_offset():
"""A TIMED goal computes 'Started' and 'End Time' = Started + goal duration.
Start 'Test 1 Hour': assert BOTH timestamps render and End = Start + 60 min
(a real computed offset, ±2 min for the read/rollover), handling the midnight
wrap. This is the app's most concrete arithmetic on user-visible values."""
open_main_clear()
started = _start_goal("Test 1 Hour")
if not started:
record("computation_end_time_offset", False,
"feature_missing: could not start 'Test 1 Hour'",
depth=0, jump_kind="value",
expect="End Time = Started + 60 min (both render)")
return
nodes = ui()
both_render = (find_node(nodes, text="Started") is not None
and find_node(nodes, text="End Time") is not None)
start_min = _clock_minutes(nodes, "Started")
end_min = _clock_minutes(nodes, "End Time")
diff = None
if start_min is not None and end_min is not None:
diff = (end_min - start_min) % (24 * 60) # wrap past midnight
offset_ok = diff is not None and abs(diff - 60) <= 2
ok = both_render and offset_ok
record("computation_end_time_offset", bool(ok),
"" if ok else (f"behavior_wrong: Test 1 Hour End Time was not Start + 60m "
f"(start_min={start_min}, end_min={end_min}, diff={diff}); "
f"both_render={both_render}"),
depth=0, jump_kind="value",
expect=f"End Time = Started + 60 min (observed diff {diff} min)")
_end_active_no_save()
@and_test(expects=("computation_test_timer_start_eq_end",))
def test_test_timer_start_equals_end():
"""The 10-second 'Test Timer' goal computes Started and End Time within the same
minute, so they render EQUAL (0-min offset). Assert both render and End - Start
is 0 min (allow 1 min for a read straddling a minute boundary). Complements the
+1h case: same machinery, different goal duration -> different computed value."""
open_main_clear()
started = _start_goal("Test Timer")
if not started:
record("computation_test_timer_start_eq_end", False,
"feature_missing: could not start 'Test Timer'",
depth=0, jump_kind="value",
expect="Test Timer Started == End Time (0-min offset)")
return
nodes = ui()
both_render = (find_node(nodes, text="Started") is not None
and find_node(nodes, text="End Time") is not None)
start_min = _clock_minutes(nodes, "Started")
end_min = _clock_minutes(nodes, "End Time")
diff = None
if start_min is not None and end_min is not None:
diff = (end_min - start_min) % (24 * 60)
same_min = diff is not None and diff <= 1
ok = both_render and same_min
record("computation_test_timer_start_eq_end", bool(ok),
"" if ok else (f"behavior_wrong: Test Timer End Time was not within the "
f"same minute as Started (start_min={start_min}, "
f"end_min={end_min}, diff={diff}); both_render={both_render}"),
depth=0, jump_kind="value",
expect=f"Test Timer End Time - Started == 0 min (observed diff {diff})")
_end_active_no_save()
# ═══════════════════════════════════════════════════════════════════════════════
# (6) FASTS COUNT — clean baseline is 0, then 0 -> 1 -> 2 as fasts are saved
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_fasts_count_zero",))
def test_fasts_count_zero():
"""On a CLEAN install the Dashboard 'Fasts / N / this month' aggregate is 0 (and
History reads 'No recent fasts to show.'). The negative baseline that makes the
0->1 delta discriminating."""
open_main_clear()
nodes = ui()
count = _fasts_count(nodes)
empty_hist = find_node_ci(nodes, "No recent fasts to show.") is not None
ok = (count == 0) and empty_hist
record("computation_fasts_count_zero", bool(ok),
"" if ok else (f"behavior_wrong: clean-install Dashboard 'Fasts' count was "
f"{count!r} (expected 0) / History not empty "
f"({empty_hist})"),
depth=0, jump_kind="value",
expect="clean-install Dashboard 'Fasts' count == 0")
@and_test(expects=("computation_fasts_count_zero_to_one",))
def test_fasts_count_zero_to_one():
"""The 'Fasts' aggregate increments 0 -> 1 after completing and SAVING one Test
Timer fast. Reads the count BEFORE (must be 0) and AFTER the save (must be 1) —
the count is the computed aggregate, not the record's mere existence."""
open_main_clear()
before = _fasts_count(ui())
made = save_test_timer_fast()
after = _fasts_count(ui()) if made else None
ok = (before == 0) and made and (after == 1)
record("computation_fasts_count_zero_to_one", bool(ok),
"" if ok else ("feature_missing: could not complete+Save a Test Timer fast"
if not made
else f"behavior_wrong: Dashboard 'Fasts' count was "
f"{before!r} before and {after!r} after saving one fast "
f"(expected 0 -> 1)"),
depth=0, jump_kind="value",
expect=f"Dashboard 'Fasts' count 0 -> 1 after one saved fast (saw {before} "
f"-> {after})")
@and_test(expects=("computation_fasts_count_two",))
def test_fasts_count_two():
"""The aggregate keeps climbing: after a SECOND saved Test Timer fast the count
is 2. A recreation that keeps only a single 'latest' row (not a real count)
stalls at 1. Asserts the 0,1,2 progression across two saves."""
open_main_clear()
counts = [_fasts_count(ui())] # baseline 0
for _ in range(2):
if not save_test_timer_fast():
break
counts.append(_fasts_count(ui()))
ok = (len(counts) == 3
and all(c is not None for c in counts)
and counts == [0, 1, 2])
record("computation_fasts_count_two", bool(ok),
"" if ok else (f"behavior_wrong: Dashboard 'Fasts' count did not climb "
f"0 -> 1 -> 2 across two saves (saw {counts}) — only one "
f"record appears to be kept"),
depth=0, jump_kind="value",
expect=f"Dashboard 'Fasts' count 0,1,2 across two saves (observed {counts})")
# ═══════════════════════════════════════════════════════════════════════════════
# (7) STATISTICS AGGREGATES — Total Fasts = 1, Consistency = 100% (goal met)
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_stats_total_fasts_one",
"computation_stats_total_fasts_one_vlm"))
def test_stats_total_fasts_one():
"""After one goal-met Test Timer fast, the Statistics ('Performance') screen's
'Total Fasts' card reads '1' (with subtitle 'completed'). Crosses to Statistics
(depth 1, backed by and_reach_statistics) and reads the computed aggregate. The
stat-card cluster showing the numbers is the paired VLM."""
open_main_clear()
made = save_test_timer_fast()
reached = made and and_reach_statistics() # depth 1 (proven reach)
if not reached:
record("computation_stats_total_fasts_one", False,
"setup_failed: could not save a fast and reach Statistics"
if not made else
"setup_failed: Statistics ('Trends') not reached from 'Go to "
"Statistics'",
depth=1, jump_kind="value",
expect="Statistics 'Total Fasts' card reads '1'")
vlm_assert("computation_stats_total_fasts_one",
"Do the three rounded statistic cards near the bottom show numeric "
"values under their titles (a whole number under 'Total Fasts' and "
"a percentage under 'Consistency')? Answer YES or NO.",
RESULTS_DIR, tag="content", depth=1, jump_kind="value")
return
nodes = ui()
total = _value_under_label(nodes, "Total Fasts", lambda t: t.isdigit())
ok = total == "1"
record("computation_stats_total_fasts_one", bool(ok),
"" if ok else f"behavior_wrong: Statistics 'Total Fasts' read {total!r} "
f"after one saved fast (expected '1')",
depth=1, jump_kind="value",
expect=f"Statistics 'Total Fasts' == '1' (read {total!r})")
# VLM (value-made-visual): the expressive stat-card cluster shows the numbers.
vlm_assert("computation_stats_total_fasts_one",
"Do the three rounded statistic cards near the bottom each show a large "
"numeric value under their title (for example a whole number under "
"'Total Fasts' and a percentage under 'Consistency')? Answer YES or NO.",
RESULTS_DIR, tag="content", depth=1, jump_kind="value")
@and_test(expects=("computation_stats_consistency_100",))
def test_stats_consistency_100():
"""A Test Timer fast REACHES its goal, so after saving one the Statistics
'Consistency' card reads '100%' (subtitle 'goals met'). Crosses to Statistics
(depth 1) and reads the computed percentage — a derived value from goals-met /
total."""
open_main_clear()
made = save_test_timer_fast()
reached = made and and_reach_statistics() # depth 1 (proven reach)
if not reached:
record("computation_stats_consistency_100", False,
"setup_failed: could not save a fast and reach Statistics",
depth=1, jump_kind="value",
expect="Statistics 'Consistency' card reads '100%'")
return
nodes = ui()
pct = _value_under_label(nodes, "Consistency", lambda t: t.endswith("%"))
ok = pct == "100%"
record("computation_stats_consistency_100", bool(ok),
"" if ok else f"behavior_wrong: Statistics 'Consistency' read {pct!r} after "
f"one goal-met fast (expected '100%')",
depth=1, jump_kind="value",
expect=f"Statistics 'Consistency' == '100%' (read {pct!r})")
@and_test(expects=("computation_stats_chart_vlm",))
def test_stats_chart_vlm():
"""The Statistics screen renders a bar/line CHART whose bar HEIGHTS encode the
per-day/period values — a value made visual that never reaches the view tree.
Crosses to Statistics (depth 1) and asks the VLM about the drawn bars. Pure VLM
(no dump-readable rule half beyond reachability, which navigation owns)."""
open_main_clear()
made = save_test_timer_fast()
reached = made and and_reach_statistics() # depth 1 (proven reach)
if not reached:
vlm_assert("computation_stats_chart",
"Are there several vertical or horizontal bars of differing "
"lengths drawn above a row of day/date axis labels (T F S S M T W)? "
"Answer YES or NO.",
RESULTS_DIR, tag="shape", depth=1, jump_kind="value")
return
# VLM (value-made-visual): the chart bars differ in height/length by value.
vlm_assert("computation_stats_chart",
"Are there several coloured bars drawn in a row above the day/date axis "
"labels (like T F S S M T W), representing a chart of values? "
"Answer YES or NO.",
RESULTS_DIR, tag="shape", depth=1, jump_kind="value")
# ═══════════════════════════════════════════════════════════════════════════════
# (8) HISTORY AGGREGATE — August Summary 'Total Fasts' = 1
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_history_summary_total_one",))
def test_history_summary_total_one():
"""After one saved Test Timer fast, the History pane's 'August Summary' ->
'Total Fasts' card reads '1'. Crosses to the History pane (depth 1, backed by
and_reach_history) and reads the month aggregate."""
open_main_clear()
made = save_test_timer_fast()
reached = made and and_reach_history() # depth 1 (proven reach)
if not reached:
record("computation_history_summary_total_one", False,
"setup_failed: could not save a fast and reach the History pane",
depth=1, jump_kind="value",
expect="History 'August Summary' 'Total Fasts' reads '1'")
return
# the summary sits below the calendar; scroll it into view then read the value
summary = scroll_into_view("August Summary", max_swipes=4)
nodes = ui()
total = _value_under_label(nodes, "Total Fasts", lambda t: t.isdigit())
ok = (summary is not None) and total == "1"
record("computation_history_summary_total_one", bool(ok),
"" if ok else f"behavior_wrong: History 'August Summary' 'Total Fasts' read "
f"{total!r} after one saved fast (expected '1')",
depth=1, jump_kind="value",
expect=f"History 'August Summary' 'Total Fasts' == '1' (read {total!r})")
# ═══════════════════════════════════════════════════════════════════════════════
# (9) DURATION FORMATTING — a saved fast renders a \\d+h \\d+m duration
# ═══════════════════════════════════════════════════════════════════════════════
@and_test(expects=("computation_duration_format",))
def test_duration_format():
"""A completed fast's duration is computed and rendered as '<H>h <M>m' (e.g.
'0h 2m'). After saving one Test Timer fast, the Dashboard History section shows
the entry under 'This Week' with a duration matching \\d+h \\d+m. Assert the
PATTERN renders (the exact minutes depend on wall-clock rollover during the ~10s
fast, so the value itself is NOT hard-coded) and that no duration was present on
the clean baseline."""
open_main_clear()
absent_before = not any(_DUR.search(n.get("text", "")) for n in ui())
made = save_test_timer_fast()
nodes = ui() if made else []
dur_node = next((n.get("text", "") for n in nodes
if _DUR.search(n.get("text", ""))), None)
this_week = made and find_node(nodes, text="This Week") is not None
parsed = _DUR.search(dur_node) if dur_node else None
# h and m are non-negative and well-formed (m < 60 is the only sanity bound)
format_ok = parsed is not None and 0 <= int(parsed.group(2)) < 60
ok = absent_before and made and this_week and format_ok
record("computation_duration_format", bool(ok),
"" if ok else ("feature_missing: could not save a Test Timer fast"
if not made
else f"behavior_wrong: no '<H>h <M>m' duration rendered in "
f"the Dashboard History after saving (dur={dur_node!r}, "
f"absent_before={absent_before})"),
depth=0, jump_kind="value",
expect=f"saved fast renders a '\\d+h \\d+m' duration under 'This Week' "
f"(saw {dur_node!r})")
# ═══════════════════════════════════════════════════════════════════════════════
TESTS = [
test_countdown_decreases,
test_countup_increases,
test_test_timer_initial_remaining,
test_goal_reached_transition,
test_start_end_time_offset,
test_test_timer_start_equals_end,
test_fasts_count_zero,
test_fasts_count_zero_to_one,
test_fasts_count_two,
test_stats_total_fasts_one,
test_stats_consistency_100,
test_stats_chart_vlm,
test_history_summary_total_one,
test_duration_format,
]
if __name__ == "__main__":
if not device_online():
print("setup_failed: device offline / adb tunnel down — aborting")
sys.exit(2)
run_suite(TESTS, "computation")