Datasets:
Download android/anilbeesetti-nextplayer/tests/test_android_structure.py from Qwen/RecreationBench: direct link, hf CLI and curl.
- Browser
- Download file 36.4 kB
-
https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/anilbeesetti-nextplayer/tests/test_android_structure.py
- Command line
-
hf download hf://datasets/Qwen/RecreationBench/android/anilbeesetti-nextplayer/tests/test_android_structure.py
-
curl -L -o test_android_structure.py https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/anilbeesetti-nextplayer/tests/test_android_structure.py
36.4 kB
| #!/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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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(). | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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(). | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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(). | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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") | |
| 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") | |