RecreationBench / android /v1tzor-timeplanner /tests /test_android_interaction.py
VoyagerXHF's picture
Upload folder using huggingface_hub (part 4)
41dfd8d verified
Raw History Blame Contribute Delete
32.7 kB
#!/usr/bin/env python3
"""INTERACTION lane — EFFECT-BY-CONSEQUENCE on user DATA for TimePlanner.
Owns: CRUD lifecycle, 3+ step sequences, multi-record integrity, DATA
persistence across process death (force_stop_and_relaunch), long-press/context
menus. Every test drives the app to the surface via the real user path, performs
the action, then reads the consequence back out of a FRESH ui() and asserts it
against what was observed on the original.
Run:
python3 test_android_interaction.py <PACKAGE> <RESULTS_DIR>
"""
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from android_testgen_kit import * # noqa: F403,E402
require_kit(1)
# The category we create/read back. All are real built-in categories (verified in
# recon: Absent/Shopping/Health/Study/Sleep/Work), so the golden create flow
# (Plan now -> Editor -> Category sheet -> row -> Select -> Save) yields a card
# whose category we read straight out of the Home schedule dump. "Study" never
# accidentally matches an empty schedule.
CAT_A = "Study"
CAT_B = "Health" # the edit target — a DIFFERENT built-in category
NOTE_TEXT = "kitreadchapter" # ASCII, no spaces => input-text path is reliable
# Every built-in category name that renders as a task-card icon desc. Used to
# count DISTINCT task cards on the schedule.
_CATEGORY_NAMES = ("Study", "Health", "Shopping", "Sleep", "Work", "Absent")
# ══════════════════════════════════════════════════════════════════════════════
# Trap handling — LeakCanary launcher alias + onboarding permission dialog.
# * LeakCanary: the .debug build bundles a SECOND launcher activity in the same
# package; monkey non-deterministically opens leakcanary.internal.activity.
# LeakActivity, and wait_for_foreground()/is_app_foreground() then LIE (same
# package). We detect it by the ABSENCE of a Home surface and force-stop +
# relaunch to shake it off. We never press HOME (that lands on the system
# launcher, whose TimePlanner ICON also fools the package check).
# * onboarding: the notification-permission dialog after clear_data(), dismissed
# at the top of the loop.
# ══════════════════════════════════════════════════════════════════════════════
def dismiss_onboarding(nodes=None):
"""Tap the notification-permission dialog's button if present. Returns True
if it dismissed one (so the caller re-loops)."""
nodes = nodes if nodes is not None else ui()
btn = next((n for n in nodes
if (n.get("text") or "") in ("Allow", "Don't allow", "Don’t allow")),
None)
if btn is None:
return False
tap_node(btn)
return True
def _home_ready(nodes):
"""Home's own surface — the top-bar title, the empty-state prompt, or the
'Plan now' control. Any means the REAL app (not LeakCanary, not the launcher)
is on screen."""
return (find_node_ci(nodes, "Schedule") is not None
or find_node_ci(nodes, "Plan now") is not None
or find_node_ci(nodes, "Nothing planned yet") is not None)
def ensure_home(max_tries=20):
for _ in range(max_tries):
nodes = ui()
if dismiss_onboarding(nodes):
settle("tap")
continue
if _home_ready(nodes):
settle("launch") # confirm a mid-launch frame settled
if _home_ready(ui()):
return True
continue
force_stop(); settle("key")
launch_app(); settle("launch")
return _home_ready(ui())
def start_home_clean():
"""Virgin-database entry point: clear data, relaunch, dismiss onboarding,
settle on the empty Home. Every CRUD/persistence test starts here."""
clear_data()
launch_app()
return ensure_home()
# ══════════════════════════════════════════════════════════════════════════════
# Compose tap helpers — leaves report clickable="false"; tap the clickable
# ancestor whose bounds enclose the label's centre.
# ══════════════════════════════════════════════════════════════════════════════
def _clickable_ancestor(nodes, anchor):
"""Tightest clickable node whose bounds contain `anchor`'s centre."""
if not anchor or "_center" not in anchor:
return None
cx, cy = anchor["_center"]
cands = [n for n in nodes
if n.get("clickable") == "true" and "_bounds" in n
and n["_bounds"][0] <= cx <= n["_bounds"][2]
and n["_bounds"][1] <= cy <= n["_bounds"][3]]
cands.sort(key=lambda n: (n["_bounds"][2] - n["_bounds"][0])
* (n["_bounds"][3] - n["_bounds"][1]))
return cands[0] if cands else None
def _tap_anchor(nodes, anchor):
"""Tap `anchor`'s clickable ancestor (or the anchor itself, which hits the
same ancestor by coordinate)."""
if anchor is None:
return False
anc = _clickable_ancestor(nodes, anchor)
return tap_node(anc) if anc else tap_node(anchor)
def _card_anchor(nodes, cat):
"""The task-card / category leaf for `cat` (icon desc or label text)."""
return find_node(nodes, content_desc=cat) or find_node(nodes, text=cat)
def _task_card_names(nodes):
"""Distinct category names rendered as task cards on the schedule. Each card
carries its category as an icon leaf desc=<category> exactly once."""
return sorted(n.get("content-desc", "") for n in nodes
if n.get("content-desc", "") in _CATEGORY_NAMES)
def _count_category(nodes, cat):
"""How many nodes carry `cat` as text or content-desc (>=1 => a card exists)."""
return sum(1 for n in nodes
if n.get("content-desc") == cat or n.get("text") == cat)
# ══════════════════════════════════════════════════════════════════════════════
# The core create flow, decomposed so depth is backed by NAMED and_enter_* /
# and_reach_* helpers. Each takes the app one surface deeper and calls and_enter.
# ══════════════════════════════════════════════════════════════════════════════
def and_reach_free_row():
"""Home empty -> tap 'Plan now' (CREATES the day's schedule) -> the free-time
'Unassigned' row appears. Stays on Home, so counts NO surface."""
n = find_node_ci(ui(), "Plan now")
if n is not None:
tap_node(n)
settle("tap")
return find_node_ci(ui(), "Unassigned") or find_node_ci(ui(), "Add a task")
def and_enter_editor():
"""Home -> free/add row -> Editor (title 'Editor', 'Category', 'Save').
Counts ONE surface. Returns True on success."""
row = and_reach_free_row()
if row is None:
return False
nodes = ui()
before = and_showing(nodes)
if not _tap_anchor(nodes, row):
return False
after = and_showing()
if not and_reach(before, after, "Category", "Schedule"):
return False
and_enter("editor")
return True
def and_enter_editor_via_card(cat):
"""Home (task exists) -> tap the task card for `cat` -> Editor. A RUNNING card
first expands inline (Add-time/Reduce/Edit); if so, tap its 'Edit' control to
reach the Editor. Counts ONE surface. Returns True on success."""
nodes = ui()
anchor = _card_anchor(nodes, cat)
if anchor is None:
return False
before = and_showing(nodes)
if not _tap_anchor(nodes, anchor):
return False
if find_node_ci(ui(), "Category") is None: # expanded, not yet in Editor
edit = find_node(ui(), content_desc="Edit")
if edit is not None:
_tap_anchor(ui(), edit)
after = and_showing()
if not and_reach(before, after, "Category", "Schedule"):
return False
and_enter("editor")
return True
def and_reach_category_sheet():
"""Editor -> tap the Category card -> Category bottom sheet ('Select' confirm;
the Editor has 'Save', not 'Select'). Counts ONE surface. True on success."""
nodes = ui()
card = _clickable_ancestor(nodes, find_node(nodes, text="Category"))
if card is None:
return False
before = and_showing(nodes)
if not tap_node(card):
return False
after = and_showing()
if not and_reach(before, after, "Select", "Save"):
return False
and_enter("category_sheet")
return True
def _select_category_in_sheet(cat):
"""From an OPEN category sheet: choose `cat`, confirm with 'Select', then land
back on the Editor. The sheet opens scrolled to the CURRENTLY selected
category, so the wanted row may be off screen; rather than scroll the recycler
(which can overshoot), type `cat` into the sheet's search field to FILTER the
list down to it. Returns True if it ran the sequence."""
row = _card_anchor(ui(), cat)
if row is None:
# filter via the search field (the sole EditText on the sheet)
fields = find_by_class(ui(), "EditText")
if fields:
type_text(fields[0], cat)
settle("tap")
row = _card_anchor(ui(), cat)
if row is None:
return False
# Tapping the row both selects it AND dismisses the search keyboard.
_tap_anchor(ui(), row)
settle("tap")
sel = find_node_ci(ui(), "Select")
if sel is None or not safe_tap(sel):
return False
# Tapping 'Select' DISMISSES the sheet by itself and lands back on the Editor
# (verified: Save reappears, Select is gone). Do NOT press BACK here — that
# would pop the Editor and discard the task.
settle("tap")
return True
def _pick_category_and_save(cat):
"""From an open Editor: open the Category sheet, choose `cat`, Select, Save.
Returns True if it ran the full sequence."""
if not and_reach_category_sheet():
return False
if not _select_category_in_sheet(cat):
return False
save = find_node_ci(ui(), "Save")
if save is None or not safe_tap(save):
return False
settle("tap")
return True
# KEYCODE_MOVE_END / KEYCODE_DEL — used only to clear the time-picker hour field
# via the kit's press_key (never a raw `input`).
_KEY_MOVE_END = 123
_KEY_DEL = 67
def _set_end_time_earlier(hour_str="6", ampm="AM"):
"""From an open Editor, shrink the task by moving its End earlier via the
Material time picker (hour -> `hour_str`, meridiem -> `ampm`). Leaves a real
free block after the task so a SECOND task can be created. Returns True if the
Editor's duration text changed (the edit landed)."""
e = ui()
end = find_node(e, content_desc="End")
if end is None:
return False
dur_before = [n.get("text") for n in e
if (n.get("text") or "").endswith("m") and "h" in (n.get("text") or "")]
if not _tap_anchor(e, end):
return False
settle("tap")
fields = find_by_class(ui(), "EditText") # the hour input
if not fields:
return False
hour = fields[0]
if not tap_node(hour):
return False
settle("keyboard")
press_key(_KEY_MOVE_END)
for _ in range(3):
press_key(_KEY_DEL)
settle("text")
type_text(hour, hour_str, verify_focus=False)
m = find_node_ci(ui(), ampm)
if m is not None:
_tap_anchor(ui(), m)
settle("tap")
ok = find_node_ci(ui(), "OK")
if ok is None or not safe_tap(ok):
return False
settle("tap")
after = ui()
dur_after = [n.get("text") for n in after
if (n.get("text") or "").endswith("m") and "h" in (n.get("text") or "")]
return dur_after != dur_before
def _create_task(cat):
"""Full golden create: from empty Home, Plan now -> Editor -> set category
`cat` -> Save. Leaves the app on Home. Returns True iff the card is present."""
if not and_enter_editor():
return False
if not _pick_category_and_save(cat):
return False
settle("tap")
return _count_category(ui(), cat) >= 1
# ══════════════════════════════════════════════════════════════════════════════
# TESTS
# ══════════════════════════════════════════════════════════════════════════════
# 1) CREATE a task (golden path) + VLM on the rendered card.
@and_test(expects=("interaction_create_task",
"interaction_create_task_running_vlm",
"interaction_create_task_icon_vlm"))
def test_create_task():
if not start_home_clean():
record("interaction_create_task", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect=f"a {CAT_A!r} task card appears on the schedule")
return
before = ui()
absent = (_count_category(before, CAT_A) == 0
and find_node_ci(before, "Nothing planned yet") is not None)
if not and_enter_editor():
record("interaction_create_task", False,
"feature_missing: no create path (Plan now -> free row -> Editor)",
depth=1, jump_kind="transition",
expect="Editor opens for a new task")
return
ran = _pick_category_and_save(CAT_A)
settle("tap")
after = ui()
present = _count_category(after, CAT_A) >= 1
ok = absent and ran and present
record("interaction_create_task", ok,
"" if ok else
(f"behavior_wrong: created task did not appear as a {CAT_A!r} card "
"on the schedule"),
depth=2, jump_kind="transition",
expect=f"{CAT_A!r} task card present on Home (was 'Nothing planned yet')")
# VLM: the default 12:00 AM-11:59 PM task spans NOW, so it renders as a
# running task highlighted with a distinct tinted background.
vlm_assert("interaction_create_task_running",
"There is a task row on the schedule (not the empty 'Nothing planned "
"yet' state). Is that task row visually highlighted with a distinct "
"coloured/tinted background different from the plain page background?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="transition",
tag="color")
# VLM: the card carries a coloured category glyph beside the name.
vlm_assert("interaction_create_task_icon",
"Does the task row on the schedule show a small coloured category "
"icon/symbol (a glyph such as a graduation cap) positioned to the "
"left of the category name text?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="transition",
tag="shape")
# 2) CREATE persists across process death (marquee).
@and_test(expects=("interaction_create_persists",))
def test_create_survives_process_death():
if not start_home_clean():
record("interaction_create_persists", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect=f"{CAT_A!r} task survives process kill")
return
absent_before = _count_category(ui(), CAT_A) == 0
if not _create_task(CAT_A):
record("interaction_create_persists", False,
"feature_missing: could not create a task to test persistence",
depth=2, jump_kind="transition",
expect=f"{CAT_A!r} task survives process kill")
return
# THE probe: kill the process and relaunch. In-memory-only recreations fail.
force_stop_and_relaunch()
ensure_home() # LeakCanary alias can still intercept
present_after = _count_category(ui(), CAT_A) >= 1
ok = absent_before and present_after
record("interaction_create_persists", ok,
"" if ok else
f"behavior_wrong: {CAT_A!r} task did not survive process death",
depth=2, jump_kind="transition",
expect=f"{CAT_A!r} task card still on Home after force_stop_and_relaunch")
# 3) EDIT a task: change category Study -> Health, verify the card updated.
@and_test(expects=("interaction_edit_category",
"interaction_edit_icon_vlm"))
def test_edit_task_category():
if not start_home_clean():
record("interaction_edit_category", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect=f"task category updates {CAT_A}->{CAT_B}")
return
if not _create_task(CAT_A):
record("interaction_edit_category", False,
"feature_missing: could not create the initial task to edit",
depth=2, jump_kind="transition",
expect=f"task category updates {CAT_A}->{CAT_B}")
return
had_study = _count_category(ui(), CAT_A) >= 1
if not and_enter_editor_via_card(CAT_A):
record("interaction_edit_category", False,
"setup_failed: could not reopen the task in the Editor",
depth=2, jump_kind="transition",
expect=f"task category updates {CAT_A}->{CAT_B}")
return
changed = _pick_category_and_save(CAT_B)
settle("tap")
after = ui()
now_health = _count_category(after, CAT_B) >= 1
no_more_study = _count_category(after, CAT_A) == 0
ok = had_study and changed and now_health and no_more_study
record("interaction_edit_category", ok,
"" if ok else
(f"behavior_wrong: editing {CAT_A}->{CAT_B} did not update the card "
f"(health={now_health}, study_gone={no_more_study})"),
depth=2, jump_kind="transition",
expect=f"schedule shows {CAT_B!r} card and no {CAT_A!r} card")
# VLM: the icon changed to a health (cross/heart) glyph.
vlm_assert("interaction_edit_icon",
"The schedule shows one task row. Does its category icon look like a "
"health/medical symbol (a cross or heart) rather than an academic "
"graduation-cap symbol?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="transition",
tag="shape")
# 4) Multi-step schedule build: after saving task #1 the list grows to show the
# task PLUS a new 'Add a task' free-slot add row.
@and_test(expects=("interaction_schedule_grows",
"interaction_schedule_grows_vlm"))
def test_schedule_build_grows():
if not start_home_clean():
record("interaction_schedule_grows", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect="after saving, list shows the task AND a new add row")
return
b = ui()
was_empty = (find_node_ci(b, "Nothing planned yet") is not None
and find_node_ci(b, "Add a task") is None)
if not _create_task(CAT_A):
record("interaction_schedule_grows", False,
"feature_missing: could not create the first task",
depth=2, jump_kind="transition",
expect="after saving, list shows the task AND a new add row")
return
after = ui()
has_task = _count_category(after, CAT_A) >= 1
has_add_row = (find_node_ci(after, "Add a task") is not None
or find_node_ci(after, "Unassigned") is not None)
ok = was_empty and has_task and has_add_row
record("interaction_schedule_grows", ok,
"" if ok else
("behavior_wrong: after saving, expected both the task card and a new "
"add row on the schedule"),
depth=2, jump_kind="transition",
expect=f"schedule shows a {CAT_A!r} card AND an 'Add a task' add row")
# VLM: timeline shows a task block followed by an add row below it.
vlm_assert("interaction_schedule_grows",
"On the schedule/timeline, is there a filled task block near the top "
"and, directly below it, a separate row containing a plus (+) 'add' "
"control (i.e. the list has grown to two stacked rows)?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="transition",
tag="layout")
# 5) Add a SECOND task -> two distinct task cards on the schedule.
@and_test(expects=("interaction_second_task",
"interaction_two_tasks_vlm"))
def test_add_second_task():
if not start_home_clean():
record("interaction_second_task", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect="two task cards on the schedule")
return
# Task #1 must NOT span the whole day, or the only free slot left is a
# zero-length one (Start==End) whose save REPLACES the first task instead of
# adding a second. So build task #1 with an earlier End, leaving a real free
# block for task #2.
if not and_enter_editor():
record("interaction_second_task", False,
"feature_missing: could not open the Editor for the first task",
depth=2, jump_kind="transition",
expect="two task cards on the schedule")
return
_set_end_time_earlier("6", "AM") # Study now ~12:00 AM-6:59 AM
settle("tap")
if not _pick_category_and_save(CAT_A):
record("interaction_second_task", False,
"feature_missing: could not save the first task",
depth=2, jump_kind="transition",
expect="two task cards on the schedule")
return
one = len(_task_card_names(ui()))
if not and_enter_editor(): # opens the Editor on the free slot
record("interaction_second_task", False,
"setup_failed: could not open the Editor for the second task",
depth=2, jump_kind="transition",
expect="two task cards on the schedule")
return
ran = _pick_category_and_save(CAT_B)
settle("tap")
after = ui()
two = len(_task_card_names(after))
ok = ran and one >= 1 and two >= 2 and two > one
record("interaction_second_task", ok,
"" if ok else
(f"behavior_wrong: expected the schedule to grow to >=2 task cards "
f"(had {one}, now {two})"),
depth=2, jump_kind="transition",
expect=f"task-card count rises from {one} to >=2")
# VLM: two distinct task blocks, one positioned ABOVE the other on the
# timeline (a positional property — the second card sits below the first).
vlm_assert("interaction_two_tasks",
"There are two separate coloured task blocks on the schedule, each "
"with its own category name. Is one task block positioned directly "
"ABOVE the other (they are stacked vertically, not overlapping and "
"not side by side)?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="transition",
tag="position")
# 6) Running-task expand controls: tapping the running card reveals the inline
# Add-time / Reduce-the-time / Edit controls that were NOT present collapsed.
# (Note: the 'Increase' desc also sits on the free 'Add a task' add-row even
# when collapsed, so the discriminating controls are the 'Add time' /
# 'Reduce the time' / 'Edit' descs, which appear only when the card expands.)
@and_test(expects=("interaction_running_expand",
"interaction_running_progress_vlm",
"interaction_running_controls_vlm"))
def test_running_task_expand():
if not start_home_clean():
record("interaction_running_expand", False,
"setup_failed: could not reach empty Home",
depth=1, jump_kind="transition",
expect="running task expands to Add-time/Reduce controls")
return
if not _create_task(CAT_A):
record("interaction_running_expand", False,
"feature_missing: could not create a running task",
depth=1, jump_kind="transition",
expect="running task expands to Add-time/Reduce controls")
return
coll = ui()
controls_before = (find_node(coll, content_desc="Reduce the time") is not None
or find_node(coll, content_desc="Add time") is not None
or find_node(coll, content_desc="Edit") is not None)
anchor = _card_anchor(coll, CAT_A)
tapped = _tap_anchor(coll, anchor) if anchor else False
and_enter("expanded_card")
settle("tap")
exp = ui()
add_time = find_node(exp, content_desc="Add time") is not None
reduce_time = find_node(exp, content_desc="Reduce the time") is not None
ok = tapped and (not controls_before) and add_time and reduce_time
record("interaction_running_expand", ok,
"" if ok else
("behavior_wrong: tapping the running task did not reveal both the "
"Add-time and Reduce-the-time controls"),
depth=1, jump_kind="transition",
expect="'Add time' and 'Reduce the time' controls appear after tapping "
"the running card")
# VLM: a partially-filled progress bar spans part-way across the row.
vlm_assert("interaction_running_progress",
"The highlighted task row shows a horizontal progress indicator. Is "
"that progress bar filled only PART of the way across (a partial "
"fill, not empty and not completely full)?",
RESULTS_DIR, expect="YES", depth=1, jump_kind="none",
tag="size")
# VLM: '+ Increase' and '- Reduce' buttons visible side by side.
vlm_assert("interaction_running_controls",
"In the expanded task row, are there two labelled buttons shown side "
"by side, one reading 'Increase' (with a plus) and one reading "
"'Reduce' (with a minus)?",
RESULTS_DIR, expect="YES", depth=1, jump_kind="transition",
tag="layout")
# 7) Cancel does NOT persist: open the free row's Editor, choose a category, then
# Cancel -> no new categorized task card was created.
@and_test(expects=("interaction_cancel_no_persist",))
def test_cancel_discards():
if not start_home_clean():
record("interaction_cancel_no_persist", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="transition",
expect="Cancel discards editor; no new categorized task")
return
before = ui()
no_task_before = len(_task_card_names(before)) == 0
if not and_enter_editor():
record("interaction_cancel_no_persist", False,
"feature_missing: could not open the Editor",
depth=2, jump_kind="transition",
expect="Cancel discards editor; no new categorized task")
return
# choose a category IN the editor, then Cancel -> should discard
if and_reach_category_sheet():
_select_category_in_sheet(CAT_A)
cancel = find_node_ci(ui(), "Cancel")
cancelled = cancel is not None and safe_tap(cancel)
settle("tap")
ensure_home()
after = ui()
no_task_after = len(_task_card_names(after)) == 0
ok = no_task_before and cancelled and no_task_after
record("interaction_cancel_no_persist", ok,
"" if ok else
("behavior_wrong: Cancel did not discard — a categorized task card "
"appeared on the schedule"),
depth=2, jump_kind="transition",
expect="no categorized task card on Home after Cancel")
# 8) Note text entry round-trips inside the Editor. The Note is a Compose
# BasicTextField that does NOT expose its content in the accessibility tree,
# so the observable consequence of a successful entry is the placeholder
# 'Optional' disappearing (shown only while the field is empty). We also read
# the EditText text back in case a recreation DOES expose it.
@and_test(expects=("interaction_note_roundtrip",))
def test_note_text_roundtrip():
if not start_home_clean():
record("interaction_note_roundtrip", False,
"setup_failed: could not reach empty Home",
depth=1, jump_kind="transition",
expect="Note field accepts typed text (placeholder clears)")
return
if not and_enter_editor():
record("interaction_note_roundtrip", False,
"feature_missing: could not open the Editor",
depth=1, jump_kind="transition",
expect="Note field accepts typed text (placeholder clears)")
return
e = ui()
fields = find_by_class(e, "EditText")
placeholder_before = find_node_ci(e, "Optional") is not None
if not fields:
record("interaction_note_roundtrip", False,
"feature_missing: no Note EditText on the Editor",
depth=1, jump_kind="transition",
expect="Note field accepts typed text (placeholder clears)")
return
typed = type_text(fields[0], NOTE_TEXT)
if not typed:
record("interaction_note_roundtrip", False,
"setup_failed: could not focus/type into the Note field",
depth=1, jump_kind="transition",
expect="Note field accepts typed text (placeholder clears)")
return
hide_keyboard()
def _entered():
u = ui()
fresh = find_by_class(u, "EditText")
got = (fresh[0].get("text") if fresh else "") or ""
placeholder_gone = find_node_ci(u, "Optional") is None
return (NOTE_TEXT in got) or placeholder_gone
if not _entered():
# custom field may ignore the ascii paste; retry via ADB Keyboard
type_text(fields[0], NOTE_TEXT, method="ime")
hide_keyboard()
entered = _entered()
ok = placeholder_before and entered
record("interaction_note_roundtrip", ok,
"" if ok else
"behavior_wrong: Note field did not accept typed text "
"(placeholder did not clear and no text read back)",
depth=1, jump_kind="transition",
expect="Note placeholder 'Optional' clears after typing "
f"{NOTE_TEXT!r} (data entered)")
# 9) Category bottom sheet: the currently-selected row is highlighted vs others
# (VLM-only rendered property; the consequence of a selection in the sheet).
@and_test(expects=("interaction_sheet_selected_vlm",))
def test_category_sheet_selection_vlm():
if not start_home_clean():
record("interaction_sheet_selected_vlm", False,
"setup_failed: could not reach empty Home",
depth=2, jump_kind="none", tag="color")
return
if not (and_enter_editor() and and_reach_category_sheet()):
record("interaction_sheet_selected_vlm", False,
"setup_failed: could not open the Category sheet",
depth=2, jump_kind="none", tag="color")
return
row = _card_anchor(ui(), CAT_A) # select 'Study' -> one row selected
if row is not None:
_tap_anchor(ui(), row)
settle("tap")
vlm_assert("interaction_sheet_selected",
"This is a category picker list. Is exactly one category row visibly "
"marked as selected (a filled/checked radio button or a highlighted "
"background) while the other rows are not?",
RESULTS_DIR, expect="YES", depth=2, jump_kind="none",
tag="color")
TESTS = [
test_create_task,
test_create_survives_process_death,
test_edit_task_category,
test_schedule_build_grows,
test_add_second_task,
test_running_task_expand,
test_cancel_discards,
test_note_text_roundtrip,
test_category_sheet_selection_vlm,
]
if __name__ == "__main__":
run_suite(TESTS, "interaction")