#!/usr/bin/env python3 """STRUCTURE module — FastTimes (intermittent-fasting tracker). Owns two things only: (1) the GATE: the app launches into its Dashboard with the top-level surfaces present (title, "Set your goal" card, the 2-col goal grid, the green FAB). (2) tree-SHAPE deltas: an interaction changes the view tree's SHAPE — a class of widget appears/vanishes, a dialog adds a window layer, a list populates. Each delta is recorded as a before->after and then REVERSED to assert it restores. Content strings -> text lane; checked/selected -> states; reachability -> nav; values -> computation. Here we assert SHAPE and existence of surfaces, plus spatial layout via the VLM (the circular ring, the calendar grid, the expressive stat-card shapes — none of which reach the view tree). Run: python3 test_android_structure.py """ import os import sys sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from android_testgen_kit import * # noqa: F403,E402 require_kit(1) # ── 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(nodes): """The first-run "Notification Preferences" rationale can appear on the first goal tap after clear_data(). Dismiss it (choice is irrelevant to structure).""" if not find_node(nodes, text="Notification Preferences"): return False for label in ("No Notifications", "Enable Notifications", "Cancel", "Skip"): n = find_node(nodes, text=label) if n: tap_node(n) settle("tap") return True return False def start_test_timer(): """From a clean dashboard, tap the "Test Timer" goal cell and end up on the ACTIVE-FAST card. Handles the optional first-run notification rationale. Returns the post-start node tree, or None if the cell was missing.""" dash = ui() cell = find_node(dash, text="Test Timer") if not cell: return None tap_node(cell) settle("tap") after = ui() if _dismiss_notif_rationale(after): after = ui() if not find_node(after, content_desc="End Fast"): # dialog path may have consumed the tap; retry the cell once cell = find_node(after, text="Test Timer") if cell: tap_node(cell) settle("tap") after = ui() return after def end_active_fast_no_save(nodes): """Tap End Fast, then BACK out of the "Fast Complete!" summary WITHOUT saving, returning to a clean dashboard. Keeps history empty (no CRUD side effect).""" ef = find_node(nodes, content_desc="End Fast") if not ef: return ui() tap_node(ef) settle("tap") back() # dismiss the summary modal without saving settle("tap") return ui() # ── Named navigation helpers (back a depth>=1 claim honestly) ────────────────── def and_reach_screen(nodes, trigger_text="", trigger_desc="", target="", source=""): """Tap a labelled trigger on `nodes`, then PROVE the surface jump: `target` appeared and `source` vanished. Counts one surface (jump_kind='reach').""" n = None if trigger_text: n = find_node(nodes, text=trigger_text) or find_node_ci(nodes, trigger_text) if n is None and trigger_desc: n = find_node(nodes, content_desc=trigger_desc) if n is None: return False return and_reach_surface(n, target, source or None) def and_enter_dialog(nodes, trigger_desc="", trigger_text=""): """Open an in-place dialog/overlay (a new window layer over the same screen), confirming the surface changed. Counts one surface (depth+1).""" ok, _note = and_enter_surface(nodes, target_text=trigger_text, content_desc=trigger_desc) return ok RESULTS_DIR = sys.argv[2] if len(sys.argv) > 2 else RESULTS_DIR # noqa: F405 # ═══════════════════════════════════════════════════════════════════════════════ # (1) GATE — top-level Dashboard surfaces present (jump_kind="none", depth=0) # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_gate_launch",)) def test_gate_launch(): open_main_clear() nodes = ui() fg = wait_for_foreground() # main container: single-Activity Compose renders a ComposeView host inside a # top-level layout container. Assert BOTH a layout host and a Compose host. container = find_by_class(nodes, "ComposeView") and find_by_class(nodes, "FrameLayout") ok = bool(fg and container) record("structure_gate_launch", ok, "" if ok else "setup_failed: app did not reach the foreground with a " "Compose container", depth=0, jump_kind="none") @and_test(expects=("structure_gate_dashboard_surfaces", "structure_dashboard_fab_vlm")) def test_gate_dashboard_surfaces(): open_main_clear() nodes = ui() # top-level Dashboard surfaces, by visible text + content-desc (no ids): title = find_node_ci(nodes, "Fast Times") # toolbar title goal_card = find_node_ci(nodes, "Set your goal") # goal card header perf = find_node_ci(nodes, "Performance") # performance section hist = find_node_ci(nodes, "History") # history section fab = find_node(nodes, content_desc="Add Fast") # green add FAB settings = find_node(nodes, content_desc="Settings") # toolbar gear ok = all([title, goal_card, perf, hist, fab, settings]) record("structure_gate_dashboard_surfaces", bool(ok), "" if ok else "feature_missing: a top-level Dashboard surface is absent " "(title/Set your goal/Performance/History/FAB/Settings)", depth=0, jump_kind="none") # VLM: the FAB is a green button in the bottom-right corner (a rounded square # with a dark icon). Assert the exact rendered COLOR + POSITION. vlm_assert("structure_dashboard_fab", "Is there a green colored button in the bottom-right corner of the " "screen containing a small dark icon? Answer YES or NO.", RESULTS_DIR, tag="color", depth=0, jump_kind="none") @and_test(expects=("structure_gate_goal_grid", "structure_goal_grid_layout_vlm")) def test_gate_goal_grid(): open_main_clear() nodes = ui() # The 8-cell goal grid: assert the SHAPE (all 8 named cells exist). This is # existence of a structural grid, not any single string's content. cells = ["12h", "14h", "16h", "18h", "24h", "∞", "1h", "0h"] present = [c for c in cells if find_node(nodes, text=c)] ok = len(present) == 8 record("structure_gate_goal_grid", ok, "" if ok else f"feature_missing: goal grid incomplete, only " f"{len(present)}/8 cells present ({present})", depth=0, jump_kind="none") # VLM: the eight cells are laid out as a 2-column grid. vlm_assert("structure_goal_grid_layout", "Under the 'Set your goal' heading, are the goal cells arranged in a " "grid with exactly two columns per row? Answer YES or NO.", RESULTS_DIR, tag="position", depth=0, jump_kind="none") # ═══════════════════════════════════════════════════════════════════════════════ # (2) SHAPE DELTAS — in-place (depth=0) transitions with a reverse # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_fab_speeddial_expand", "structure_fab_speeddial_vlm")) def test_fab_speeddial_expand(): open_main_clear() dash = ui() fab = find_node(dash, content_desc="Add Fast") if not fab: record("structure_fab_speeddial_expand", False, "feature_missing: Add Fast FAB not present on Dashboard", depth=0, jump_kind="transition", expect="FAB expand adds 'Start Open Fast'+'View History' children") else: before = and_showing(dash) n_clk_before = len(find_nodes(dash, clickable=True)) tap_node(fab) exp_nodes = ui() after = and_showing(exp_nodes) n_clk_after = len(find_nodes(exp_nodes, clickable=True)) # speed-dial GROWS the tree: 2 new labelled actions + 2 more clickables. added = after - before grew = (any("Start Open Fast" in k for k in added) and any("View History" in k for k in added) and n_clk_after >= n_clk_before + 2) # reverse: tapping the FAB again collapses it back to the original shape. fab2 = find_node(exp_nodes, content_desc="Add Fast") if fab2: tap_node(fab2) coll = ui() restored = (not find_node(coll, text="Start Open Fast") and len(find_nodes(coll, clickable=True)) == n_clk_before) ok = grew and restored record("structure_fab_speeddial_expand", ok, "" if ok else ("behavior_wrong: speed-dial did not add the two " "action buttons" if not grew else "behavior_wrong: speed-dial did not collapse back"), depth=0, jump_kind="transition", expect="clickables +2 with 'Start Open Fast'+'View History' on expand," " restored on collapse") # re-expand so the VLM screenshot shows the speed-dial open fab3 = find_node(coll, content_desc="Add Fast") if fab3: tap_node(fab3) vlm_assert("structure_fab_speeddial", "Are there two green pill-shaped action buttons stacked vertically " "directly above the round green button in the bottom-right corner? " "Answer YES or NO.", RESULTS_DIR, tag="position", depth=0, jump_kind="transition") @and_test(expects=("structure_active_fast_shape", "structure_active_fast_ring_vlm")) def test_active_fast_shape(): open_main_clear() dash = ui() before = and_showing(dash) fab_before = bool(find_node(dash, content_desc="Add Fast")) active = start_test_timer() if active is None: record("structure_active_fast_shape", False, "setup_failed: 'Test Timer' goal cell not found on Dashboard", depth=0, jump_kind="transition", expect="active-fast card adds ProgressBar+End Fast, FAB disappears") else: # SHAPE delta: a circular ProgressBar (the ring) + an "End Fast" control # appear, and the "Add Fast" FAB disappears while a fast is active. ring = find_by_class(active, "ProgressBar") end_fast = find_node(active, content_desc="End Fast") fab_after = bool(find_node(active, content_desc="Add Fast")) after = and_showing(active) changed = surface_changed(before, after) grew = bool(ring) and bool(end_fast) and fab_before and (not fab_after) # VLM while the ring is on screen (before we tear the fast down) vlm_assert("structure_active_fast_ring", "Is there a circular ring or arc drawn around the countdown " "timer numbers near the top-center of the screen? " "Answer YES or NO.", RESULTS_DIR, tag="shape", depth=0, jump_kind="transition") # reverse: end the fast (no save) -> the goal grid shape returns, ring gone. restored_nodes = end_active_fast_no_save(active) restored = (bool(find_node(restored_nodes, text="Set your goal")) and not find_node(restored_nodes, content_desc="End Fast") and bool(find_node(restored_nodes, content_desc="Add Fast"))) ok = changed and grew and restored record("structure_active_fast_shape", ok, "" if ok else ("behavior_wrong: starting a fast did not swap the goal " "card for the active-fast ring/End-Fast shape" if not grew else "behavior_wrong: ending the fast did not restore " "the Dashboard goal shape"), depth=0, jump_kind="transition", expect="goal card -> ProgressBar ring + End Fast + FAB gone; " "restored to goal grid on End Fast") return # active is None path: still spend the declared VLM record (screenshot dashboard) vlm_assert("structure_active_fast_ring", "Is there a circular ring or arc drawn around the countdown " "timer numbers near the top-center of the screen? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=0, jump_kind="transition") # ═══════════════════════════════════════════════════════════════════════════════ # (3) SHAPE DELTAS — navigation-backed (depth>=1), each proven by and_reach_* # ═══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_dashboard_to_profiles", "structure_profiles_grid_vlm")) def test_dashboard_to_profiles_shape(): open_main_clear() dash = ui() before = and_showing(dash) # Navigate to Manage Profiles (proves reach: 'Other Profiles' appears, the # 'Set your goal' goal card vanishes). Backs depth=1. reached = and_reach_screen(dash, trigger_text="Manage Profiles", target="Other Profiles", source="Set your goal") prof = ui() after = and_showing(prof) # SHAPE: the profiles screen adds a grid of profile cards (many named cards) and # an "Add Profile" FAB — a materially different tree from the Dashboard. cards = [t for t in ("12 Hours", "14 Hours", "16 Hours", "18 Hours", "24 Hours") if find_node(prof, text=t)] add_fab = bool(find_node(prof, content_desc="Add Profile")) ok = reached and surface_changed(before, after) and len(cards) >= 4 and add_fab record("structure_dashboard_to_profiles", bool(ok), "" if ok else ("feature_missing: Manage Profiles screen not reached / no " "profile-card grid + Add Profile FAB"), depth=1, jump_kind="transition", expect="Dashboard goal card -> Manage Profiles grid (>=4 duration cards) " "+ Add Profile FAB") # VLM: the profiles are rendered as a grid of cards. vlm_assert("structure_profiles_grid", "Under the 'Other Profiles' heading, are multiple fasting-profile " "cards arranged in a two-column grid? Answer YES or NO.", RESULTS_DIR, tag="position", depth=1, jump_kind="transition") @and_test(expects=("structure_add_profile_dialog", "structure_add_profile_dialog_vlm")) def test_add_profile_dialog_shape(): open_main_clear() dash = ui() reached = and_reach_screen(dash, trigger_text="Manage Profiles", target="Other Profiles", source="Set your goal") prof = ui() n_edit_before = len(find_by_class(prof, "EditText")) # Open the Add Profile dialog (a new window layer over Manage Profiles). depth=2. opened = and_enter_dialog(prof, trigger_desc="Add Profile") dlg = ui() # SHAPE delta of the dialog layer: 3 EditText fields + 1 CheckBox appear. n_edit = len(find_by_class(dlg, "EditText")) n_check = len(find_by_class(dlg, "CheckBox")) has_labels = all(find_node(dlg, text=t) for t in ("Add Profile", "Cancel", "Save")) grew = (n_edit_before == 0 and n_edit == 3 and n_check == 1 and has_labels) # VLM WHILE THE DIALOG IS OPEN (must precede the Cancel that reverses it). vlm_assert("structure_add_profile_dialog", "Is there a rounded rectangular dialog card overlaid on the screen " "that contains three empty text input boxes stacked vertically with a " "'Cancel' and 'Save' button below them? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=2, jump_kind="transition") # reverse: Cancel dismisses the dialog -> EditTexts gone, grid back. cancel = find_node(dlg, text="Cancel") if cancel: tap_node(cancel) back_nodes = ui() restored = (len(find_by_class(back_nodes, "EditText")) == 0 and bool(find_node(back_nodes, content_desc="Add Profile"))) ok = reached and opened and grew and restored record("structure_add_profile_dialog", bool(ok), "" if ok else ("behavior_wrong: Add Profile dialog did not add 3 " "EditText fields + a checkbox" if not grew else "behavior_wrong: Cancel did not dismiss the dialog"), depth=2, jump_kind="transition", expect="EditText 0->3 + 1 CheckBox on dialog open, restored on Cancel") @and_test(expects=("structure_settings_rows", "structure_settings_toggles_vlm")) def test_settings_row_shape(): open_main_clear() dash = ui() before = and_showing(dash) reached = and_reach_screen(dash, trigger_desc="Settings", target="Appearance", source="Set your goal") st = ui() after = and_showing(st) # SHAPE: a real Settings column has MANY distinct section/row labels; a stub # would not. Require at least 6 of the known section/row labels to be present. labels = ["Appearance", "Color Scheme", "First Day of Week", "Show Floating Action Button", "Use Expressive Progress Indicator", "Show Fasting Phases", "Notifications", "Show live progress notification", "Goal reached notification"] found = [x for x in labels if find_node_ci(st, x)] ok = reached and surface_changed(before, after) and len(found) >= 6 record("structure_settings_rows", bool(ok), "" if ok else (f"feature_missing: Settings has only {len(found)} of the " f"expected section/row labels ({found})"), depth=1, jump_kind="transition", expect="Settings column shows >=6 distinct section/row labels") # VLM: the toggle rows render as pill switches on the right of their labels. vlm_assert("structure_settings_toggles", "Does the Settings screen show setting rows with pill-shaped toggle " "switches aligned to the right side of the rows? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=1, jump_kind="transition") @and_test(expects=("structure_settings_scroll_reveal",)) def test_settings_scroll_reveal(): open_main_clear() dash = ui() reached = and_reach_screen(dash, trigger_desc="Settings", target="Appearance", source="Set your goal") top = ui() # A real Settings screen is a scrollable column: the "Export Data" / "Import # Data" Data-Management buttons sit BELOW the fold, so they are absent from the # first dump and a scroll REVEALS them (a scroll-driven shape change of what is # on screen). Also assert the column is wrapped in a ScrollView (a stub with a # fixed Column would not scroll). scroll_into_view re-dumps between swipes. scrollable = bool(find_by_class(top, "ScrollView")) export_top = find_node_ci(top, "Export Data") revealed = scroll_into_view("Export Data", max_swipes=6) import_after = find_node_ci(ui(), "Import Data") ok = (reached and scrollable and (export_top is None) and bool(revealed) and bool(import_after)) record("structure_settings_scroll_reveal", bool(ok), "" if ok else ("behavior_wrong: 'Export Data'/'Import Data' not revealed " "by scrolling the Settings column" if export_top is None else "behavior_wrong: 'Export Data' was already visible at " "the top (no scroll delta)"), depth=1, jump_kind="transition", expect="ScrollView column; 'Export Data' hidden at top, revealed on scroll") @and_test(expects=("structure_statistics_containers", "structure_stats_cards_vlm", "structure_stats_chart_vlm")) def test_statistics_containers_shape(): open_main_clear() dash = ui() before = and_showing(dash) reached = and_reach_screen(dash, trigger_desc="Go to Statistics", target="Trends", source="Set your goal") st = ui() after = and_showing(st) # SHAPE: the expected SET of statistics containers exists — the three stat cards, # the "Trends" block, and the segmented toggles (RadioButton group, >=3 options). stat_cards = [t for t in ("Total Fasts", "Average Fast", "Consistency") if find_node(st, text=t)] trends = bool(find_node(st, text="Trends")) radios = find_by_class(st, "RadioButton") ok = (reached and surface_changed(before, after) and len(stat_cards) == 3 and trends and len(radios) >= 3) record("structure_statistics_containers", bool(ok), "" if ok else ("feature_missing: Statistics screen missing expected " f"containers (cards={stat_cards}, trends={trends}, " f"radios={len(radios)})"), depth=1, jump_kind="transition", expect="3 stat cards + 'Trends' + a >=3-option segmented toggle present") # VLM: the three Material-3-Expressive stat cards have distinctive non-rectangular # shapes (pentagon / blob / scalloped). vlm_assert("structure_stats_cards", "Are the three statistics cards ('Total Fasts', 'Average Fast', " "'Consistency') drawn as non-rectangular blob/pentagon/scalloped " "shapes rather than plain rectangles? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=1, jump_kind="transition") # VLM: a horizontal bar chart is rendered above the day/date axis. vlm_assert("structure_stats_chart", "Is there a horizontal row of bar-chart segments drawn above a row of " "single-letter day-of-week axis labels? Answer YES or NO.", RESULTS_DIR, tag="shape", depth=1, jump_kind="transition") @and_test(expects=("structure_statistics_expand",)) def test_statistics_expand_shape(): open_main_clear() dash = ui() reached = and_reach_screen(dash, trigger_desc="Go to Statistics", target="Trends", source="Set your goal") st = ui() before = and_showing(st) n_before = len(st) # The "All-time statistics" Expand chevron GROWS the tree (adds a Total Duration # row + a Collapse control). Locate the expand affordance and toggle it. exp = find_node(st, content_desc="Expand") if exp is None: # fall back to the row label if the chevron desc differs exp = find_node(st, text="All-time statistics") grew = restored = False if exp is not None: tap_node(exp) st2 = ui() after = and_showing(st2) added = after - before grew = (len(st2) > n_before and (any("Collapse" in k for k in added) or any("Total Duration" in k for k in added))) # reverse: collapse it back coll = (find_node(st2, content_desc="Collapse") or find_node(st2, content_desc="Expand")) if coll: tap_node(coll) st3 = ui() restored = (not find_node(st3, content_desc="Collapse")) ok = reached and grew and restored record("structure_statistics_expand", bool(ok), "" if ok else ("behavior_wrong: 'All-time statistics' expand did not grow " "the tree" if not grew else "behavior_wrong: expanded section did not collapse back"), depth=1, jump_kind="transition", expect="All-time statistics expand adds Total Duration/Collapse, " "restored on collapse") @and_test(expects=("structure_history_calendar", "structure_history_grid_vlm", "structure_history_summary_vlm")) def test_history_calendar_shape(): open_main_clear() dash = ui() before = and_showing(dash) reached = and_reach_screen(dash, trigger_desc="Go to History", target="August 2026", source="Set your goal") hist = ui() after = and_showing(hist) # SHAPE: a real month calendar has a large number of numeric day cells. Count # distinct day numbers 1..31; a stub would not render a full grid. days = set() for n in hist: t = n.get("text", "").strip() if t.isdigit() and 1 <= int(t) <= 31: days.add(int(t)) month_hdr = bool(find_node(hist, text="August 2026")) nav = (bool(find_node(hist, content_desc="Previous Month")) and bool(find_node(hist, content_desc="Next Month"))) ok = (reached and surface_changed(before, after) and len(days) >= 28 and month_hdr and nav) record("structure_history_calendar", bool(ok), "" if ok else (f"feature_missing: History calendar incomplete " f"(distinct day cells={len(days)}, header={month_hdr}, " f"month-nav={nav})"), depth=1, jump_kind="transition", expect=">=28 distinct day cells + month header + prev/next month nav") # VLM: the days form a month grid with a weekday header row. vlm_assert("structure_history_grid", "Is there a monthly calendar laid out as a grid of numbered day cells " "in seven columns, with a row of weekday letters above it? " "Answer YES or NO.", RESULTS_DIR, tag="position", depth=1, jump_kind="transition") # VLM: the 'August Summary' shows three distinctly-shaped stat cards. vlm_assert("structure_history_summary", "Below the calendar, does the 'August Summary' section show three " "non-rectangular stat cards positioned side by side in one row? " "Answer YES or NO.", RESULTS_DIR, tag="shape", depth=1, jump_kind="transition") # ═══════════════════════════════════════════════════════════════════════════════ TESTS = [ test_gate_launch, test_gate_dashboard_surfaces, test_gate_goal_grid, test_fab_speeddial_expand, test_active_fast_shape, test_dashboard_to_profiles_shape, test_add_profile_dialog_shape, test_settings_row_shape, test_settings_scroll_reveal, test_statistics_containers_shape, test_statistics_expand_shape, test_history_calendar_shape, ] if __name__ == "__main__": if not device_online(): print("setup_failed: device offline / adb tunnel down — aborting") sys.exit(2) run_suite(TESTS, "structure")