Datasets:
Download android/anilbeesetti-nextplayer/tests/test_android_text.py from Qwen/RecreationBench: direct link, hf CLI and curl.
- Browser
- Download file 40.6 kB
-
https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/anilbeesetti-nextplayer/tests/test_android_text.py
- Command line
-
hf download hf://datasets/Qwen/RecreationBench/android/anilbeesetti-nextplayer/tests/test_android_text.py
-
curl -L -o test_android_text.py https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/anilbeesetti-nextplayer/tests/test_android_text.py
40.6 kB
| #!/usr/bin/env python3 | |
| """TEXT lane for NextPlayer (dev.anilbeesetti.nextplayer.debug). | |
| This lane owns CONTENT / OUTPUT strings that a user action PRODUCES, and it is | |
| the sole owner of exact-string equality. Every test performs an interaction and | |
| then reads the resulting string out of a FRESH ui() and asserts it matches what | |
| the original renders. The discriminating half is the CHANGE: the string is | |
| ABSENT before the trigger and PRESENT after — a hardcoded label present at launch | |
| would pass on a dead shell, so the dynamic ones are asserted absent-then-present. | |
| Ground truth (observed live on the running original before authoring): | |
| * Home folder row: name "Download", count chip "3 Videos", parent path | |
| "/storage/emulated/0" (folder-level). Title bar "Next Player Debug". | |
| * Inside the Download folder every video row shows the FULL path | |
| "/storage/emulated/0/Download"; titles have NO extension (alpha_clip, | |
| beta_movie, gamma_reel); folder title bar reads "Download". | |
| * Search (top-bar "Search"): typing "beta" -> header EXACTLY "Videos (1)" and a | |
| result row "beta_movie"; "gamma" -> "Videos (1)" + "gamma_reel"; "movie" -> | |
| "Videos (1)" + "beta_movie"; "zzznope" -> the empty-state "No results found" | |
| (NO "Videos (N)" header at all). | |
| * PlayerActivity title bar shows the filename WITH extension: "beta_movie.mp4" | |
| / "gamma_reel.mp4" / "alpha_clip.mp4". The Loop button content-desc is one of | |
| "Loop: Off"/"Loop: One"/"Loop: All" and advances Off->One->All->Off on tap | |
| (the setting PERSISTS across restarts, so we read the CURRENT desc and assert | |
| the NEXT one, never a fixed start value). | |
| * Settings > Player: row "Controller timeout" subtitle "4 seconds"; row | |
| "Default playback speed" subtitle "1.0". Settings > Appearance: row | |
| "Dark theme" subtitle "System Default". Settings > About: "by anilbeesetti", | |
| "Libraries", "Github", "UPI" + "anilbeesetti10@oksbi". (The version number | |
| "0.16.3 (56)" is a BUILD CONSTANT and is deliberately NOT asserted.) | |
| * FAB -> "Open network stream" opens the "Network Stream" dialog with label | |
| "Enter a network URL:" and a placeholder text "http://example.com/example.mp4" | |
| (rendered as its own TextView; the EditText's own text is empty). Typing into | |
| the field reads back from a fresh dump; we dismiss with "Cancel" (NOT BACK, | |
| which would close the whole dialog). | |
| CEDES (per lane contract): a computed/derived number -> computation (the folder | |
| "00:16" total, the search COUNT as a number); a checked bit -> states; whether a | |
| label's screen is reachable -> navigation (a label tapped to navigate is nav's | |
| trigger, not our assertion); a widget class present -> structure; the content of | |
| a record the user created -> interaction. Here we assert only the exact WORDS an | |
| interaction produced. | |
| Fixtures: the 3 sample videos are authored into fixtures/ and mirrored to the | |
| device by push_fixtures() (run_suite() calls it once); reached through | |
| fixture_on_device(name), never a hand-pushed path. | |
| """ | |
| import os | |
| import sys | |
| import time | |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) | |
| from android_testgen_kit import * # noqa: F403,E402 | |
| import android_testgen_kit as kit # noqa: E402 (for the geometry cache) | |
| require_kit(1) | |
| # ── Ground-truth strings (observed on the running original) ───────────────────── | |
| FOLDER_NAME = "Download" | |
| FOLDER_COUNT = "3 Videos" # Home-only count chip | |
| FOLDER_PATH = "/storage/emulated/0/Download" # shown on each video row INSIDE | |
| NAV_UP = "Navigate up" | |
| PLAYER_MARKER = "Play/Pause" # content-desc unique to the player | |
| POPULAR = "Popular folders" # Search screen section | |
| SEARCH_EMPTY = "No results found" # zero-match empty state | |
| LOOP_DESCS = ("Loop: Off", "Loop: One", "Loop: All") | |
| SETTINGS_SIBLING = "Media library" # a Settings-root row, gone on subs | |
| # 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") | |
| def next_loop(cur): | |
| """The desc that a Loop tap should produce next (Off->One->All->Off).""" | |
| if cur in LOOP_DESCS: | |
| return LOOP_DESCS[(LOOP_DESCS.index(cur) + 1) % len(LOOP_DESCS)] | |
| return None | |
| def all_text(nodes): | |
| """All non-empty visible text, joined — a cheap 'does this string appear'.""" | |
| return " | ".join(n.get("text", "") for n in nodes if n.get("text", "").strip()) | |
| def has_text(nodes, s): | |
| """Exact-match on any node's text attribute (this lane's specialty).""" | |
| return any(n.get("text", "").strip() == s for n in nodes) | |
| def sub_of(nodes, label): | |
| """The subtitle string that renders directly BELOW a settings row `label`. | |
| Settings rows are title-over-subtitle: the subtitle is the text node whose | |
| x overlaps the label's and whose top edge sits just below the label's. Return | |
| the closest such node's text, or "" if none.""" | |
| row = find_node(nodes, text=label) | |
| if not row or "_bounds" not in row: | |
| return "" | |
| lx1, ly1, lx2, ly2 = row["_bounds"] | |
| best, best_dy = "", 10 ** 9 | |
| for n in nodes: | |
| if n is row or not n.get("text", "").strip() or "_bounds" not in n: | |
| continue | |
| x1, y1, x2, y2 = n["_bounds"] | |
| # horizontal overlap with the label + starts below it | |
| if x2 <= lx1 or x1 >= lx2 or y1 < ly2 - 5: | |
| continue | |
| dy = y1 - ly2 | |
| if 0 <= dy < best_dy: | |
| best, best_dy = n.get("text", "").strip(), dy | |
| return best | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # Setup helpers | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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 a top-bar icon by content-desc. The desc node itself is not clickable | |
| — its wrapping View is — so tap the tightest clickable ancestor whose bounds | |
| contain the icon centre, falling back to the desc node.""" | |
| target = find_node(nodes, content_desc=desc) | |
| if not target or "_bounds" not in target: | |
| return False | |
| tcx, tcy = target["_center"] | |
| best, best_area = None, 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: | |
| area = (x2 - x1) * (y2 - y1) | |
| if best_area is None or area < best_area: | |
| best, best_area = n, area | |
| return tap_node(best) if best else tap_node(target) | |
| def _home_content_ready(nodes): | |
| """True once the Home picker rendered its top bar + folder row, so we never | |
| assert against a mid-load or launcher frame.""" | |
| topbar = all(find_node(nodes, content_desc=d) | |
| for d in ("Search", "Menu", "Settings")) | |
| body = bool(find_node(nodes, text=FOLDER_NAME)) or bool(find_node(nodes, text="beta_movie")) | |
| return topbar and body | |
| def _open_quick_settings(nodes): | |
| tap_topbar(nodes, "Menu") | |
| settle("tap") | |
| return ui() | |
| def _reset_view_mode(nodes): | |
| """Normalize the picker to the default Folders view (persisted prefs survive | |
| restart_app). Opens Quick Settings, selects Folders, taps Done.""" | |
| qs = _open_quick_settings(nodes) | |
| if find_node(qs, text="Folders"): | |
| tap_text(qs, "Folders") | |
| settle("tap") | |
| done = find_node(ui(), text="Done") | |
| if done: | |
| tap_node(done) | |
| settle("tap") | |
| return ui() | |
| def home_ready(): | |
| """Restart (keeps media grant), wait for the rendered Home, and guarantee the | |
| default Folders view so the 'Download' folder row exists. Returns Home nodes. | |
| push_fixtures() is idempotent (run_suite() also calls it); doing it here keeps | |
| each test self-sufficient and makes the fixture dependency explicit.""" | |
| 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): | |
| nodes = ui() | |
| if _home_content_ready(nodes): | |
| break | |
| settle("dump") | |
| if _home_content_ready(nodes): | |
| break | |
| if not nodes: | |
| return [] | |
| if not find_node(nodes, text=FOLDER_NAME): | |
| nodes = _reset_view_mode(nodes) | |
| return nodes | |
| # ── Depth-family reach helpers (named and_enter_*/and_reach_* so the depth audit | |
| # finds a backing call for every declared depth>=1). Each opens a surface and | |
| # increments the surface counter via and_enter(). ────────────────────────────── | |
| def and_reach_search(): | |
| """Home -> Search screen. Returns fresh search nodes (with the EditText) or [].""" | |
| nodes = home_ready() | |
| if not nodes: | |
| return [] | |
| tap_topbar(nodes, "Search") | |
| settle("tap") | |
| after = ui() | |
| if find_node(after, text=POPULAR) or find_by_class(after, "EditText"): | |
| and_enter("search") | |
| return after | |
| return [] | |
| def and_search_for(query): | |
| """Open Search, type `query`, and return the fresh result nodes (or []). | |
| The Search EditText auto-focuses; we still route through type_text so focus is | |
| verified. We do NOT press ENTER — results filter live as characters arrive.""" | |
| nodes = and_reach_search() | |
| if not nodes: | |
| return [] | |
| field = find_by_class(nodes, "EditText") | |
| if not field: | |
| return [] | |
| type_text(field[0], query) | |
| settle("keyboard") | |
| return ui() | |
| def and_enter_folder(name=FOLDER_NAME): | |
| """Home -> the named folder. Returns fresh folder nodes (video rows) or [].""" | |
| nodes = home_ready() | |
| row = find_node(nodes, text=name) | |
| if not row: | |
| return [] | |
| if not tap_node(row): | |
| return [] | |
| settle("tap") | |
| after = ui() | |
| if find_node(after, content_desc=NAV_UP) or has_text(after, FOLDER_PATH): | |
| and_enter("folder") | |
| return after | |
| return [] | |
| def and_reach_settings(): | |
| """Home -> Settings root. Returns fresh Settings nodes or [].""" | |
| nodes = home_ready() | |
| if not nodes: | |
| return [] | |
| tap_topbar(nodes, "Settings") | |
| settle("tap") | |
| after = ui() | |
| if find_node(after, text="Appearance") and find_node(after, text="About"): | |
| and_enter("settings") | |
| return after | |
| return [] | |
| def and_reach_settings_sub(row, marker): | |
| """Home -> Settings -> the `row` subscreen (confirmed by `marker` text). | |
| Counts a second surface (depth 2 from Home). Returns fresh sub nodes or [].""" | |
| settings = and_reach_settings() | |
| if not settings: | |
| return [] | |
| node = find_node(settings, text=row) or scroll_into_view(row) | |
| if not node: | |
| return [] | |
| if not tap_node(node): | |
| return [] | |
| after = ui() | |
| for _ in range(3): | |
| if find_node(after, text=marker): | |
| break | |
| settle("tap") | |
| after = ui() | |
| if find_node(after, text=marker): | |
| and_enter(row.lower()) | |
| return after | |
| return [] | |
| def _dump_center(nodes): | |
| 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 _use_landscape_geom(nodes): | |
| """Point the kit's cached geometry at the dump's own (rotated) bounds so | |
| and_showing() keeps the player controls and tap_node() accepts their x>1080 | |
| centres (the landscape player window reports portrait via `wm size`).""" | |
| maxx = max((b[2] for b in (n.get("_bounds") for n in nodes) if b), default=2400) | |
| maxy = max((b[3] for b in (n.get("_bounds") for n in nodes) if b), default=1080) | |
| kit._screen_info = {"width": maxx, "height": maxy, "density": 440, | |
| "center_x": maxx // 2, "center_y": maxy // 2} | |
| def _controls_up(nodes): | |
| return bool(find_node(nodes, content_desc=PLAYER_MARKER) | |
| or any(find_node(nodes, content_desc=d) for d in LOOP_DESCS) | |
| or any(n.get("text", "").endswith(".mp4") for n in nodes)) | |
| def _in_player(): | |
| return "PlayerActivity" in get_current_activity() | |
| def and_enter_player(title="beta_movie"): | |
| """Home -> Download -> tap the video row -> PlayerActivity, then REVEAL the | |
| auto-hiding controls and install landscape geometry. Returns fresh player | |
| nodes with controls up, or []. | |
| Backs depth=2 (Home->folder->player). The fixtures are SHORT (3-8 s), so we do | |
| NOT pre-sleep the full launch settle before revealing — we tap the frame | |
| centre in a tight loop and, if the clip ended and popped back to the folder, | |
| re-tap the row. `title` is the picker title WITHOUT extension.""" | |
| folder = and_enter_folder() | |
| if not folder: | |
| return [] | |
| row = find_node(folder, text=title) | |
| if not row: | |
| return [] | |
| if not tap_node(row): | |
| return [] | |
| time.sleep(1.0) | |
| kit._screen_info = None # drop the stale portrait cache | |
| and_enter("player") | |
| nodes = [] | |
| for _ in range(5): | |
| if not _in_player(): | |
| # clip ended / popped back to the folder — restart it from the row | |
| folder = ui() | |
| r = find_node(folder, text=title) | |
| if r: | |
| tap_node(r) | |
| time.sleep(1.0) | |
| kit._screen_info = None | |
| continue | |
| nodes = ui() | |
| if _controls_up(nodes): | |
| _use_landscape_geom(nodes) | |
| return nodes | |
| cx, cy = _dump_center(nodes) | |
| if not cx: | |
| break | |
| tap(cx, cy) | |
| time.sleep(0.4) | |
| nodes = ui() | |
| if _controls_up(nodes): | |
| _use_landscape_geom(nodes) | |
| return nodes | |
| return [] | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (A) Search result header + row strings. depth=1, transition. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_search_beta_header(): | |
| search = and_reach_search() | |
| if not search: | |
| record("text_search_beta_header", False, | |
| "setup_failed: Search screen not reached from the Home search icon", | |
| depth=1, jump_kind="transition", expect="header reads 'Videos (1)'") | |
| vlm_assert("text_search_beta_header", | |
| "Does a header reading exactly 'Videos (1)' appear near the top " | |
| "of the search results, above a single result row?", | |
| RESULTS_DIR, expect="NO", depth=1, jump_kind="transition", | |
| tag="content") | |
| return | |
| absent = not has_text(search, "Videos (1)") | |
| field = find_by_class(search, "EditText") | |
| if not field: | |
| record("text_search_beta_header", False, | |
| "setup_failed: no search EditText on the Search screen", | |
| depth=1, jump_kind="transition", expect="header reads 'Videos (1)'") | |
| return | |
| type_text(field[0], "beta") | |
| settle("keyboard") | |
| after = ui() | |
| header_ok = has_text(after, "Videos (1)") | |
| row_ok = has_text(after, "beta_movie") | |
| ok = absent and header_ok and row_ok | |
| record("text_search_beta_header", ok, | |
| "" if ok else "behavior_wrong: searching 'beta' did not yield header " | |
| "'Videos (1)' + row 'beta_movie'", | |
| depth=1, jump_kind="transition", | |
| expect="header 'Videos (1)' and result row 'beta_movie' after typing 'beta'") | |
| vlm_assert("text_search_beta_header", | |
| "Is a header reading exactly 'Videos (1)' shown near the top of the " | |
| "search results, directly above one result row?", | |
| RESULTS_DIR, expect="YES", depth=1, jump_kind="transition", | |
| tag="content") | |
| def test_search_gamma_row(): | |
| after = and_search_for("gamma") | |
| if not after: | |
| record("text_search_gamma_row", False, | |
| "setup_failed: Search screen not reached / no EditText", | |
| depth=1, jump_kind="transition", | |
| expect="header 'Videos (1)' + row 'gamma_reel'") | |
| return | |
| ok = has_text(after, "Videos (1)") and has_text(after, "gamma_reel") | |
| record("text_search_gamma_row", ok, | |
| "" if ok else "behavior_wrong: searching 'gamma' did not yield " | |
| "'Videos (1)' + row 'gamma_reel'", | |
| depth=1, jump_kind="transition", | |
| expect="header 'Videos (1)' and result row 'gamma_reel' after typing 'gamma'") | |
| def test_search_substring_movie(): | |
| after = and_search_for("movie") | |
| if not after: | |
| record("text_search_substring_movie", False, | |
| "setup_failed: Search screen not reached / no EditText", | |
| depth=1, jump_kind="transition", | |
| expect="header 'Videos (1)' + row 'beta_movie'") | |
| return | |
| # 'movie' is a substring of only beta_movie -> exactly one match. | |
| ok = has_text(after, "Videos (1)") and has_text(after, "beta_movie") | |
| record("text_search_substring_movie", ok, | |
| "" if ok else "behavior_wrong: substring 'movie' did not match exactly " | |
| "beta_movie (expected header 'Videos (1)')", | |
| depth=1, jump_kind="transition", | |
| expect="header 'Videos (1)' and row 'beta_movie' after typing 'movie'") | |
| def test_search_empty_state(): | |
| search = and_reach_search() | |
| if not search: | |
| record("text_search_empty_state", False, | |
| "setup_failed: Search screen not reached", | |
| depth=1, jump_kind="transition", expect="empty state 'No results found'") | |
| return | |
| absent = not has_text(search, SEARCH_EMPTY) | |
| field = find_by_class(search, "EditText") | |
| if not field: | |
| record("text_search_empty_state", False, | |
| "setup_failed: no search EditText on the Search screen", | |
| depth=1, jump_kind="transition", expect="empty state 'No results found'") | |
| return | |
| type_text(field[0], "zzznope") | |
| settle("keyboard") | |
| after = ui() | |
| # A non-matching query renders the empty-state string AND no 'Videos (' header. | |
| present = has_text(after, SEARCH_EMPTY) | |
| no_header = not any(n.get("text", "").startswith("Videos (") for n in after) | |
| ok = absent and present and no_header | |
| record("text_search_empty_state", ok, | |
| "" if ok else "behavior_wrong: a non-matching query did not render the " | |
| "'No results found' empty state", | |
| depth=1, jump_kind="transition", | |
| expect="'No results found' shown (and no 'Videos (N)' header) for a non-matching query") | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (B) Player title-bar filename (WITH extension). depth=2, transition. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_player_title_beta(): | |
| player = and_enter_player("beta_movie") | |
| if not player: | |
| record("text_player_title_beta", False, | |
| "setup_failed: could not reveal PlayerActivity controls for beta_movie", | |
| depth=2, jump_kind="transition", expect="title bar reads 'beta_movie.mp4'") | |
| vlm_assert("text_player_title_beta", | |
| "Is the text 'beta_movie.mp4' shown as a title in the top bar of " | |
| "the video player, to the right of a back arrow?", | |
| RESULTS_DIR, expect="NO", depth=2, jump_kind="transition", | |
| tag="content") | |
| return | |
| ok = has_text(player, "beta_movie.mp4") | |
| record("text_player_title_beta", ok, | |
| "" if ok else "behavior_wrong: player top bar did not show 'beta_movie.mp4'", | |
| depth=2, jump_kind="transition", | |
| expect="player top-bar title reads 'beta_movie.mp4' (with the .mp4 extension)") | |
| vlm_assert("text_player_title_beta", | |
| "Is the text 'beta_movie.mp4' shown as a title in the top bar of the " | |
| "video player, to the right of a back arrow?", | |
| RESULTS_DIR, expect="YES", depth=2, jump_kind="transition", | |
| tag="content") | |
| def test_player_title_gamma(): | |
| player = and_enter_player("gamma_reel") | |
| if not player: | |
| record("text_player_title_gamma", False, | |
| "setup_failed: could not reveal PlayerActivity controls for gamma_reel", | |
| depth=2, jump_kind="transition", expect="title bar reads 'gamma_reel.mp4'") | |
| return | |
| ok = has_text(player, "gamma_reel.mp4") | |
| record("text_player_title_gamma", ok, | |
| "" if ok else "behavior_wrong: player top bar did not show 'gamma_reel.mp4'", | |
| depth=2, jump_kind="transition", | |
| expect="player top-bar title reads 'gamma_reel.mp4' (with the .mp4 extension)") | |
| def test_player_title_alpha(): | |
| player = and_enter_player("alpha_clip") | |
| if not player: | |
| record("text_player_title_alpha", False, | |
| "setup_failed: could not reveal PlayerActivity controls for alpha_clip", | |
| depth=2, jump_kind="transition", expect="title bar reads 'alpha_clip.mp4'") | |
| return | |
| ok = has_text(player, "alpha_clip.mp4") | |
| record("text_player_title_alpha", ok, | |
| "" if ok else "behavior_wrong: player top bar did not show 'alpha_clip.mp4'", | |
| depth=2, jump_kind="transition", | |
| expect="player top-bar title reads 'alpha_clip.mp4' (with the .mp4 extension)") | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (C) Player Loop content-desc string advances on tap. depth=2, transition. | |
| # The Loop setting PERSISTS across restarts, so read the CURRENT desc, tap | |
| # once, and assert it became the correct NEXT desc — never a fixed start. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_loop_desc_advances(): | |
| player = and_enter_player("beta_movie") | |
| if not player: | |
| record("text_loop_desc_advances", False, | |
| "setup_failed: could not reveal PlayerActivity controls", | |
| depth=2, jump_kind="transition", expect="Loop desc advances to the next value") | |
| return | |
| loop = None | |
| cur = None | |
| for d in LOOP_DESCS: | |
| n = find_node(player, content_desc=d) | |
| if n: | |
| loop, cur = n, d | |
| break | |
| if not loop: | |
| record("text_loop_desc_advances", False, | |
| "feature_missing: no 'Loop: Off/One/All' button in the player", | |
| depth=2, jump_kind="transition", expect="Loop desc advances to the next value") | |
| return | |
| want = next_loop(cur) | |
| tap_node(loop) | |
| settle("tap") | |
| after = _reveal_after_action(player) | |
| ok = bool(want) and bool(find_node(after, content_desc=want)) | |
| record("text_loop_desc_advances", ok, | |
| "" if ok else f"behavior_wrong: Loop desc did not advance '{cur}' -> '{want}'", | |
| depth=2, jump_kind="transition", | |
| expect=f"Loop button content-desc changed from '{cur}' to '{want}' after one tap") | |
| def _reveal_after_action(prev_nodes): | |
| """After a player-control tap the overlay may have started to fade; re-reveal | |
| and re-install geometry, then return a fresh dump.""" | |
| _use_landscape_geom(prev_nodes) | |
| for _ in range(4): | |
| nodes = ui() | |
| if _controls_up(nodes): | |
| _use_landscape_geom(nodes) | |
| return nodes | |
| cx, cy = _dump_center(nodes) | |
| if not cx: | |
| break | |
| tap(cx, cy) | |
| time.sleep(0.35) | |
| return ui() | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (D) Folder row strings. Home-level "Download"/"3 Videos" (depth 0) and the | |
| # video-row path produced by entering the folder (depth 1). | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_home_folder_labels(): | |
| nodes = home_ready() | |
| if not nodes: | |
| record("text_home_folder_labels", False, | |
| "setup_failed: Home picker did not render its folder list", | |
| depth=0, jump_kind="value", | |
| expect="folder row shows 'Download' and count chip '3 Videos'") | |
| vlm_assert("text_home_folder_labels", | |
| "Is a folder entry labeled 'Download' shown together with a small " | |
| "badge/chip reading '3 Videos' on the same row?", | |
| RESULTS_DIR, expect="NO", depth=0, jump_kind="value", tag="content") | |
| return | |
| name_ok = has_text(nodes, FOLDER_NAME) | |
| count_ok = has_text(nodes, FOLDER_COUNT) | |
| ok = name_ok and count_ok | |
| record("text_home_folder_labels", ok, | |
| "" if ok else "behavior_wrong: Home folder row missing 'Download' and/or " | |
| "the '3 Videos' count chip", | |
| depth=0, jump_kind="value", | |
| expect="Home folder row shows 'Download' and count chip '3 Videos'") | |
| vlm_assert("text_home_folder_labels", | |
| "Is a folder entry labeled 'Download' shown together with a small " | |
| "badge/chip reading '3 Videos' on the same row?", | |
| RESULTS_DIR, expect="YES", depth=0, jump_kind="value", tag="content") | |
| def test_folder_video_path(): | |
| folder = and_enter_folder() | |
| if not folder: | |
| record("text_folder_video_path", False, | |
| "setup_failed: Download folder contents not reached", | |
| depth=1, jump_kind="transition", | |
| expect="video row shows path '/storage/emulated/0/Download'") | |
| return | |
| # The full path string only renders on the video rows INSIDE the folder. | |
| ok = has_text(folder, FOLDER_PATH) | |
| record("text_folder_video_path", ok, | |
| "" if ok else "behavior_wrong: video rows did not show the path " | |
| "'/storage/emulated/0/Download'", | |
| depth=1, jump_kind="transition", | |
| expect="each video row shows the path '/storage/emulated/0/Download'") | |
| def test_folder_titles_no_extension(): | |
| folder = and_enter_folder() | |
| if not folder: | |
| record("text_folder_titles_no_extension", False, | |
| "setup_failed: Download folder contents not reached", | |
| depth=1, jump_kind="transition", | |
| expect="picker rows read 'beta_movie' (no extension)") | |
| return | |
| # In the picker the titles carry NO extension; the .mp4 form is player-only. | |
| plain = has_text(folder, "beta_movie") | |
| no_ext = not has_text(folder, "beta_movie.mp4") | |
| ok = plain and no_ext | |
| record("text_folder_titles_no_extension", ok, | |
| "" if ok else "behavior_wrong: picker row title was not the bare " | |
| "'beta_movie' (without the .mp4 extension)", | |
| depth=1, jump_kind="transition", | |
| expect="picker row reads 'beta_movie' (no extension), unlike the player's 'beta_movie.mp4'") | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (E) Settings subtitle strings. depth=2, transition. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_settings_controller_timeout(): | |
| sub = and_reach_settings_sub("Player", "Material You controls") | |
| if not sub: | |
| record("text_settings_controller_timeout", False, | |
| "setup_failed: Player settings subscreen not reached", | |
| depth=2, jump_kind="transition", | |
| expect="'Controller timeout' subtitle reads '4 seconds'") | |
| return | |
| label_ok = has_text(sub, "Controller timeout") | |
| subtitle = sub_of(sub, "Controller timeout") | |
| ok = label_ok and subtitle == "4 seconds" | |
| record("text_settings_controller_timeout", ok, | |
| "" if ok else f"behavior_wrong: 'Controller timeout' subtitle was " | |
| f"{subtitle!r}, expected '4 seconds'", | |
| depth=2, jump_kind="transition", | |
| expect="the 'Controller timeout' row's subtitle reads '4 seconds'") | |
| def test_settings_default_speed(): | |
| sub = and_reach_settings_sub("Player", "Material You controls") | |
| if not sub: | |
| record("text_settings_default_speed", False, | |
| "setup_failed: Player settings subscreen not reached", | |
| depth=2, jump_kind="transition", | |
| expect="'Default playback speed' subtitle reads '1.0'") | |
| return | |
| label_ok = has_text(sub, "Default playback speed") | |
| subtitle = sub_of(sub, "Default playback speed") | |
| ok = label_ok and subtitle == "1.0" | |
| record("text_settings_default_speed", ok, | |
| "" if ok else f"behavior_wrong: 'Default playback speed' subtitle was " | |
| f"{subtitle!r}, expected '1.0'", | |
| depth=2, jump_kind="transition", | |
| expect="the 'Default playback speed' row's subtitle reads '1.0'") | |
| def test_settings_dark_theme_subtitle(): | |
| sub = and_reach_settings_sub("Appearance", "Dark theme") | |
| if not sub: | |
| record("text_settings_dark_theme_subtitle", False, | |
| "setup_failed: Appearance settings subscreen not reached", | |
| depth=2, jump_kind="transition", | |
| expect="'Dark theme' subtitle reads 'System Default'") | |
| return | |
| label_ok = has_text(sub, "Dark theme") | |
| subtitle = sub_of(sub, "Dark theme") | |
| ok = label_ok and subtitle == "System Default" | |
| record("text_settings_dark_theme_subtitle", ok, | |
| "" if ok else f"behavior_wrong: 'Dark theme' subtitle was {subtitle!r}, " | |
| f"expected 'System Default'", | |
| depth=2, jump_kind="transition", | |
| expect="the 'Dark theme' row's subtitle reads 'System Default' (default)") | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (F) About subscreen label strings (stable, recreation-required; NOT the version). | |
| # depth=2, transition. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def test_about_credit_and_rows(): | |
| sub = and_reach_settings_sub("About", "by anilbeesetti") | |
| if not sub: | |
| record("text_about_credit_and_rows", False, | |
| "setup_failed: About subscreen not reached", | |
| depth=2, jump_kind="transition", | |
| expect="'by anilbeesetti', 'Libraries', 'Github' all present") | |
| return | |
| # Deliberately NOT asserting the version number "0.16.3 (56)" — a build | |
| # constant the recreation cannot know. | |
| credit = has_text(sub, "by anilbeesetti") | |
| libs = has_text(sub, "Libraries") | |
| github = has_text(sub, "Github") | |
| ok = credit and libs and github | |
| missing = [s for s, present in | |
| (("by anilbeesetti", credit), ("Libraries", libs), ("Github", github)) | |
| if not present] | |
| record("text_about_credit_and_rows", ok, | |
| "" if ok else f"behavior_wrong: About screen missing {missing}", | |
| depth=2, jump_kind="transition", | |
| expect="About shows the credit 'by anilbeesetti' and rows 'Libraries' and 'Github'") | |
| def test_about_upi_handle(): | |
| sub = and_reach_settings_sub("About", "by anilbeesetti") | |
| if not sub: | |
| record("text_about_upi_handle", False, | |
| "setup_failed: About subscreen not reached", | |
| depth=2, jump_kind="transition", | |
| expect="UPI row subtitle 'anilbeesetti10@oksbi'") | |
| return | |
| label_ok = has_text(sub, "UPI") | |
| handle_ok = has_text(sub, "anilbeesetti10@oksbi") | |
| ok = label_ok and handle_ok | |
| record("text_about_upi_handle", ok, | |
| "" if ok else "behavior_wrong: About screen missing the 'UPI' row and/or " | |
| "its 'anilbeesetti10@oksbi' handle", | |
| depth=2, jump_kind="transition", | |
| expect="About shows a 'UPI' row with the handle 'anilbeesetti10@oksbi'") | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # (G) Network Stream dialog: label + placeholder, and typed-back text. | |
| # depth=2, transition. Do NOT hide_keyboard in this dialog (BACK closes it); | |
| # read the field from a fresh ui() and dismiss with Cancel. | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| 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: | |
| continue | |
| if best is None or (cy + cx) > (best["_center"][1] + best["_center"][0]): | |
| best = n | |
| return best | |
| def and_reach_network_dialog(): | |
| """Home -> FAB -> 'Open network stream' -> Network Stream dialog. Counts two | |
| surfaces (depth 2 from Home). Returns fresh dialog nodes or [].""" | |
| nodes = home_ready() | |
| fab = _find_fab(nodes) | |
| if not fab: | |
| return [] | |
| if not tap_node(fab): | |
| return [] | |
| settle("tap") | |
| menu = ui() | |
| and_enter("fab_menu") | |
| pill = find_node(menu, text="Open network stream") | |
| if not pill: | |
| return [] | |
| if not tap_node(pill): | |
| return [] | |
| settle("tap") | |
| dlg = ui() | |
| if find_node(dlg, text="Network Stream"): | |
| and_enter("network_dialog") | |
| return dlg | |
| return [] | |
| def test_network_dialog_label_placeholder(): | |
| dlg = and_reach_network_dialog() | |
| if not dlg: | |
| record("text_network_dialog_label_placeholder", False, | |
| "setup_failed: Network Stream dialog not reached via the FAB", | |
| depth=2, jump_kind="transition", | |
| expect="label 'Enter a network URL:' + placeholder 'http://example.com/example.mp4'") | |
| return | |
| label_ok = has_text(dlg, "Enter a network URL:") | |
| placeholder_ok = has_text(dlg, "http://example.com/example.mp4") | |
| ok = label_ok and placeholder_ok | |
| # Dismiss with Cancel (NOT BACK, which closes the whole dialog and could pop | |
| # further); keep the surface clean for later tests. | |
| cancel = find_node(dlg, text="Cancel") | |
| if cancel: | |
| tap_node(cancel) | |
| settle("tap") | |
| record("text_network_dialog_label_placeholder", ok, | |
| "" if ok else "behavior_wrong: dialog missing the label 'Enter a network " | |
| "URL:' and/or placeholder 'http://example.com/example.mp4'", | |
| depth=2, jump_kind="transition", | |
| expect="dialog shows label 'Enter a network URL:' and placeholder " | |
| "'http://example.com/example.mp4'") | |
| def test_network_url_reads_back(): | |
| dlg = and_reach_network_dialog() | |
| if not dlg: | |
| record("text_network_url_reads_back", False, | |
| "setup_failed: Network Stream dialog not reached via the FAB", | |
| depth=2, jump_kind="transition", expect="field reads back the typed URL") | |
| return | |
| field = find_by_class(dlg, "EditText") | |
| if not field: | |
| record("text_network_url_reads_back", False, | |
| "setup_failed: no EditText in the Network Stream dialog", | |
| depth=2, jump_kind="transition", expect="field reads back the typed URL") | |
| return | |
| typed = "http://test.mp4" | |
| absent = typed not in all_text(dlg) | |
| type_text(field[0], typed) | |
| settle("text") | |
| # Read directly from a fresh dump — do NOT hide the keyboard here (BACK would | |
| # dismiss the dialog). | |
| after = ui() | |
| et = find_by_class(after, "EditText") | |
| field_text = et[0].get("text", "") if et else "" | |
| present = typed in field_text or typed in all_text(after) | |
| ok = absent and present | |
| cancel = find_node(after, text="Cancel") | |
| if cancel: | |
| tap_node(cancel) | |
| settle("tap") | |
| record("text_network_url_reads_back", ok, | |
| "" if ok else f"behavior_wrong: URL field did not read back {typed!r} " | |
| f"(got {field_text!r})", | |
| depth=2, jump_kind="transition", | |
| expect=f"the URL EditText reads back the typed text {typed!r}") | |
| TESTS = [ | |
| test_search_beta_header, | |
| test_search_gamma_row, | |
| test_search_substring_movie, | |
| test_search_empty_state, | |
| test_player_title_beta, | |
| test_player_title_gamma, | |
| test_player_title_alpha, | |
| test_loop_desc_advances, | |
| test_home_folder_labels, | |
| test_folder_video_path, | |
| test_folder_titles_no_extension, | |
| test_settings_controller_timeout, | |
| test_settings_default_speed, | |
| test_settings_dark_theme_subtitle, | |
| test_about_credit_and_rows, | |
| test_about_upi_handle, | |
| test_network_dialog_label_placeholder, | |
| test_network_url_reads_back, | |
| ] | |
| if __name__ == "__main__": | |
| run_suite(TESTS, "text") | |