#!/usr/bin/env python3 """STRUCTURE lane for NextPlayer (dev.anilbeesetti.nextplayer.debug). This lane owns exactly two things: (1) the LAUNCH GATE — the app comes up, Home shows its top-level surfaces (three top-bar icon controls by content-desc + the media list); jump_kind "none", kept to a single case. (2) tree-SHAPE deltas — an interaction changes the view-tree's SHAPE (child count / arrangement / a new window layer), asserted by counting a widget class or a marker-string set BEFORE and AFTER the user path, then reversed to prove it restores. jump_kind "transition". Compose a11y does NOT expose toggle/selection state on this app (every Switch / segment / chip reports checked=false selected=false regardless of visual state), so this file NEVER asserts checked/selected — it asserts SHAPE (counts) or hands the rendered-layout question to the VLM. IMPORTANT — the picker VIEW MODE (Folders/Videos/Tree) and LAYOUT (List/Grid) are PERSISTED preferences that survive force-stop, so a test that switches to Videos leaves the app in Videos on the next launch. Every test therefore normalizes the picker back to Folders + List in home_ready() before it asserts, and tests that mutate the mode restore it. This is what keeps the cases independent. Ground truth (observed on the running original, see recon.md + recon_shots/): * Home top bar: 3 clickable Views whose child carries content-desc "Search" / "Menu" / "Settings"; body is a list; a desc-less FAB View bottom-right. * Every media/list/settings ROW carries a RadioButton child, so a RadioButton COUNT is a robust row count: Home Folders view = 1 (the "Download" folder), folder contents / Videos view = 3 (alpha/beta/gamma), Settings root = 9. * FAB expands to 3 pill labels: "Open network stream" / "Open local video" / "Recently played" (0 -> 3), and an X collapses them (3 -> 0). * Menu opens a "Quick Settings" bottom sheet whose distinctive section headers are {"Quick Settings","Media view mode","Media Layout","Sort","Fields"} plus a "Done"/"Cancel" row (0 markers on Home -> 5 in the sheet). * A video row opens PlayerActivity (landscape): picker markers ("Download" title / "3 Videos") vanish, player marker content-desc "Play/Pause" appears. * Search shows a "Popular folders" header (empty query); typing "beta" replaces it with a "Videos (1)" result section (header shape change). Fixtures: the 3 sample videos (alpha_clip.mp4 / beta_movie.mp4 / gamma_reel.mp4) are authored into fixtures/ and mirrored to the device by push_fixtures(); every test reaches them through fixture_on_device(name), never a hand-pushed path. """ 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) # ── Ground-truth marker sets (strings observed on the running original) ───────── TOPBAR_DESCS = ("Search", "Menu", "Settings") FAB_PILLS = ("Open network stream", "Open local video", "Recently played") QS_MARKERS = ("Quick Settings", "Media view mode", "Media Layout", "Sort", "Fields") SETTINGS_ROWS = 9 # Appearance ... About PLAYER_MARKER = "Play/Pause" # content-desc that only exists in the player PICKER_TITLE = "Next Player Debug" FOLDER_NAME = "Download" VIDEO_TITLES = ("alpha_clip", "beta_movie", "gamma_reel") # The fixture videos the picker opens; declared via fixture_on_device so the # dependency is explicit and the kit pushes the bytes on a fresh emulator. FIXTURE_VIDEOS = ("alpha_clip.mp4", "beta_movie.mp4", "gamma_reel.mp4") # ══════════════════════════════════════════════════════════════════════════════ # Helpers (setup / navigation). Navigation helpers are named and_enter_* so an # and_enter() call backs every declared depth>=1 (see and_audit_depth). # ══════════════════════════════════════════════════════════════════════════════ def and_grant_media(): """Tap the runtime media-permission 'Allow all' if it is showing (no-op otherwise). restart_app() keeps the grant, so this is just a safety net.""" for label in ("Allow all", "While using the app", "Allow"): n = find_node_ci(ui(), label) if n: tap_node(n) settle("tap") return True return False def tap_topbar(nodes, desc): """Tap the top-bar icon by content-desc. The desc node itself is not clickable — its PARENT View is — so tap the nearest clickable ancestor by bounds containment, falling back to the desc node's centre.""" target = find_node(nodes, content_desc=desc) if not target or "_bounds" not in target: return False tcx, tcy = target["_center"] best = None best_area = None for n in nodes: if n.get("clickable") != "true" or "_bounds" not in n: continue x1, y1, x2, y2 = n["_bounds"] if x1 <= tcx <= x2 and y1 <= tcy <= y2: # contains the icon centre area = (x2 - x1) * (y2 - y1) if best_area is None or area < best_area: # tightest clickable wrapper best, best_area = n, area return tap_node(best) if best else tap_node(target) def open_quick_settings(nodes): """Tap Menu; returns fresh nodes once the Quick Settings sheet is up.""" tap_topbar(nodes, "Menu") settle("tap") return ui() def in_folders_mode(nodes): """Home is in the default Folders view iff the 'Download' folder row shows and the flat video titles do not.""" return bool(find_node(nodes, text=FOLDER_NAME)) and not any( find_node(nodes, text=t) for t in VIDEO_TITLES) def reset_view_mode(nodes): """Normalize the picker to Folders + List (the app's default), because those are PERSISTED across restart. Opens Quick Settings, selects Folders then List, taps Done. Returns fresh Home nodes.""" qs = open_quick_settings(nodes) if find_node(qs, text="Folders"): tap_text(qs, "Folders") settle("tap") if find_node(ui(), text="List"): tap_text(ui(), "List") settle("tap") tap_node(find_node(ui(), text="Done")) settle("tap") return ui() def _home_content_ready(nodes): """True once the Home picker has actually rendered (top-bar controls plus a folder row or the flat video titles), so we do not assert against a mid-load or launcher screen. wait_for_foreground() alone is too loose — it matches the package anywhere in the window dump even while backgrounded.""" topbar = all(find_node(nodes, content_desc=d) for d in TOPBAR_DESCS) body = bool(find_node(nodes, text=FOLDER_NAME)) or any( find_node(nodes, text=t) for t in VIDEO_TITLES) return topbar and body def home_ready(normalize=True): """Mirror the fixture videos, restart, grant media, WAIT until Home actually rendered; return fresh Home nodes in the DEFAULT Folders+List mode. push_fixtures() is idempotent (run_suite() also calls it once); doing it here keeps every test self-sufficient and makes the fixture dependency explicit — the files land at fixture_on_device('beta_movie.mp4') etc. A launch can be slow, so we poll for real content and retry the launch once; and because view mode PERSISTS across restart, we reset it to Folders unless a caller opts out.""" push_fixtures() _ = [fixture_on_device(v) for v in FIXTURE_VIDEOS] # explicit dependency nodes = [] for attempt in range(2): restart_app() if not wait_for_foreground(): continue and_grant_media() for _ in range(6): # poll for rendered Home nodes = ui() if _home_content_ready(nodes): break settle("dump") if _home_content_ready(nodes): break # launched cleanly if not nodes: return [] if normalize and not in_folders_mode(nodes): nodes = reset_view_mode(nodes) return nodes def count_rows(nodes): """Number of media/list rows == number of RadioButton children on this app.""" return len(find_by_class(nodes, "RadioButton")) def marker_count(nodes, markers): """How many of `markers` appear as an exact text/content-desc on screen.""" present = 0 for m in markers: if find_node(nodes, text=m) or find_node(nodes, content_desc=m): present += 1 return present def find_fab(nodes): """The bottom-right expand FAB: a desc-less, text-less clickable View in the lower-right quadrant. Derived from a fresh dump — never a hardcoded coord.""" s = get_screen_info() best = None for n in nodes: if n.get("clickable") != "true": continue if n.get("text", "").strip() or n.get("content-desc", "").strip(): continue b = n.get("_bounds") if not b: continue cx, cy = n["_center"] if cx < s["width"] * 0.6 or cy < s["height"] * 0.6: continue w, h = b[2] - b[0], b[3] - b[1] if w < 60 or h < 60 or w > s["width"] * 0.6: # a real FAB, not a big panel continue if best is None or (cy + cx) > (best["_center"][1] + best["_center"][0]): best = n return best def and_enter_settings(): """Home -> Settings. Proves the jump (Settings list appears) and counts one surface. Returns fresh Settings nodes or [].""" nodes = home_ready() before = and_showing(nodes) tap_topbar(nodes, "Settings") settle("tap") after_nodes = ui() after = and_showing(after_nodes) if and_reach(before, after, "Appearance", source=None) or \ find_node(after_nodes, text="Appearance"): and_enter("settings") return after_nodes return [] def and_enter_folder(name=FOLDER_NAME): """Home (Folders view) -> tap the named folder -> folder contents. Proves the jump ('Navigate up' present) and counts one surface. Returns fresh folder-contents nodes or [].""" nodes = home_ready() row = find_node(nodes, text=name) if not row: return [] before = and_showing(nodes) tap_node(row) settle("tap") after_nodes = ui() after = and_showing(after_nodes) if and_reach(before, after, "Navigate up", source=None) or \ find_node(after_nodes, content_desc="Navigate up"): and_enter("folder") return after_nodes return [] def dump_center(nodes): """Centre of the CURRENT display in the dump's own coordinate frame. The player is landscape but `wm size` still reports the physical portrait size, so get_screen_info() cannot be trusted there; the dump's root bounds are in the correct rotated frame (e.g. 2400x1080).""" maxx = max((b[2] for b in (n.get("_bounds") for n in nodes) if b), default=0) maxy = max((b[3] for b in (n.get("_bounds") for n in nodes) if b), default=0) return (maxx // 2, maxy // 2) if maxx and maxy else (0, 0) def reveal_player_controls(): """Tap the (rotated) screen centre until the auto-hiding player controls are up. Returns the fresh player nodes once 'Play/Pause' is present, else [].""" for _ in range(5): nodes = ui() if find_node(nodes, content_desc=PLAYER_MARKER): return nodes cx, cy = dump_center(nodes) if not cx: break tap(cx, cy) settle("tap") nodes = ui() return nodes if find_node(nodes, content_desc=PLAYER_MARKER) else [] def and_enter_player(title="beta_movie"): """Home -> folder -> tap a video row -> PlayerActivity. Proves the jump (player 'Play/Pause' appears), counts a second surface, and REVEALS the auto-hiding controls. Returns fresh player nodes or [].""" folder_nodes = and_enter_folder() if not folder_nodes: return [] row = find_node(folder_nodes, text=title) if not row: return [] before = and_showing(folder_nodes) tap_node(row) settle("launch") # PlayerActivity start + autoplay global _screen_info _screen_info = None # invalidate any cached (wrong) geometry player_nodes = reveal_player_controls() if player_nodes and ( and_reach(before, and_showing(player_nodes), PLAYER_MARKER, source=None) or find_node(player_nodes, content_desc=PLAYER_MARKER)): and_enter("player") return player_nodes return [] # ══════════════════════════════════════════════════════════════════════════════ # (1) GATE — the one allowed existence case. jump_kind="none", depth=0. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_gate_launch", "structure_gate_home_vlm")) def test_gate_launch(): nodes = home_ready() fg = wait_for_foreground() container = bool(find_by_class(nodes, "FrameLayout")) topbar = all(find_node(nodes, content_desc=d) for d in TOPBAR_DESCS) folder = bool(find_node(nodes, text=FOLDER_NAME)) ok = fg and container and topbar and folder msg = "" if not fg or not container: msg = "setup_failed: app did not reach the foreground" elif not topbar: msg = "feature_missing: Home top bar lacks Search/Menu/Settings controls" elif not folder: msg = "setup_failed: Download folder row not visible (fixtures not scanned?)" record("structure_gate_launch", ok, msg, depth=0, jump_kind="none") vlm_assert("structure_gate_home", "In the top app bar of this video app, are there exactly three " "icon buttons (a magnifier, a grid/menu icon, and a gear) on the " "right side, arranged in a single horizontal row?", RESULTS_DIR, depth=0, jump_kind="none", tag="position") # ══════════════════════════════════════════════════════════════════════════════ # (2) FAB expand — SHAPE delta: 0 -> 3 pill labels. transition, depth=1. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_fab_expand", "structure_fab_expand_vlm")) def test_fab_expand(): nodes = home_ready() before = marker_count(nodes, FAB_PILLS) # expect 0 fab = find_fab(nodes) tapped = tap_node(fab) if fab else False settle("tap") after_nodes = ui() and_enter("fab_menu") # backs depth=1 after = marker_count(after_nodes, FAB_PILLS) # expect 3 ok = tapped and before == 0 and after == len(FAB_PILLS) msg = "" if not tapped: msg = "setup_failed: FAB not found / not tappable" elif after != len(FAB_PILLS): msg = (f"behavior_wrong: FAB action pills {before}->{after}, " f"expected 0->{len(FAB_PILLS)}") record("structure_fab_expand", ok, msg, depth=1, jump_kind="transition", expect=f"FAB action-pill labels {before}->{len(FAB_PILLS)} on expand") vlm_assert("structure_fab_expand", "Are there exactly three rounded pill-shaped buttons stacked " "vertically near the bottom-right (labelled about network stream, " "local video, and recently played), each with a leading icon?", RESULTS_DIR, depth=1, jump_kind="transition", tag="shape") # ══════════════════════════════════════════════════════════════════════════════ # (3) FAB collapse — reverse of (2): 3 pills -> 0. transition, depth=1. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_fab_collapse",)) def test_fab_collapse(): nodes = home_ready() fab = find_fab(nodes) tap_node(fab) settle("tap") expanded = ui() and_enter("fab_menu") n_open = marker_count(expanded, FAB_PILLS) # expect 3 close = find_fab(expanded) # the X close FAB tapped = tap_node(close) if close else False settle("tap") collapsed = ui() and_back() n_closed = marker_count(collapsed, FAB_PILLS) # expect 0 ok = tapped and n_open == len(FAB_PILLS) and n_closed == 0 msg = "" if n_open != len(FAB_PILLS): msg = f"setup_failed: FAB did not expand ({n_open} pills)" elif n_closed != 0: msg = (f"behavior_wrong: pills did not collapse " f"({n_open}->{n_closed}, expected {len(FAB_PILLS)}->0)") record("structure_fab_collapse", ok, msg, depth=1, jump_kind="transition", expect=f"FAB pills {len(FAB_PILLS)}->0 on close (X)") # ══════════════════════════════════════════════════════════════════════════════ # (4) View mode Folders -> Videos — SHAPE delta: 1 folder row -> 3 video rows. # transition, depth=1. Tapping 'Done' dismisses the sheet (no extra BACK). # Restored to Folders at the end so the next test starts clean. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_viewmode_folders_to_videos", "structure_viewmode_folders_to_videos_vlm")) def test_viewmode_folders_to_videos(): nodes = home_ready() rows_folders = count_rows(nodes) # expect 1 (Download) qs = open_quick_settings(nodes) and_enter("quick_settings") ok_seg = tap_text(qs, "Videos") settle("tap") tap_node(find_node(ui(), text="Done")) # Done closes the sheet settle("tap") videos_nodes = ui() rows_videos = count_rows(videos_nodes) # expect 3 (flat list) files_present = sum(bool(find_node(videos_nodes, text=t)) for t in VIDEO_TITLES) folder_gone = not find_node(videos_nodes, text=FOLDER_NAME) ok = (ok_seg and rows_folders == 1 and rows_videos == 3 and files_present == 3 and folder_gone) msg = "" if not ok_seg: msg = "setup_failed: 'Videos' segment not found in Quick Settings" elif rows_videos != 3: msg = (f"behavior_wrong: rows {rows_folders}->{rows_videos}, " f"expected 1 folder -> 3 videos") elif files_present != 3: msg = f"behavior_wrong: only {files_present}/3 video titles after switch" elif not folder_gone: msg = "behavior_wrong: folder row still present in Videos mode" record("structure_viewmode_folders_to_videos", ok, msg, depth=1, jump_kind="transition", expect="RadioButton rows 1(folder)->3(videos); alpha/beta/gamma shown") # VLM before restoring, so the screenshot shows the 3-video list. vlm_assert("structure_viewmode_folders_to_videos", "Is this a single-column vertical list of exactly three video " "items with red, blue and green thumbnails (top to bottom), " "rather than one folder entry?", RESULTS_DIR, depth=1, jump_kind="transition", tag="color") reset_view_mode(videos_nodes) # restore Folders+List # ══════════════════════════════════════════════════════════════════════════════ # (5) Media Layout List -> Grid — a RENDERED layout change. Rule track asserts # the surface materially changed; the grid-vs-list judgement is VLM. # transition, depth=1. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_layout_grid", "structure_layout_grid_vlm")) def test_layout_grid(): nodes = home_ready() # Switch to Videos first (several items) so a grid is visible, capture the # list surface, then switch to Grid — both in one Quick Settings visit. qs = open_quick_settings(nodes) and_enter("quick_settings") tap_text(qs, "Videos") settle("tap") tap_node(find_node(ui(), text="Done")) settle("tap") list_nodes = ui() before = and_showing(list_nodes) qs2 = open_quick_settings(list_nodes) grid = find_node(qs2, text="Grid") ok_grid = tap_node(grid) if grid else False settle("tap") tap_node(find_node(ui(), text="Done")) settle("tap") after_nodes = ui() after = and_showing(after_nodes) changed = surface_changed(before, after, min_delta=2) titles = sum(bool(find_node(after_nodes, text=t)) for t in VIDEO_TITLES) ok = ok_grid and (changed or titles >= 2) msg = "" if not ok_grid: msg = "setup_failed: 'Grid' segment not found in Quick Settings" elif not (changed or titles >= 2): msg = "behavior_wrong: picker did not re-render after selecting Grid" record("structure_layout_grid", ok, msg, depth=1, jump_kind="transition", expect="picker re-renders (List->Grid) with the 3 videos preserved") vlm_assert("structure_layout_grid", "Are the video thumbnails arranged in a multi-column grid with at " "least two thumbnails positioned SIDE BY SIDE in the same row, " "rather than stacked one-per-row?", RESULTS_DIR, depth=1, jump_kind="transition", tag="position") reset_view_mode(after_nodes) # restore Folders+List # ══════════════════════════════════════════════════════════════════════════════ # (6) Enter Player — SHAPE: picker tree replaced by player tree. transition, # depth=2 (Home -> folder -> player), backed by and_enter_player(). # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_enter_player", "structure_enter_player_vlm")) def test_enter_player(): folder_nodes = and_enter_folder() picker_had_marker = bool(find_node(folder_nodes, content_desc="Navigate up") or find_node(folder_nodes, text="3 Videos") or any(find_node(folder_nodes, text=t) for t in VIDEO_TITLES)) player_nodes = and_enter_player("beta_movie") has_player = bool(player_nodes and find_node(player_nodes, content_desc=PLAYER_MARKER)) # picker markers must be GONE from the player tree (the tree was REPLACED) picker_gone = not (find_node(player_nodes, text=FOLDER_NAME) or find_node(player_nodes, text="3 Videos")) ok = picker_had_marker and has_player and picker_gone msg = "" if not has_player: msg = "feature_missing: player controls (Play/Pause) not present after tap" elif not picker_gone: msg = "behavior_wrong: picker markers still present in the player tree" record("structure_enter_player", ok, msg, depth=2, jump_kind="transition", expect="picker tree (Download/3 Videos) replaced by player (Play/Pause control)") vlm_assert("structure_enter_player", "In this landscape video player, is there a play/pause control in " "the CENTRE of the screen and a horizontal seek bar near the " "BOTTOM edge?", RESULTS_DIR, depth=2, jump_kind="transition", tag="position") # ══════════════════════════════════════════════════════════════════════════════ # (7) Quick Settings sheet — SHAPE: a new window layer with a distinctive # multi-section child set appears over Home. transition, depth=1. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_quicksettings_sheet", "structure_quicksettings_sheet_vlm")) def test_quicksettings_sheet(): nodes = home_ready() before = marker_count(nodes, QS_MARKERS) # expect 0 on Home qs = open_quick_settings(nodes) and_enter("quick_settings") after = marker_count(qs, QS_MARKERS) # expect 5 in the sheet has_actions = bool(find_node(qs, text="Done") and find_node(qs, text="Cancel")) ok = before == 0 and after == len(QS_MARKERS) and has_actions msg = "" if after != len(QS_MARKERS): msg = (f"behavior_wrong: Quick Settings section markers {before}->{after}, " f"expected 0->{len(QS_MARKERS)}") elif not has_actions: msg = "behavior_wrong: sheet lacks the Done/Cancel action row" record("structure_quicksettings_sheet", ok, msg, depth=1, jump_kind="transition", expect="0->5 sheet section headers + Done/Cancel row appear over Home") vlm_assert("structure_quicksettings_sheet", "In this 'Quick Settings' bottom sheet, are the 'Cancel' and " "'Done' text buttons positioned at the BOTTOM of the sheet, with " "'Done' to the right of 'Cancel'?", RESULTS_DIR, depth=1, jump_kind="transition", tag="position") # ══════════════════════════════════════════════════════════════════════════════ # (8) Settings list — SHAPE: a scrollable list of exactly 9 category rows. # transition, depth=1, backed by and_enter_settings(). # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_settings_list", "structure_settings_list_vlm")) def test_settings_list(): settings_nodes = and_enter_settings() reached = bool(settings_nodes) rows = count_rows(settings_nodes) # expect 9 ok = reached and rows == SETTINGS_ROWS msg = "" if not reached: msg = "setup_failed: Settings screen not reached" elif rows != SETTINGS_ROWS: msg = (f"behavior_wrong: Settings category rows = {rows}, " f"expected {SETTINGS_ROWS}") record("structure_settings_list", ok, msg, depth=1, jump_kind="transition", expect=f"Settings root is a {SETTINGS_ROWS}-row category list") vlm_assert("structure_settings_list", "Is this a vertical, single-column list of setting category rows " "(each row a leading icon plus a title and a smaller subtitle " "beneath it), with roughly nine such rows?", RESULTS_DIR, depth=1, jump_kind="transition", tag="layout") # ══════════════════════════════════════════════════════════════════════════════ # (9) Folder drill-down — SHAPE: 1 folder row -> 3 video rows, and a 'Navigate # up' control appears. transition, depth=1, backed by and_enter_folder(). # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_folder_drilldown",)) def test_folder_drilldown(): home_nodes = home_ready() rows_home = count_rows(home_nodes) # expect 1 (Download) up_before = bool(find_node(home_nodes, content_desc="Navigate up")) # False folder_nodes = and_enter_folder() reached = bool(folder_nodes) rows_folder = count_rows(folder_nodes) # expect 3 videos up_after = bool(find_node(folder_nodes, content_desc="Navigate up")) # True ok = (reached and rows_home == 1 and rows_folder == 3 and not up_before and up_after) msg = "" if not reached: msg = "setup_failed: folder contents not reached" elif rows_folder != 3: msg = (f"behavior_wrong: rows {rows_home}(home)->{rows_folder}(folder), " f"expected 1->3") elif not up_after: msg = "behavior_wrong: 'Navigate up' control not added inside the folder" record("structure_folder_drilldown", ok, msg, depth=1, jump_kind="transition", expect="rows 1->3 and a 'Navigate up' back control appears") # ══════════════════════════════════════════════════════════════════════════════ # (10) Search screen SHAPE — 'Popular folders' section (empty query) is replaced # by a filtered result section when a query is typed. transition, depth=1. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("structure_search_shape", "structure_search_shape_vlm")) def test_search_shape(): nodes = home_ready() tap_topbar(nodes, "Search") settle("tap") search_nodes = ui() and_enter("search") popular = bool(find_node(search_nodes, text="Popular folders")) edit = find_by_class(search_nodes, "EditText") typed = type_text(edit[0], "beta") if edit else False settle("text") results = ui() popular_gone = not find_node(results, text="Popular folders") result_header = bool(find_node(results, text="Videos (1)")) beta_row = bool(find_node(results, text="beta_movie")) ok = popular and typed and popular_gone and (result_header or beta_row) msg = "" if not popular: msg = "setup_failed: 'Popular folders' section not shown on empty search" elif not typed: msg = "setup_failed: could not type into the search field" elif not (result_header or beta_row): msg = "behavior_wrong: query 'beta' did not produce a filtered result section" elif not popular_gone: msg = "behavior_wrong: 'Popular folders' still present after a query" record("structure_search_shape", ok, msg, depth=1, jump_kind="transition", expect="'Popular folders' section -> 'Videos (1)' result row on typing 'beta'") vlm_assert("structure_search_shape", "Below a search box containing the text 'beta', is there a section " "header reading 'Videos (1)' with exactly one video result row " "beneath it?", RESULTS_DIR, depth=1, jump_kind="transition", tag="content") # ══════════════════════════════════════════════════════════════════════════════ # (11) Network Stream dialog — SHAPE delta: FAB -> "Open network stream" adds a # NEW dialog window layer over Home (title + URL label + an EditText + a # Done/Cancel row). Home has 0 EditText; the dialog adds exactly 1 plus 4 # marker strings. Cancel removes the layer and restores Home. transition, # depth=2 (Home -> FAB menu -> dialog), backed by two and_enter() calls. # Chosen for depth-2 over an in-player delta because it has no video clip to # race. # ══════════════════════════════════════════════════════════════════════════════ NET_DIALOG_MARKERS = ("Network Stream", "Enter a network URL:", "Done", "Cancel") @and_test(expects=("structure_network_stream_dialog",)) def test_network_stream_dialog(): nodes = home_ready() edits_home = len(find_by_class(nodes, "EditText")) # expect 0 on Home fab = find_fab(nodes) if not tap_node(fab): record("structure_network_stream_dialog", False, "setup_failed: FAB not found / not tappable", depth=2, jump_kind="transition", expect="Network Stream dialog adds an EditText + 4 markers over Home") return settle("tap") menu = ui() and_enter("fab_menu") # surface 1: FAB menu if not tap_text(menu, "Open network stream"): record("structure_network_stream_dialog", False, "feature_missing: 'Open network stream' action not present", depth=2, jump_kind="transition", expect="Network Stream dialog adds an EditText + 4 markers over Home") return settle("tap") dlg = ui() and_enter("network_dialog") # surface 2: the dialog markers = marker_count(dlg, NET_DIALOG_MARKERS) # expect 4 edits_dlg = len(find_by_class(dlg, "EditText")) # expect 1 # reverse: Cancel removes the dialog layer and restores Home tap_text(dlg, "Cancel") settle("tap") restored = ui() dialog_gone = not find_node(restored, text="Network Stream") home_back = bool(find_node(restored, text=FOLDER_NAME)) ok = (edits_home == 0 and markers == len(NET_DIALOG_MARKERS) and edits_dlg == 1 and dialog_gone and home_back) msg = "" if markers != len(NET_DIALOG_MARKERS): msg = (f"behavior_wrong: dialog markers {markers}/" f"{len(NET_DIALOG_MARKERS)} present") elif edits_dlg != 1 or edits_home != 0: msg = (f"behavior_wrong: EditText count home={edits_home} dialog={edits_dlg}, " f"expected 0->1") elif not dialog_gone: msg = "behavior_wrong: dialog layer not removed after Cancel" elif not home_back: msg = "behavior_wrong: Home not restored after Cancel" record("structure_network_stream_dialog", ok, msg, depth=2, jump_kind="transition", expect="dialog adds 1 EditText + 4 markers over Home; Cancel restores Home") TESTS = [ test_gate_launch, test_fab_expand, test_fab_collapse, test_viewmode_folders_to_videos, test_layout_grid, test_enter_player, test_quicksettings_sheet, test_settings_list, test_folder_drilldown, test_search_shape, test_network_stream_dialog, ] if __name__ == "__main__": run_suite(TESTS, "structure")