#!/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. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_search_beta_header", "text_search_beta_header_vlm")) 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") @and_test(expects=("text_search_gamma_row",)) 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'") @and_test(expects=("text_search_substring_movie",)) 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'") @and_test(expects=("text_search_empty_state",)) 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. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_player_title_beta", "text_player_title_beta_vlm")) 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") @and_test(expects=("text_player_title_gamma",)) 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)") @and_test(expects=("text_player_title_alpha",)) 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. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_loop_desc_advances",)) 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). # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_home_folder_labels", "text_home_folder_labels_vlm")) 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") @and_test(expects=("text_folder_video_path",)) 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'") @and_test(expects=("text_folder_titles_no_extension",)) 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. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_settings_controller_timeout",)) 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'") @and_test(expects=("text_settings_default_speed",)) 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'") @and_test(expects=("text_settings_dark_theme_subtitle",)) 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. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("text_about_credit_and_rows",)) 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'") @and_test(expects=("text_about_upi_handle",)) 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 [] @and_test(expects=("text_network_dialog_label_placeholder",)) 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'") @and_test(expects=("text_network_url_reads_back",)) 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")