| |
| """STRUCTURE lane — Aegis Authenticator. |
| |
| Owns exactly two things: |
| 1. The GATE: MainActivity is in the foreground and its top-level surfaces |
| (toolbar host with search/sort/overflow, FAB, root container) exist. |
| These are jump_kind="none" existence checks — the only place existence |
| is allowed. |
| 2. Tree-SHAPE deltas: an interaction that changes the tree's shape (a menu |
| that adds a class of card, a dialog that adds a window layer, an |
| empty->populated list, a contextual action-mode toolbar). Recorded as |
| jump_kind="transition" with the observed delta, reversed where the app |
| reverses it. |
| |
| Every expected shape below was OBSERVED on the running original app. |
| Never asserts content strings/values — those belong to other lanes. |
| """ |
| import os, sys |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from android_testgen_kit import * |
|
|
| TESTS = [] |
|
|
|
|
| def test(fn): |
| TESTS.append(fn) |
| return fn |
|
|
|
|
| |
|
|
| def _robust_id(rid_suffix, tries=4): |
| """node_by_id with a re-dump retry. A dump taken right after a keyboard |
| dismissal can come back partial (missing nodes); retrying absorbs that.""" |
| for _ in range(tries): |
| n = node_by_id(ui(), rid_suffix) |
| if n: |
| return n |
| settle("dump") |
| return None |
|
|
|
|
| def _dismiss_kb_on_form(): |
| """Dismiss the soft keyboard on EditEntryActivity WITHOUT leaving it, so the |
| lower form fields (text_issuer/text_secret) and the toolbar SAVE button |
| return to the uiautomator dump. A raw BACK here collapses the IME but keeps |
| the activity; we re-press once if the IME lags, and bail if we somehow left |
| the form. (The kit's generic hide_keyboard() taps an inert strip that on this |
| form re-shows the IME, leaving those fields below the fold.)""" |
| for _ in range(2): |
| if not keyboard_visible(): |
| return True |
| if "EditEntryActivity" not in get_current_activity(): |
| return False |
| press_key("KEYCODE_BACK") |
| settle("keyboard") |
| return "EditEntryActivity" in get_current_activity() |
|
|
|
|
| def and_enter_main(): |
| """Clean MainActivity: force-stop + clear data (-> onboarding), then skip the |
| IntroActivity by resource-id if it is showing (portable). Choosing rb_none |
| means the vault opens directly on every launch (no unlock screen).""" |
| force_stop() |
| clear_data() |
| launch_app() |
| wait_for_foreground() |
| nodes = ui() |
| if node_by_id(nodes, "btnNext"): |
| tap_node(node_by_id(nodes, "btnNext")) |
| rb = node_by_id(ui(), "rb_none") |
| if rb: |
| tap_node(rb) |
| b = node_by_id(ui(), "btnNext") |
| if b: |
| tap_node(b) |
| b = node_by_id(ui(), "btnNext") |
| if b: |
| tap_node(b) |
| return ui() |
|
|
|
|
| def and_enter_edit_entry(): |
| """Navigate Main -> FAB menu -> "Enter manually" -> EditEntryActivity. |
| Counts one surface (backs a depth>=1 declaration).""" |
| tap_node(node_by_id(ui(), "fab")) |
| settle("tap") |
| item = node_by_id(ui(), "fab_menu_item_enter") |
| if not item: |
| return None |
| tap_node(item) |
| settle("launch") |
| and_enter("EditEntryActivity") |
| return ui() |
|
|
|
|
| def and_enter_settings(): |
| """Navigate Main -> overflow ("More options") -> Settings -> |
| PreferencesActivity. Counts one surface.""" |
| ov = find_node(ui(), content_desc="More options") |
| if not ov: |
| return None |
| tap_node(ov) |
| settle("tap") |
| st = find_node_ci(ui(), "Settings") |
| if not st: |
| return None |
| tap_node(st) |
| settle("launch") |
| and_enter("PreferencesActivity") |
| return ui() |
|
|
|
|
| def _create_entry(name="TestIssuer", secret="GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"): |
| """Fill and SAVE one manual entry from Main. Returns the Main tree after save, |
| or None if the flow did not land back on MainActivity. |
| |
| Per field: tap-type (type_text focuses the field first) then hide the |
| keyboard so the next field's tap is not intercepted. Every element lookup |
| goes through _robust_id because the post-keyboard dump is occasionally |
| partial on this form.""" |
| if and_enter_edit_entry() is None: |
| return None |
| nm = _robust_id("text_name") |
| if nm: |
| type_text(nm, name) |
| _dismiss_kb_on_form() |
| iss = _robust_id("text_issuer") |
| if iss: |
| type_text(iss, name) |
| _dismiss_kb_on_form() |
| sec = _robust_id("text_secret") |
| if sec: |
| type_text(sec, secret) |
| _dismiss_kb_on_form() |
| save = _robust_id("action_save") |
| if not save: |
| return None |
| tap_node(save) |
| settle("launch") |
| |
| |
| and_reset_depth() |
| if "MainActivity" not in get_current_activity(): |
| return None |
| return ui() |
|
|
|
|
| def _count_by_id(nodes, rid_suffix): |
| """How many nodes carry this resource-id last segment (for row counting).""" |
| return len([n for n in (nodes or []) |
| if n.get("resource-id", "").rsplit("/", 1)[-1] == rid_suffix]) |
|
|
|
|
| |
| |
| |
|
|
| @test |
| @and_test(expects=("structure_gate_launch",)) |
| def test_gate_launch(): |
| nodes = and_enter_main() |
| fg = wait_for_foreground() |
| root = bool(find_by_class(nodes, "FrameLayout")) and bool(find_by_class(nodes, "ViewGroup")) |
| ok = fg and root and "MainActivity" in get_current_activity() |
| record("structure_gate_launch", bool(ok), |
| "" if ok else "setup_failed: app did not reach MainActivity with a root container", |
| depth=0, jump_kind="none") |
|
|
|
|
| @test |
| @and_test(expects=("structure_gate_toolbar",)) |
| def test_gate_toolbar(): |
| nodes = and_enter_main() |
| |
| host = node_by_id(nodes, "toolbar") is not None or node_by_id(nodes, "app_bar_layout") is not None |
| search = node_by_id(nodes, "search_button") is not None |
| sort = node_by_id(nodes, "action_sort") is not None |
| overflow = find_node(nodes, content_desc="More options") is not None |
| ok = host and search and sort and overflow |
| record("structure_gate_toolbar", bool(ok), |
| "" if ok else "feature_missing: toolbar host with search/sort/overflow not all present", |
| depth=0, jump_kind="none") |
|
|
|
|
| @test |
| @and_test(expects=("structure_gate_fab",)) |
| def test_gate_fab(): |
| nodes = and_enter_main() |
| fab = node_by_id(nodes, "fab") is not None |
| add_desc = find_node(nodes, content_desc="Add new entry") is not None |
| ok = fab and add_desc |
| record("structure_gate_fab", bool(ok), |
| "" if ok else "feature_missing: FAB ('Add new entry') not present on MainActivity", |
| depth=0, jump_kind="none") |
|
|
|
|
| |
| |
| |
|
|
| @test |
| @and_test(expects=("structure_fab_menu_shape", |
| "structure_fab_menu_shape_vlm")) |
| def test_fab_menu_shape(): |
| """FAB tap -> tree gains the 3 CardView menu items (Scan QR / Scan image / |
| Enter manually) that were absent before. Observed: 0 -> 3 cards.""" |
| nodes = and_enter_main() |
| cards_before = len(find_by_class(nodes, "CardView")) |
| before = and_showing(nodes) |
| ok_tap = tap_node(node_by_id(nodes, "fab")) |
| settle("tap") |
| after_nodes = ui() |
| cards_after = len(find_by_class(after_nodes, "CardView")) |
| after = and_showing(after_nodes) |
| menu_item = node_by_id(after_nodes, "fab_menu_item_enter") is not None |
| ok = (ok_tap and menu_item and cards_after == cards_before + 3 |
| and surface_changed(before, after)) |
| record("structure_fab_menu_shape", bool(ok), |
| "" if ok else f"behavior_wrong: fab menu did not add 3 cards " |
| f"({cards_before}->{cards_after})", |
| depth=0, jump_kind="transition", |
| expect="FAB menu subtree appears: CardView 0->3 + fab_menu_item_enter") |
| |
| vlm_assert("structure_fab_menu_shape", |
| "Is there a vertical stack of menu item cards positioned above the " |
| "circular floating action button in the lower-right area?", |
| RESULTS_DIR, tag="layout", depth=0, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_fab_menu_reverse",)) |
| def test_fab_menu_reverse(): |
| """FAB menu is reversible: BACK collapses it -> the 3 cards disappear and the |
| tree shape restores to the pre-open surface.""" |
| nodes = and_enter_main() |
| base = and_showing(nodes) |
| tap_node(node_by_id(nodes, "fab")) |
| settle("tap") |
| opened = ui() |
| open_has = node_by_id(opened, "fab_menu_item_enter") is not None |
| back() |
| settle("tap") |
| closed = ui() |
| close_gone = node_by_id(closed, "fab_menu_item_enter") is None |
| cards_gone = len(find_by_class(closed, "CardView")) == 0 |
| restored = not surface_changed(base, and_showing(closed)) |
| ok = open_has and close_gone and cards_gone and restored |
| record("structure_fab_menu_reverse", bool(ok), |
| "" if ok else "behavior_wrong: fab menu did not collapse/restore on back", |
| depth=0, jump_kind="transition", |
| expect="FAB menu cards removed on back; surface restored to base") |
|
|
|
|
| @test |
| @and_test(expects=("structure_search_shape", |
| "structure_search_shape_vlm")) |
| def test_search_shape(): |
| """Search tap -> toolbar swaps to a SearchView subtree: search_src_text + |
| search_close_btn appear where the search_button was.""" |
| nodes = and_enter_main() |
| before = and_showing(nodes) |
| ok_tap = tap_node(node_by_id(nodes, "search_button")) |
| settle("tap") |
| after_nodes = ui() |
| after = and_showing(after_nodes) |
| src = node_by_id(after_nodes, "search_src_text") is not None |
| close_btn = node_by_id(after_nodes, "search_close_btn") is not None |
| btn_gone = node_by_id(after_nodes, "search_button") is None |
| ok = ok_tap and src and close_btn and btn_gone and surface_changed(before, after) |
| record("structure_search_shape", bool(ok), |
| "" if ok else "behavior_wrong: search did not swap toolbar to a SearchView subtree", |
| depth=0, jump_kind="transition", |
| expect="Toolbar -> SearchView: search_src_text/search_close_btn appear, search_button gone") |
| |
| |
| vlm_assert("structure_search_shape", |
| "Is there a search input field across the top with a magnifier icon " |
| "on the left and an X (clear) icon on the right?", |
| RESULTS_DIR, tag="position", depth=0, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_search_reverse",)) |
| def test_search_reverse(): |
| """Search is reversible: tapping the SearchView close button collapses it -> |
| search_src_text disappears and the normal search_button returns.""" |
| nodes = and_enter_main() |
| tap_node(node_by_id(nodes, "search_button")) |
| settle("tap") |
| opened = ui() |
| open_src = node_by_id(opened, "search_src_text") is not None |
| cb = node_by_id(opened, "search_close_btn") |
| tap_node(cb) |
| settle("tap") |
| closed = ui() |
| src_gone = node_by_id(closed, "search_src_text") is None |
| btn_back = node_by_id(closed, "search_button") is not None |
| fab_back = node_by_id(closed, "fab") is not None |
| ok = open_src and src_gone and btn_back and fab_back |
| record("structure_search_reverse", bool(ok), |
| "" if ok else "behavior_wrong: search did not collapse back to the normal toolbar", |
| depth=0, jump_kind="transition", |
| expect="SearchView collapses: search_src_text gone, search_button+fab restored") |
|
|
|
|
| @test |
| @and_test(expects=("structure_sort_popup_shape",)) |
| def test_sort_popup_shape(): |
| """Sort tap -> a popup subtree layers over Main: RadioButtons + the sort |
| option rows appear (none of which were in the tree before).""" |
| nodes = and_enter_main() |
| radios_before = len(find_by_class(nodes, "RadioButton")) |
| before = and_showing(nodes) |
| trigger = node_by_id(nodes, "action_sort") or find_node(nodes, content_desc="Sort") |
| ok_tap = tap_node(trigger) |
| settle("tap") |
| after_nodes = ui() |
| after = and_showing(after_nodes) |
| radios_after = len(find_by_class(after_nodes, "RadioButton")) |
| ok = ok_tap and radios_after > radios_before and surface_changed(before, after) |
| record("structure_sort_popup_shape", bool(ok), |
| "" if ok else f"behavior_wrong: sort popup added no radio subtree " |
| f"({radios_before}->{radios_after})", |
| depth=0, jump_kind="transition", |
| expect="Sort popup subtree appears: RadioButton count increases (0->>0)") |
|
|
|
|
| @test |
| @and_test(expects=("structure_overflow_menu_shape", |
| "structure_overflow_menu_shape_vlm")) |
| def test_overflow_menu_shape(): |
| """More-options tap -> an options popup subtree layers over Main (Settings / |
| About rows appear that were not in the tree before).""" |
| nodes = and_enter_main() |
| before = and_showing(nodes) |
| ov = find_node(nodes, content_desc="More options") |
| ok_tap = tap_node(ov) |
| settle("tap") |
| after_nodes = ui() |
| after = and_showing(after_nodes) |
| settings = find_node_ci(after_nodes, "Settings") is not None |
| about = find_node_ci(after_nodes, "About") is not None |
| ok = ok_tap and settings and about and surface_changed(before, after) |
| record("structure_overflow_menu_shape", bool(ok), |
| "" if ok else "behavior_wrong: overflow did not add a popup menu subtree", |
| depth=0, jump_kind="transition", |
| expect="Overflow popup subtree appears with Settings + About rows") |
| |
| vlm_assert("structure_overflow_menu_shape", |
| "Is there a small popup menu of text options anchored near the " |
| "top-right corner of the screen?", |
| RESULTS_DIR, tag="position", depth=0, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_editentry_form_shape",)) |
| def test_editentry_form_shape(): |
| """EditEntryActivity presents the add-entry form cluster: the text fields |
| (name/issuer/secret) and the collapsed Advanced accordion header + SAVE — |
| a distinct shape from Main's list. depth>=1 (backed by and_enter_edit_entry).""" |
| and_enter_main() |
| nodes = and_enter_edit_entry() |
| if nodes is None: |
| record("structure_editentry_form_shape", False, |
| "setup_failed: could not reach EditEntryActivity", |
| depth=1, jump_kind="transition", |
| expect="EditEntryActivity form fields present") |
| return |
| edits = len(find_by_class(nodes, "EditText")) |
| have = all(node_by_id(nodes, i) is not None |
| for i in ("text_name", "text_issuer", "text_secret", |
| "accordian_header", "action_save")) |
| on_edit = "EditEntryActivity" in get_current_activity() |
| ok = on_edit and have and edits >= 4 |
| record("structure_editentry_form_shape", bool(ok), |
| "" if ok else f"behavior_wrong: edit-entry form cluster incomplete " |
| f"(EditText={edits})", |
| depth=1, jump_kind="transition", |
| expect="EditEntryActivity: >=4 EditText + accordian_header + action_save") |
|
|
|
|
| @test |
| @and_test(expects=("structure_accordion_expand", |
| "structure_accordion_expand_vlm")) |
| def test_accordion_expand(): |
| """Advanced accordion in EditEntryActivity: tapping the header expands the |
| subtree, adding the advanced controls (dropdown_type, dropdown_algo, |
| text_digits) and increasing the node count. Observed: 50 -> 75 nodes. |
| depth>=1 (backed by and_enter_edit_entry).""" |
| and_enter_main() |
| nodes = and_enter_edit_entry() |
| if nodes is None: |
| record("structure_accordion_expand", False, |
| "setup_failed: could not reach EditEntryActivity", |
| depth=1, jump_kind="transition", |
| expect="Advanced accordion expands to add dropdown_type/text_digits") |
| record("structure_accordion_expand_vlm", False, |
| "setup_failed: could not reach EditEntryActivity", |
| depth=1, jump_kind="transition", tag="position", |
| expect="two dropdowns side by side after Advanced expands") |
| return |
| n_before = len(nodes) |
| adv_before = node_by_id(nodes, "dropdown_type") is not None |
| before = and_showing(nodes) |
| ok_tap = tap_node(node_by_id(nodes, "accordian_header")) |
| settle("tap") |
| after_nodes = ui() |
| n_after = len(after_nodes) |
| after = and_showing(after_nodes) |
| adv_after = all(node_by_id(after_nodes, i) is not None |
| for i in ("dropdown_type", "dropdown_algo", "text_digits")) |
| ok = (ok_tap and not adv_before and adv_after and n_after > n_before |
| and surface_changed(before, after)) |
| record("structure_accordion_expand", bool(ok), |
| "" if ok else f"behavior_wrong: accordion did not expand advanced subtree " |
| f"(nodes {n_before}->{n_after})", |
| depth=1, jump_kind="transition", |
| expect="Accordion expands: dropdown_type/dropdown_algo/text_digits appear, node count grows") |
| |
| vlm_assert("structure_accordion_expand", |
| "In the expanded Advanced section, are there two dropdown/spinner " |
| "controls placed side by side on the same row?", |
| RESULTS_DIR, tag="position", depth=1, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_settings_list_shape", |
| "structure_settings_list_shape_vlm")) |
| def test_settings_list_shape(): |
| """Settings root (PreferencesActivity) is a scrollable RecyclerView list of |
| category rows — a distinct shape from Main. depth>=1 (and_enter_settings).""" |
| and_enter_main() |
| nodes = and_enter_settings() |
| if nodes is None: |
| record("structure_settings_list_shape", False, |
| "setup_failed: could not reach Settings", |
| depth=1, jump_kind="transition", |
| expect="PreferencesActivity RecyclerView list of category rows") |
| record("structure_settings_list_shape_vlm", False, |
| "setup_failed: could not reach Settings", |
| depth=1, jump_kind="transition", tag="layout", |
| expect="single vertical column of settings category rows") |
| return |
| on_prefs = "PreferencesActivity" in get_current_activity() |
| has_list = len(find_by_class(nodes, "RecyclerView")) >= 1 |
| |
| rows = sum(1 for lbl in ("Appearance", "Behavior", "Security", "Backups") |
| if find_node_ci(nodes, lbl) is not None) |
| ok = on_prefs and has_list and rows >= 3 |
| record("structure_settings_list_shape", bool(ok), |
| "" if ok else f"behavior_wrong: settings not a category list " |
| f"(recycler={has_list}, rows={rows})", |
| depth=1, jump_kind="transition", |
| expect="PreferencesActivity: RecyclerView with >=3 category rows") |
| |
| vlm_assert("structure_settings_list_shape", |
| "Is the settings screen a single vertical column of stacked category " |
| "rows, each with a title and a short description line?", |
| RESULTS_DIR, tag="layout", depth=1, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_create_populates_list", |
| "structure_create_populates_list_vlm")) |
| def test_create_populates_list(): |
| """Creating an entry flips the list shape: the empty-state placeholder |
| (textView5) is replaced by a populated list containing a profile_code row, |
| and the header gains entries_shown_count. depth 0 but a real shape delta.""" |
| nodes = and_enter_main() |
| empty_before = node_by_id(nodes, "textView5") is not None |
| code_before = node_by_id(nodes, "profile_code") is not None |
| after = _create_entry() |
| if after is None: |
| record("structure_create_populates_list", False, |
| "setup_failed: entry creation flow did not complete", |
| depth=0, jump_kind="transition", |
| expect="empty-state -> populated list with a profile_code row") |
| record("structure_create_populates_list_vlm", False, |
| "setup_failed: entry creation flow did not complete", |
| depth=0, jump_kind="transition", tag="layout", |
| expect="entry row: circular avatar left, two text lines right") |
| return |
| code_after = node_by_id(after, "profile_code") is not None |
| empty_gone = node_by_id(after, "textView5") is None |
| count_row = node_by_id(after, "entries_shown_count") is not None |
| ok = (empty_before and not code_before and code_after and empty_gone and count_row) |
| record("structure_create_populates_list", bool(ok), |
| "" if ok else "behavior_wrong: list shape did not change from empty to populated", |
| depth=0, jump_kind="transition", |
| expect="empty textView5 removed; profile_code row + entries_shown_count appear") |
| |
| vlm_assert("structure_create_populates_list", |
| "Does the list now show an entry row with a circular avatar tile on " |
| "the left and two lines of text stacked to its right?", |
| RESULTS_DIR, tag="layout", depth=0, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_longpress_action_mode", |
| "structure_longpress_action_mode_vlm")) |
| def test_longpress_action_mode(): |
| """Long-press an entry -> the normal toolbar is replaced by a contextual |
| action-mode bar: action_mode_close_button + Copy/Edit action buttons appear. |
| depth>=1 (backed by and_enter_edit_entry inside the create helper).""" |
| and_enter_main() |
| nodes = _create_entry() |
| if nodes is None or node_by_id(nodes, "profile_code") is None: |
| record("structure_longpress_action_mode", False, |
| "setup_failed: no entry to long-press", |
| depth=1, jump_kind="transition", |
| expect="contextual action-mode toolbar appears on long-press") |
| record("structure_longpress_action_mode_vlm", False, |
| "setup_failed: no entry to long-press", |
| depth=1, jump_kind="transition", tag="layout", |
| expect="row of action icons across the top bar") |
| return |
| row = node_by_id(nodes, "profile_code") |
| before = and_showing(nodes) |
| long_press(row) |
| settle("tap") |
| after_nodes = ui() |
| after = and_showing(after_nodes) |
| close_btn = node_by_id(after_nodes, "action_mode_close_button") is not None |
| copy = node_by_id(after_nodes, "action_copy") is not None |
| edit = node_by_id(after_nodes, "action_edit") is not None |
| ok = close_btn and copy and edit and surface_changed(before, after) |
| record("structure_longpress_action_mode", bool(ok), |
| "" if ok else "behavior_wrong: long-press did not open the contextual action mode", |
| depth=1, jump_kind="transition", |
| expect="action-mode bar: action_mode_close_button + action_copy + action_edit appear") |
| |
| |
| |
| vlm_assert("structure_longpress_action_mode", |
| "Is the top bar a row of several action icons (such as star, copy, " |
| "edit) with a back or close arrow icon at the far left?", |
| RESULTS_DIR, tag="layout", depth=1, jump_kind="transition") |
|
|
|
|
| @test |
| @and_test(expects=("structure_multi_entry_shape",)) |
| def test_multi_entry_shape(): |
| """Creating a second entry grows the list shape: the number of profile_code |
| rows increases from 1 to 2 (each row is one entry). depth 0 shape delta.""" |
| and_enter_main() |
| one = _create_entry(name="AlphaOne") |
| if one is None: |
| record("structure_multi_entry_shape", False, |
| "setup_failed: first entry not created", |
| depth=0, jump_kind="transition", |
| expect="profile_code row count 1 -> 2 after a second create") |
| return |
| rows_one = _count_by_id(one, "profile_code") |
| two = _create_entry(name="BravoTwo") |
| rows_two = _count_by_id(two, "profile_code") |
| ok = rows_one == 1 and rows_two == 2 |
| record("structure_multi_entry_shape", bool(ok), |
| "" if ok else f"behavior_wrong: profile_code row count not 1->2 " |
| f"({rows_one}->{rows_two})", |
| depth=0, jump_kind="transition", |
| expect="profile_code rows: 1 -> 2 after second create") |
|
|
|
|
| @test |
| @and_test(expects=("structure_main_overview_vlm",)) |
| def test_main_overview_vlm(): |
| """Whole-screen layout of Main with one entry: a single-column list with a |
| floating action button in the bottom-right. VLM-only (spatial).""" |
| and_enter_main() |
| nodes = _create_entry() |
| ok_setup = nodes is not None and node_by_id(nodes, "profile_code") is not None |
| if not ok_setup: |
| record("structure_main_overview_vlm", False, |
| "setup_failed: could not populate Main for the overview shot", |
| depth=0, jump_kind="transition", tag="position", |
| expect="single-column list with a FAB bottom-right") |
| return |
| vlm_assert("structure_main_overview", |
| "Is the main screen a single-column list of entries with a round " |
| "floating action button in the bottom-right corner?", |
| RESULTS_DIR, tag="position", depth=0, jump_kind="transition") |
|
|
|
|
| if __name__ == "__main__": |
| if not device_online(): |
| print("setup_failed: device offline — the adb tunnel may have dropped") |
| sys.exit(1) |
| run_suite(TESTS, "structure") |
|
|
