RecreationBench / android /cyb3rko-flashdim /tests /test_android_interaction.py
VoyagerXHF's picture
Upload folder using huggingface_hub
966ca88 verified
Raw History Blame Contribute Delete
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
# ════════════════════════════════════════════════════════════════════════════
@and_test(expects=("interaction_seq_max_half_min_off",))
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')")
@and_test(expects=("interaction_seq_toggle_through",))
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')")
@and_test(expects=("interaction_seq_min_then_max_override",))
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'")
@and_test(expects=("interaction_button_seekbar_same_state",
"interaction_button_seekbar_same_state_vlm"))
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")
@and_test(expects=("interaction_seekbar_min_fill_vlm",))
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")
@and_test(expects=("interaction_seekbar_mid_fill_vlm",))
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
# ════════════════════════════════════════════════════════════════════════════
@and_test(expects=("interaction_sos_enter_exit",
"interaction_sos_enter_exit_vlm"))
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
# ════════════════════════════════════════════════════════════════════════════
@and_test(expects=("interaction_morse_dialog_flow",
"interaction_morse_dialog_flow_vlm"))
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
# ════════════════════════════════════════════════════════════════════════════
@and_test(expects=("interaction_interval_mode_roundtrip",
"interaction_interval_mode_roundtrip_vlm"))
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)
# ════════════════════════════════════════════════════════════════════════════
@and_test(expects=("interaction_context_awareness_persists",))
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)")
@and_test(expects=("interaction_preferred_level_dialog_live_value",
"interaction_preferred_level_persists"))
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")