Datasets:
Download android/tom-murphy-development-fasttimes/tests/test_android_computation.py from Qwen/RecreationBench: direct link, hf CLI and curl.
- Browser
- Download file 40.9 kB
-
https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/tom-murphy-development-fasttimes/tests/test_android_computation.py
- Command line
-
hf download hf://datasets/Qwen/RecreationBench/android/tom-murphy-development-fasttimes/tests/test_android_computation.py
-
curl -L -o test_android_computation.py https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/tom-murphy-development-fasttimes/tests/test_android_computation.py
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 | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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 | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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) | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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) | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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 | |
| 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() | |
| 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 | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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") | |
| 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})") | |
| 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) | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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") | |
| 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})") | |
| 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 | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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 | |
| # ═══════════════════════════════════════════════════════════════════════════════ | |
| 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") | |