Datasets:
Download android/cyb3rko-flashdim/tests/test_android_interaction.py from Qwen/RecreationBench: direct link, hf CLI and curl.
- Browser
- Download file 31.5 kB
-
https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/cyb3rko-flashdim/tests/test_android_interaction.py
- Command line
-
hf download hf://datasets/Qwen/RecreationBench/android/cyb3rko-flashdim/tests/test_android_interaction.py
-
curl -L -o test_android_interaction.py https://huggingface.co/datasets/Qwen/RecreationBench/resolve/main/android/cyb3rko-flashdim/tests/test_android_interaction.py
31.5 kB
| #!/usr/bin/env python3 | |
| """FlashDim — INTERACTION lane. | |
| EFFECT-BY-CONSEQUENCE: multi-step sequences whose consequence on app state is | |
| read back out of a fresh ui(), and DATA/SETTING persistence across full process | |
| death. A dead shell that ignores the taps must FAIL here. | |
| Run: | |
| ADB_PATH=/opt/android/platform-tools/adb DEVICE_SERIAL=emulator-5554 \ | |
| python3 test_android_interaction.py <PACKAGE> <RESULTS_DIR> | |
| """ | |
| import os | |
| import re | |
| import sys | |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) | |
| from android_testgen_kit import * # noqa: F403,E402 | |
| RD = sys.argv[2] if len(sys.argv) > 2 else RESULTS_DIR | |
| # ── local helpers (never touch adb directly) ─────────────────────────────────── | |
| def li_text(): | |
| """Current level_indicator text (e.g. '0 / 10', 'SOS mode'), or None.""" | |
| n = node_by_id(ui(), "level_indicator") | |
| return n.get("text") if n else None | |
| def qa_text(): | |
| """Current quick_actions_view text, or None.""" | |
| n = node_by_id(ui(), "quick_actions_view") | |
| return n.get("text") if n else None | |
| def tap_home_level(rid): | |
| """Tap a home level button by id-suffix; return the resulting level text.""" | |
| if not tap_node(node_by_id(ui(), rid)): | |
| return None | |
| return li_text() | |
| def tap_seekbar_fraction(frac): | |
| """Tap the custom seek_bar at `frac` from its TOP (top=max, bottom=0). | |
| level = round(10*(1-frac)). Coordinates are derived live from the node's | |
| bounds — never a literal. Returns the resulting level text. | |
| """ | |
| sb = node_by_id(ui(), "seek_bar") | |
| if not sb or "_bounds" not in sb: | |
| return None | |
| x1, y1, x2, y2 = sb["_bounds"] | |
| cx = (x1 + x2) // 2 | |
| ty = int(y1 + frac * (y2 - y1)) | |
| tap(cx, ty) | |
| return li_text() | |
| def _yc(node): | |
| b = node["_bounds"] | |
| return (b[1] + b[3]) // 2 | |
| def switch_for_title(nodes, title): | |
| """The Switch node on the same settings row as `title` — the one whose | |
| y-centre is closest (within ~80px) to the title's.""" | |
| t = find_node(nodes, text=title) | |
| if not t or "_bounds" not in t: | |
| return None | |
| ty = _yc(t) | |
| best, best_d = None, 10 ** 9 | |
| for s in find_by_class(nodes, "Switch"): | |
| if "_bounds" not in s: | |
| continue | |
| d = abs(_yc(s) - ty) | |
| if d < best_d: | |
| best, best_d = s, d | |
| return best if best_d <= 80 else None | |
| def pref_level_summary(nodes): | |
| """The 'Preferred level' summary TextView (ends ': <value>'), or None.""" | |
| pl = find_node(nodes, text="Preferred level") | |
| if not pl or "_bounds" not in pl: | |
| return None | |
| ply = _yc(pl) | |
| cands = [x for x in nodes | |
| if x.get("class", "").endswith("TextView") | |
| and x.get("text", "") | |
| and "_bounds" in x | |
| and _yc(x) > ply and abs(_yc(x) - ply) < 120] | |
| return cands[0].get("text") if cands else None | |
| def new_val_in_dialog(nodes): | |
| """Parse the 'New: N' number in the Set preferred level dialog, or None.""" | |
| for x in nodes: | |
| t = x.get("text", "") | |
| if t.startswith("New:"): | |
| m = re.search(r"New:\s*(\d+)", t) | |
| return m.group(1) if m else None | |
| return None | |
| # ── depth-family helpers (their and_enter_* NAME backs a declared depth>=1) ───── | |
| def and_enter_settings(): | |
| """Open the Settings activity from the home toolbar. Counts one surface.""" | |
| if not tap_node(node_by_id(ui(), "settings_action")): | |
| return False | |
| settle("launch") | |
| and_enter("settings") | |
| return True | |
| def and_enter_morse_dialog(): | |
| """Open the Morse dialog from the home screen. Counts one surface.""" | |
| if not tap_node(node_by_id(ui(), "morse_button")): | |
| return False | |
| settle("tap") | |
| and_enter("morse_dialog") | |
| return True | |
| def and_enter_interval_dialog(): | |
| """Open the Interval dialog from the home screen. Counts one surface.""" | |
| if not tap_node(node_by_id(ui(), "interval_button")): | |
| return False | |
| settle("tap") | |
| and_enter("interval_dialog") | |
| return True | |
| def and_enter_preferred_level_dialog(): | |
| """From an open Settings screen, open the Set preferred level dialog.""" | |
| if not tap_node(find_node(ui(), text="Preferred level")): | |
| return False | |
| settle("tap") | |
| and_enter("preferred_level_dialog") | |
| return True | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| # A. Multi-step level sequences (consequence = level_indicator), depth 0 | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| def test_seq_max_half_min_off(): | |
| """4-step ordered progression driven by four different buttons; each step's | |
| consequence depends on the previous surface being live.""" | |
| # clear_data() guarantees a virgin launch at '0 / 10' — a bare restart_app() | |
| # resumes the app's surviving task in whatever level a prior test left it. | |
| clear_data() | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "max_button") is None: | |
| record("interaction_seq_max_half_min_off", False, | |
| "setup_failed: home level buttons not present", | |
| depth=0, jump_kind="transition", | |
| expect="'0 / 10'->'10 / 10'->'5 / 10'->'1 / 10'->'0 / 10'") | |
| return | |
| s0 = li_text() # launch: "0 / 10" | |
| s_max = tap_home_level("max_button") # "10 / 10" | |
| s_half = tap_home_level("half_button") # "5 / 10" | |
| s_min = tap_home_level("min_button") # "1 / 10" | |
| s_off = tap_home_level("off_button") # "0 / 10" | |
| ok = (s0 == "0 / 10" and s_max == "10 / 10" and s_half == "5 / 10" | |
| and s_min == "1 / 10" and s_off == "0 / 10") | |
| record("interaction_seq_max_half_min_off", ok, | |
| "" if ok else f"behavior_wrong: progression was " | |
| f"{s0}->{s_max}->{s_half}->{s_min}->{s_off}", | |
| depth=0, jump_kind="transition", | |
| expect="Max->Half->Min->Off = '10 / 10'->'5 / 10'->'1 / 10'->'0 / 10' (final '0 / 10')") | |
| def test_seq_off_max_off_half(): | |
| """Off->Max->Off->Half. Toggling max ON then OFF then half proves each tap | |
| re-commits state rather than echoing the first input.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "off_button") is None: | |
| record("interaction_seq_toggle_through", False, | |
| "setup_failed: home level buttons not present", | |
| depth=0, jump_kind="transition", expect="final '5 / 10' after Off->Max->Off->Half") | |
| return | |
| s_off1 = tap_home_level("off_button") # "0 / 10" | |
| s_max = tap_home_level("max_button") # "10 / 10" | |
| s_off2 = tap_home_level("off_button") # "0 / 10" | |
| s_half = tap_home_level("half_button") # "5 / 10" | |
| ok = (s_off1 == "0 / 10" and s_max == "10 / 10" | |
| and s_off2 == "0 / 10" and s_half == "5 / 10") | |
| record("interaction_seq_toggle_through", ok, | |
| "" if ok else f"behavior_wrong: progression was " | |
| f"{s_off1}->{s_max}->{s_off2}->{s_half}", | |
| depth=0, jump_kind="transition", | |
| expect="Off->Max->Off->Half = '0 / 10'->'10 / 10'->'0 / 10'->'5 / 10' (final '5 / 10')") | |
| def test_seq_min_then_max_override(): | |
| """Min sets '1 / 10', then Max must OVERRIDE to '10 / 10' — a later action | |
| winning over an earlier one, not being ignored.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "min_button") is None: | |
| record("interaction_seq_min_then_max_override", False, | |
| "setup_failed: home level buttons not present", | |
| depth=0, jump_kind="transition", expect="'1 / 10' then '10 / 10'") | |
| return | |
| s_min = tap_home_level("min_button") # "1 / 10" | |
| s_max = tap_home_level("max_button") # "10 / 10" | |
| ok = (s_min == "1 / 10" and s_max == "10 / 10") | |
| record("interaction_seq_min_then_max_override", ok, | |
| "" if ok else f"behavior_wrong: Min={s_min}, then Max={s_max}", | |
| depth=0, jump_kind="transition", | |
| expect="Min='1 / 10' then Max overrides to '10 / 10'") | |
| def test_button_and_seekbar_drive_same_state(): | |
| """Max button -> '10 / 10', Min button -> '1 / 10', then a seekbar tap near | |
| the TOP must return '10 / 10' — proving buttons and the custom seekbar drive | |
| the SAME level state. VLM confirms the segmented fill matches level 10.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "seek_bar") is None or node_by_id(ui(), "max_button") is None: | |
| record("interaction_button_seekbar_same_state", False, | |
| "setup_failed: seek_bar or level buttons missing", | |
| depth=0, jump_kind="transition", | |
| expect="'10 / 10' -> '1 / 10' -> seekbar '10 / 10'") | |
| vlm_assert("interaction_button_seekbar_same_state", | |
| "Is the vertical segmented bar completely filled (all ~10 segments " | |
| "highlighted) and does the level read 10 / 10?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="shape") | |
| return | |
| s_max = tap_home_level("max_button") # "10 / 10" | |
| s_min = tap_home_level("min_button") # "1 / 10" | |
| s_seek = tap_seekbar_fraction(0.05) # back to "10 / 10" | |
| ok = (s_max == "10 / 10" and s_min == "1 / 10" and s_seek == "10 / 10") | |
| record("interaction_button_seekbar_same_state", ok, | |
| "" if ok else f"behavior_wrong: Max={s_max}, Min={s_min}, seekTop={s_seek}", | |
| depth=0, jump_kind="transition", | |
| expect="Max='10 / 10', Min='1 / 10', seekbar-top back to '10 / 10' (shared state)") | |
| # VLM #1: seekbar fully filled at level 10 | |
| vlm_assert("interaction_button_seekbar_same_state", | |
| "Is the vertical segmented bar completely filled (all ~10 segments " | |
| "highlighted) and does the level read 10 / 10?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="shape") | |
| def test_seekbar_min_fill_vlm(): | |
| """Tap Min, then have the VLM verify only the bottom-most seekbar segment is | |
| lit — a canvas-drawn fill that the view tree never exposes.""" | |
| restart_app() | |
| wait_for_foreground() | |
| s_min = tap_home_level("min_button") # "1 / 10" (rule-side sanity for the screenshot) | |
| if s_min != "1 / 10": | |
| record("interaction_seekbar_min_fill_vlm", False, | |
| f"setup_failed: Min gave {s_min!r}, not '1 / 10'; screenshot unreliable", | |
| depth=0, jump_kind="none", tag="shape") | |
| return | |
| # VLM #2: only bottom segment lit | |
| vlm_assert("interaction_seekbar_min_fill", | |
| "Is only the bottom-most segment of the vertical bar highlighted while " | |
| "the rest are dark?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="shape") | |
| def test_seekbar_mid_fill_vlm(): | |
| """Tap the seekbar mid, verify level '5 / 10', then have the VLM confirm the | |
| bar is filled about halfway from the bottom.""" | |
| restart_app() | |
| wait_for_foreground() | |
| s_mid = tap_seekbar_fraction(0.5) # "5 / 10" | |
| if s_mid != "5 / 10": | |
| record("interaction_seekbar_mid_fill_vlm", False, | |
| f"setup_failed: seekbar-mid gave {s_mid!r}, not '5 / 10'", | |
| depth=0, jump_kind="none", tag="shape") | |
| return | |
| # VLM #6: bar filled about halfway | |
| vlm_assert("interaction_seekbar_mid_fill", | |
| "Is the vertical segmented bar filled about halfway from the bottom " | |
| "(roughly the lower half of the segments highlighted, the upper half dark)?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="shape") | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| # B. SOS mode enter -> exit (consequence = multiple widgets change), depth 0 | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| def test_sos_enter_then_exit(): | |
| """Tap SOS: indicator -> 'SOS mode', quick_actions -> 'Morse:...', the | |
| Max/Half/Min/Morse/Interval buttons DISAPPEAR, sos disabled, seek disabled. | |
| Then tap Off: EVERYTHING restores. Asserts BOTH halves of the sequence.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "sos_button") is None: | |
| record("interaction_sos_enter_exit", False, | |
| "feature_missing: no sos_button on the main surface", | |
| depth=0, jump_kind="transition", | |
| expect="'SOS mode' + buttons hidden, then restored to '0 / 10'") | |
| vlm_assert("interaction_sos_enter_exit", | |
| "Have the Maximum/Half/Minimum buttons disappeared, leaving only " | |
| "SOS and Off in the left column?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="position") | |
| return | |
| # enter | |
| tap_node(node_by_id(ui(), "sos_button")) | |
| n = ui() | |
| entered_li = (node_by_id(n, "level_indicator") or {}).get("text") | |
| entered_qa = (node_by_id(n, "quick_actions_view") or {}).get("text") or "" | |
| hidden = all(node_by_id(n, rid) is None for rid in | |
| ("morse_button", "interval_button", "max_button", | |
| "half_button", "min_button")) | |
| sos_disabled = (node_by_id(n, "sos_button") or {}).get("enabled") == "false" | |
| seek_disabled = (node_by_id(n, "seek_bar") or {}).get("enabled") == "false" | |
| entered_ok = (entered_li == "SOS mode" and entered_qa.startswith("Morse:") | |
| and hidden and sos_disabled and seek_disabled) | |
| # VLM #3: brightness buttons gone in SOS mode | |
| vlm_assert("interaction_sos_enter_exit", | |
| "Have the Maximum/Half/Minimum buttons disappeared, leaving only " | |
| "SOS and Off in the left column?", | |
| RD, expect="YES", depth=0, jump_kind="transition", tag="position") | |
| # exit | |
| tap_node(node_by_id(ui(), "off_button")) | |
| m = ui() | |
| restored_li = (node_by_id(m, "level_indicator") or {}).get("text") | |
| restored_qa = (node_by_id(m, "quick_actions_view") or {}).get("text") | |
| buttons_back = all(node_by_id(m, rid) is not None for rid in | |
| ("morse_button", "interval_button", "max_button", | |
| "half_button", "min_button")) | |
| restored_ok = (restored_li == "0 / 10" and restored_qa == "Quick Actions" | |
| and buttons_back) | |
| ok = entered_ok and restored_ok | |
| record("interaction_sos_enter_exit", ok, | |
| "" if ok else f"behavior_wrong: entered(li={entered_li!r},hidden={hidden}," | |
| f"sosOff={sos_disabled},seekOff={seek_disabled}) " | |
| f"restored(li={restored_li!r},qa={restored_qa!r},back={buttons_back})", | |
| depth=0, jump_kind="transition", | |
| expect="SOS enter: li='SOS mode', qa startswith 'Morse:', buttons hidden, " | |
| "sos+seek disabled; Off exit restores li='0 / 10', qa='Quick Actions', buttons back") | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| # C. Morse dialog input sequence (3+ steps), depth 1 | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| def test_morse_dialog_input_flow(): | |
| """3-step sequence inside the Morse dialog: | |
| 1) open dialog, | |
| 2) tap Flash with EMPTY input -> validation error appears AND dialog stays, | |
| 3) type a message, tap Flash -> the dialog DISMISSES. | |
| Each step depends on the prior surface being live; a shell that ignores the | |
| empty-Flash tap would dismiss immediately at step 2 and fail.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "morse_button") is None: | |
| record("interaction_morse_dialog_flow", False, | |
| "feature_missing: no morse_button on the main surface", | |
| depth=1, jump_kind="transition", | |
| expect="empty Flash -> error + dialog open; typed Flash -> dialog gone") | |
| vlm_assert("interaction_morse_dialog_flow", | |
| "Is a dialog with a single-line text input field (hint about a message) " | |
| "and a 'Flash' button visible on screen?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="layout") | |
| return | |
| if not and_enter_morse_dialog(): | |
| record("interaction_morse_dialog_flow", False, | |
| "setup_failed: could not open the Morse dialog", | |
| depth=1, jump_kind="transition", | |
| expect="empty Flash -> error + dialog open; typed Flash -> dialog gone") | |
| vlm_assert("interaction_morse_dialog_flow", | |
| "Is a dialog with a single-line text input field (hint about a message) " | |
| "and a 'Flash' button visible on screen?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="layout") | |
| return | |
| dialog_open = node_by_id(ui(), "text_input_text") is not None | |
| # VLM #4: the morse input dialog is on screen | |
| vlm_assert("interaction_morse_dialog_flow", | |
| "Is a dialog with a single-line text input field (hint about a message) " | |
| "and a 'Flash' button visible on screen?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="layout") | |
| # step 2: empty Flash -> error, dialog persists | |
| tap_node(node_by_id(ui(), "button1")) | |
| settle("tap") | |
| n = ui() | |
| still_open = node_by_id(n, "text_input_text") is not None | |
| err = find_node_ci(n, "Please enter your message") is not None | |
| # step 3: type + Flash -> dialog dismisses | |
| field = node_by_id(ui(), "text_input_text") | |
| typed = False | |
| if field: | |
| typed = type_text(field, "A") | |
| cur = node_by_id(ui(), "text_input_text") | |
| if cur is not None and cur.get("text") != "A": | |
| type_text(field, "A", method="ime") | |
| hide_keyboard() | |
| tap_node(node_by_id(ui(), "button1")) | |
| settle("tap") | |
| dismissed = node_by_id(ui(), "text_input_text") is None | |
| ok = dialog_open and still_open and err and dismissed | |
| record("interaction_morse_dialog_flow", ok, | |
| "" if ok else f"behavior_wrong: open={dialog_open}, emptyStillOpen={still_open}, " | |
| f"error={err}, typed={typed}, dismissedAfterFlash={dismissed}", | |
| depth=1, jump_kind="transition", | |
| expect="empty Flash keeps dialog open with error 'Please enter your message'; " | |
| "typed 'A' + Flash dismisses the dialog") | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| # D. Interval dialog TIME<->BPM mode-switch round-trip (3 states), depth 1 | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| def test_interval_mode_roundtrip(): | |
| """Open Interval dialog (TIME default: input '500', suffix 'ms'), tap BPM | |
| (input '100', 'ms' gone), tap TIME (back to '500'/'ms'). Asserts the full | |
| 3-state round-trip — each switch depends on the prior mode being live.""" | |
| restart_app() | |
| wait_for_foreground() | |
| if node_by_id(ui(), "interval_button") is None: | |
| record("interaction_interval_mode_roundtrip", False, | |
| "feature_missing: no interval_button on the main surface", | |
| depth=1, jump_kind="transition", | |
| expect="TIME '500'/'ms' -> BPM '100'/none -> TIME '500'/'ms'") | |
| vlm_assert("interaction_interval_mode_roundtrip", | |
| "Does the numeric input show 100 with no 'ms' suffix beside it?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="content") | |
| return | |
| if not and_enter_interval_dialog(): | |
| record("interaction_interval_mode_roundtrip", False, | |
| "setup_failed: could not open the Interval dialog", | |
| depth=1, jump_kind="transition", | |
| expect="TIME '500'/'ms' -> BPM '100'/none -> TIME '500'/'ms'") | |
| vlm_assert("interaction_interval_mode_roundtrip", | |
| "Does the numeric input show 100 with no 'ms' suffix beside it?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="content") | |
| return | |
| def snap(): | |
| n = ui() | |
| return ((node_by_id(n, "number_input_text") or {}).get("text"), | |
| (node_by_id(n, "textinput_suffix_text") or {}).get("text")) | |
| t_num, t_suf = snap() # TIME default: 500 / ms | |
| tap_node(node_by_id(ui(), "bpm_button")) | |
| settle("tap") | |
| b_num, b_suf = snap() # BPM: 100 / None | |
| # VLM #5: BPM shows 100 with no ms suffix | |
| vlm_assert("interaction_interval_mode_roundtrip", | |
| "Does the numeric input show 100 with no 'ms' suffix beside it?", | |
| RD, expect="YES", depth=1, jump_kind="transition", tag="content") | |
| tap_node(node_by_id(ui(), "time_button")) | |
| settle("tap") | |
| r_num, r_suf = snap() # back to TIME: 500 / ms | |
| ok = (t_num == "500" and t_suf == "ms" | |
| and b_num == "100" and b_suf is None | |
| and r_num == "500" and r_suf == "ms") | |
| record("interaction_interval_mode_roundtrip", ok, | |
| "" if ok else f"behavior_wrong: TIME=({t_num},{t_suf}) BPM=({b_num},{b_suf}) " | |
| f"TIME2=({r_num},{r_suf})", | |
| depth=1, jump_kind="transition", | |
| expect="TIME('500','ms') -> BPM('100',no suffix) -> TIME('500','ms') round-trip") | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| # E. PERSISTENCE across process death (this lane OWNS data/setting persistence) | |
| # ════════════════════════════════════════════════════════════════════════════ | |
| def test_context_awareness_persists(): | |
| """Toggle 'Context awareness' OFF->ON in Settings, force-stop + relaunch, | |
| reopen Settings, assert the switch is STILL checked. An in-memory-only | |
| recreation cannot survive the process death.""" | |
| clear_data() | |
| launch_app() | |
| wait_for_foreground() | |
| if not and_enter_settings(): | |
| record("interaction_context_awareness_persists", False, | |
| "setup_failed: could not open Settings", | |
| depth=1, jump_kind="transition", | |
| expect="'Context awareness' switch checked=true after relaunch") | |
| return | |
| sw = switch_for_title(ui(), "Context awareness") | |
| if sw is None: | |
| record("interaction_context_awareness_persists", False, | |
| "feature_missing: no 'Context awareness' switch in Settings", | |
| depth=1, jump_kind="transition", | |
| expect="'Context awareness' switch checked=true after relaunch") | |
| return | |
| was_off = sw.get("checked") == "false" | |
| tap_node(sw) | |
| settle("tap") | |
| sw2 = switch_for_title(ui(), "Context awareness") | |
| turned_on = (sw2 or {}).get("checked") == "true" | |
| # kill the process and relaunch | |
| force_stop_and_relaunch() | |
| wait_for_foreground() | |
| and_reset_depth() | |
| if not and_enter_settings(): | |
| record("interaction_context_awareness_persists", False, | |
| "setup_failed: could not reopen Settings after relaunch", | |
| depth=1, jump_kind="transition", | |
| expect="'Context awareness' switch checked=true after relaunch") | |
| return | |
| sw3 = switch_for_title(ui(), "Context awareness") | |
| persisted = (sw3 or {}).get("checked") == "true" | |
| ok = was_off and turned_on and persisted | |
| record("interaction_context_awareness_persists", ok, | |
| "" if ok else f"behavior_wrong: wasOff={was_off}, turnedOn={turned_on}, " | |
| f"stillOnAfterRestart={persisted}", | |
| depth=1, jump_kind="transition", | |
| expect="'Context awareness' OFF->ON then survives force_stop_and_relaunch (checked=true)") | |
| def test_preferred_level_value_persists(): | |
| """Two consequences on the 'Preferred level' preference: | |
| 1) inside the slider dialog (depth 2), tapping the track sets the live | |
| 'New: <value>' to the exact value the tap position maps to; | |
| 2) after OK + force-stop + relaunch, the Settings summary STILL ends with | |
| the SAME ': <value>' and is NOT the untouched default ': 10'. | |
| A concrete VALUE surviving process death — an in-memory recreation fails (2).""" | |
| LIVE = "interaction_preferred_level_dialog_live_value" | |
| PERSIST = "interaction_preferred_level_persists" | |
| clear_data() | |
| launch_app() | |
| wait_for_foreground() | |
| if not and_enter_settings(): | |
| record(LIVE, False, "setup_failed: could not open Settings", | |
| depth=2, jump_kind="value", expect="dialog 'New:' shows the tapped value '2'") | |
| record(PERSIST, False, "setup_failed: could not open Settings", | |
| depth=1, jump_kind="value", | |
| expect="'Preferred level' summary keeps its set value after relaunch") | |
| return | |
| if find_node(ui(), text="Preferred level") is None: | |
| record(LIVE, False, "feature_missing: no 'Preferred level' row in Settings", | |
| depth=2, jump_kind="value", expect="dialog 'New:' shows the tapped value '2'") | |
| record(PERSIST, False, "feature_missing: no 'Preferred level' row in Settings", | |
| depth=1, jump_kind="value", | |
| expect="'Preferred level' summary keeps its set value after relaunch") | |
| return | |
| default_summary = pref_level_summary(ui()) or "" | |
| if not and_enter_preferred_level_dialog(): | |
| record(LIVE, False, "setup_failed: could not open the Set preferred level dialog", | |
| depth=2, jump_kind="value", expect="dialog 'New:' shows the tapped value '2'") | |
| record(PERSIST, False, "setup_failed: could not open the Set preferred level dialog", | |
| depth=2, jump_kind="value", | |
| expect="'Preferred level' summary keeps its set value after relaunch") | |
| return | |
| # The slider is a custom view with no distinct node; tap along its track strip | |
| # (derived from the container + 'New:' label bounds) to set a distinct value. | |
| d = ui() | |
| conts = [x for x in d if x.get("class", "").endswith("LinearLayout") | |
| and "_bounds" in x and x["_bounds"][1] > 1000] | |
| news = [x for x in d if x.get("text", "").startswith("New:") and "_bounds" in x] | |
| before_new = new_val_in_dialog(d) # default "10" | |
| changed_new = None | |
| if conts and news: | |
| cont = min(conts, key=lambda c: (c["_bounds"][2] - c["_bounds"][0])) | |
| cx1, _, cx2, cy2 = cont["_bounds"] | |
| sy = (news[0]["_bounds"][3] + cy2) // 2 | |
| # f=0.2 of the track -> value 2 (distinct from the default 10) | |
| tap(int(cx1 + 0.2 * (cx2 - cx1)), sy) | |
| changed_new = new_val_in_dialog(ui()) | |
| # depth-2 value: the live "New:" readout reflects the tapped position (10 -> 2) | |
| live_ok = (before_new == "10" and changed_new == "2") | |
| record(LIVE, live_ok, | |
| "" if live_ok else f"behavior_wrong: 'New:' was {before_new!r}, after tapping " | |
| f"track f=0.2 became {changed_new!r} (expected '2')", | |
| depth=2, jump_kind="value", | |
| expect="dialog 'New:' 10 -> '2' after tapping the slider track at fraction 0.2") | |
| tap_node(node_by_id(ui(), "button1")) # OK | |
| settle("tap") | |
| set_summary = pref_level_summary(ui()) or "" | |
| set_value = None | |
| m = re.search(r":\s*(\d+)\s*$", set_summary) | |
| if m: | |
| set_value = m.group(1) | |
| # kill the process and relaunch | |
| force_stop_and_relaunch() | |
| wait_for_foreground() | |
| and_reset_depth() | |
| if not and_enter_settings(): | |
| record(PERSIST, False, | |
| "setup_failed: could not reopen Settings after relaunch", | |
| depth=1, jump_kind="value", | |
| expect="'Preferred level' summary keeps its set value after relaunch") | |
| return | |
| after_summary = pref_level_summary(ui()) or "" | |
| changed_from_default = (set_summary != default_summary | |
| and not set_summary.rstrip().endswith(": 10")) | |
| persisted = (bool(set_value) and after_summary == set_summary) | |
| ok = changed_from_default and persisted | |
| record(PERSIST, ok, | |
| "" if ok else f"behavior_wrong: default={default_summary[-12:]!r}, " | |
| f"newInDialog={changed_new!r}, set={set_summary[-12:]!r}, " | |
| f"afterRestart={after_summary[-12:]!r}", | |
| depth=1, jump_kind="value", | |
| expect=f"'Preferred level' summary ends ': {set_value}' both before and after " | |
| f"force_stop_and_relaunch (and not the default ': 10')") | |
| TESTS = [ | |
| # A. multi-step level sequences (depth 0) | |
| test_seq_max_half_min_off, | |
| test_seq_off_max_off_half, | |
| test_seq_min_then_max_override, | |
| test_button_and_seekbar_drive_same_state, | |
| test_seekbar_min_fill_vlm, | |
| test_seekbar_mid_fill_vlm, | |
| # B. SOS enter/exit sequence (depth 0) | |
| test_sos_enter_then_exit, | |
| # C. Morse dialog input sequence (depth 1) | |
| test_morse_dialog_input_flow, | |
| # D. Interval dialog mode round-trip (depth 1) | |
| test_interval_mode_roundtrip, | |
| # E. persistence across process death (depth 1 / depth 2 value) | |
| test_context_awareness_persists, | |
| test_preferred_level_value_persists, | |
| ] | |
| if __name__ == "__main__": | |
| if not device_online(): | |
| print("device offline — the adb tunnel may have dropped") | |
| run_suite(TESTS, "interaction") | |