| |
| """COMPUTATION lane — Vector Pinball. |
| |
| CORE FUNCTION = the scoring engine: launching the ball + it striking |
| bumpers/targets is the INPUT; the score number rising from 0 is the OUTPUT. That |
| number is drawn on a custom `scoreView` canvas and NEVER reaches the view tree, |
| so the score assertions are legitimately VLM. Scores are NONDETERMINISTIC, so we |
| assert value PROPERTIES that are still specific and falsifiable (== 0 at start, |
| > 0 after play, monotonic within a ball, a comma-formatted rendering, yellow / |
| top-center / large-font rendering) — never an exact number. Two tree-observable |
| computed outputs are also asserted with real values: the Line width numeric |
| round-trip (type N -> echoed N) and the High-Scores "Last Score:" == top |
| score-row identity; the end-of-game bar==Last-Score identity is cross-checked on |
| the VLM track. |
| |
| The top bar is a ROTATING banner: it shows the score most of the time but |
| interrupts it with transient yellow status text ("Ball 3", "2x Multiplier", |
| "Ball Saved", "Touch to start"). A single probe→assert pair is therefore racy, so |
| every numeric-bar assertion first waits for TWO consecutive numeric reads (no |
| banner cycling) before recording. The transient on-field floating "+points" popup |
| is genuinely NOT capturable on demand (a single screencap catches it ~1 time in |
| 8 on this emulator), so it is NOT asserted — its VLM slot is taken by the |
| reliable end-of-game identity/colour checks. |
| |
| This module is the sole owner of jump_kind="value". |
| """ |
| import os |
| import re |
| import sys |
| import time |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from android_testgen_kit import * |
|
|
| |
| NUM_RE = re.compile(r"[0-9][0-9,]*") |
|
|
|
|
| |
| |
| |
| |
| def _play_taps(rounds=6): |
| """Launch the ball and work the flippers/bumpers for `rounds` bursts.""" |
| s = get_screen_info() |
| w, h = s["width"], s["height"] |
| launch_x, launch_y = int(w * 0.5), int(h * 0.55) |
| flip_l_x, flip_l_y = int(w * 0.28), int(h * 0.85) |
| flip_r_x, flip_r_y = int(w * 0.72), int(h * 0.85) |
| bump_x, bump_y = int(w * 0.65), int(h * 0.40) |
| for _ in range(rounds): |
| tap(launch_x, launch_y) |
| time.sleep(0.4) |
| tap(flip_l_x, flip_l_y) |
| time.sleep(0.15) |
| tap(flip_r_x, flip_r_y) |
| time.sleep(0.3) |
| tap(bump_x, bump_y) |
| time.sleep(0.2) |
|
|
|
|
| def _vlm_read_number(image_path): |
| """Ask the VLM to read the top score-bar number; return an int or None. |
| |
| Returns None when the bar shows STATUS text (Ball Saved / 2x Multiplier / |
| Touch to start / etc.) rather than a numeric score. |
| """ |
| ans = call_vlm(image_path, "Read the top bar of this pinball game. If the top " |
| "bar shows WORDS instead of a number (for example 'Ball 3', " |
| "'2x Multiplier', 'Ball Saved' or 'Touch to start'), reply with " |
| "the single word NONE. Otherwise reply with ONLY the digits (no " |
| "commas, no words).") |
| if not ans: |
| return None |
| if "NONE" in ans.upper(): |
| return None |
| digits = re.sub(r"[^0-9]", "", ans) |
| return int(digits) if digits else None |
|
|
|
|
| def _wait_for_stable_numeric_bar(min_val=1, tries=8): |
| """Settle the top bar onto a RESTING numeric frame reading >= `min_val`. |
| |
| Requires TWO consecutive probe reads (spaced ~0.6s) that BOTH show a number |
| >= min_val — which means no banner is currently cycling — then returns at |
| once, so the caller's vlm_assert lands on the still-resting numeric bar. |
| |
| Returns the last numeric value seen (int) or None. When no ball is alive it |
| nudges the flippers/bumpers to keep one in play. |
| """ |
| shot = os.path.join(RESULTS_DIR, "screenshots", "_bar_probe.png") |
| last = None |
| prev_ok = False |
| for _ in range(tries): |
| if not prev_ok: |
| _play_taps(2) |
| time.sleep(2.0) |
| if not screencap(shot): |
| continue |
| val = _vlm_read_number(shot) |
| if val is not None: |
| last = val |
| if val is not None and val >= min_val: |
| if prev_ok: |
| return val |
| prev_ok = True |
| time.sleep(0.6) |
| if screencap(shot): |
| v2 = _vlm_read_number(shot) |
| if v2 is not None: |
| last = v2 |
| if v2 is not None and v2 >= min_val: |
| return v2 |
| prev_ok = False |
| else: |
| prev_ok = False |
| return last |
|
|
|
|
| def and_start_game(): |
| """menu -> gameplay (surface +1). Returns the gameplay tree, or None.""" |
| restart_app() |
| if not wait_for_foreground(10): |
| return None |
| sg = node_by_id(ui(), "startGameButton") |
| if sg is None: |
| return None |
| before = and_showing() |
| tap_node(sg) |
| time.sleep(2) |
| after = and_showing() |
| |
| if not and_reach(before, after, target="pauseIcon", source="START GAME"): |
| return None |
| and_enter("gameplay") |
| return ui() |
|
|
|
|
| def and_start_game_clean(): |
| """Like and_start_game but from wiped data (fresh high-score table).""" |
| clear_data() |
| launch_app() |
| if not wait_for_foreground(10): |
| return None |
| sg = node_by_id(ui(), "startGameButton") |
| if sg is None: |
| return None |
| tap_node(sg) |
| time.sleep(2) |
| and_enter("gameplay") |
| return ui() |
|
|
|
|
| def and_start_game_on_next_table(n_next=1): |
| """menu -> switch table `n_next` times -> gameplay. Returns tree or None.""" |
| restart_app() |
| if not wait_for_foreground(10): |
| return None |
| for _ in range(n_next): |
| nxt = node_by_id(ui(), "nextTableButton") |
| if nxt is None: |
| return None |
| tap_node(nxt) |
| time.sleep(1) |
| sg = node_by_id(ui(), "startGameButton") |
| if sg is None: |
| return None |
| tap_node(sg) |
| time.sleep(2) |
| and_enter("gameplay") |
| return ui() |
|
|
|
|
| def and_reach_high_scores_after_game(): |
| """Play a full game, End Game, then open the High Scores panel (surfaces). |
| |
| Returns the high-score panel tree, or None. depth accrues through gameplay |
| and the panel. |
| """ |
| if and_start_game_clean() is None: |
| return None |
| _play_taps(6) |
| |
| pi = node_by_id(ui(), "pauseIcon") |
| if pi is None: |
| return None |
| tap_node(pi) |
| time.sleep(1) |
| eg = node_by_id(ui(), "endGameButton") |
| if eg is None: |
| return None |
| tap_node(eg) |
| time.sleep(2) |
| |
| hs = node_by_id(ui(), "highScoreButton") |
| if hs is None: |
| return None |
| if not and_reach_surface(hs, target="highScorePanel", source="START GAME"): |
| return None |
| return ui() |
|
|
|
|
| def and_enter_line_width_dialog(): |
| """menu -> Preferences -> Line width dialog (surfaces +2). |
| |
| Returns the sole EditText node in the open dialog, or None. |
| """ |
| restart_app() |
| if not wait_for_foreground(10): |
| return None |
| pref = node_by_id(ui(), "preferencesButton") |
| if pref is None: |
| return None |
| tap_node(pref) |
| time.sleep(1.5) |
| and_enter("preferences") |
| row = scroll_into_view("Line width") |
| if row is None: |
| return None |
| tap_node(row) |
| time.sleep(1) |
| and_enter("line_width_dialog") |
| et = find_by_class(ui(), "EditText") |
| return et[0] if et else None |
|
|
|
|
| |
| @and_test(expects=("computation_score_zero_at_start_vlm",)) |
| def test_score_zero_at_start(): |
| if and_start_game() is None: |
| record("computation_score_zero_at_start_vlm", False, |
| "setup_failed: could not enter gameplay", depth=1, |
| jump_kind="value", tag="content") |
| return |
| vlm_assert("computation_score_zero_at_start", |
| "Look at the top score bar of this pinball game. Does the score " |
| "read exactly 0 (zero)?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_score_positive_after_play_vlm",)) |
| def test_score_positive_after_play(): |
| if and_start_game() is None: |
| record("computation_score_positive_after_play_vlm", False, |
| "setup_failed: could not enter gameplay", depth=1, |
| jump_kind="value", tag="content") |
| return |
| _play_taps(6) |
| |
| |
| val = _wait_for_stable_numeric_bar(min_val=1) |
| if not (val and val > 0): |
| _play_taps(6) |
| _wait_for_stable_numeric_bar(min_val=1) |
| vlm_assert("computation_score_positive_after_play", |
| "Look at the top score bar of this pinball game. Is the displayed " |
| "score a number strictly greater than zero (i.e. NOT 0)?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_score_monotonic_vlm",)) |
| def test_score_monotonic(): |
| if and_start_game() is None: |
| record("computation_score_monotonic_vlm", False, |
| "setup_failed: could not enter gameplay", depth=1, |
| jump_kind="value", tag="content") |
| return |
| _play_taps(3) |
| first_val = _wait_for_stable_numeric_bar(min_val=1) |
| _play_taps(4) |
| |
| |
| _wait_for_stable_numeric_bar(min_val=(first_val or 0) + 1) |
| baseline = first_val if (first_val is not None) else 0 |
| vlm_assert("computation_score_monotonic", |
| "Look at the top score bar of this pinball game. Is the displayed " |
| f"score a number GREATER than {baseline}?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="content") |
|
|
|
|
| |
| |
| |
| @and_test(expects=("computation_endgame_bar_matches_lastscore_vlm",)) |
| def test_endgame_bar_matches_lastscore(): |
| if and_reach_high_scores_after_game() is None: |
| record("computation_endgame_bar_matches_lastscore_vlm", False, |
| "setup_failed: could not play a game and open High Scores", depth=2, |
| jump_kind="value", tag="content") |
| return |
| vlm_assert("computation_endgame_bar_matches_lastscore", |
| "This screenshot shows a pinball High Scores dialog. The thin status " |
| "strip across the very top of the screen shows a number, and inside " |
| "the dialog there is a 'Last Score:' line with a number. Are those two " |
| "numbers equal to each other?", |
| RESULTS_DIR, depth=2, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_highscore_bar_yellow_vlm",)) |
| def test_highscore_bar_yellow(): |
| if and_reach_high_scores_after_game() is None: |
| record("computation_highscore_bar_yellow_vlm", False, |
| "setup_failed: could not play a game and open High Scores", depth=2, |
| jump_kind="value", tag="color") |
| return |
| vlm_assert("computation_highscore_bar_yellow", |
| "Look at the thin status strip across the very top of this screen " |
| "(above the 'High scores' dialog). It contains a short label followed " |
| "by a number. Are those characters, INCLUDING the number, rendered in " |
| "a YELLOW color?", |
| RESULTS_DIR, depth=2, jump_kind="value", tag="color") |
|
|
|
|
| |
| @and_test(expects=("computation_score_bar_yellow_vlm",)) |
| def test_score_bar_yellow(): |
| if and_start_game() is None: |
| record("computation_score_bar_yellow_vlm", False, |
| "setup_failed: could not enter gameplay", depth=1, |
| jump_kind="value", tag="color") |
| return |
| _play_taps(5) |
| _wait_for_stable_numeric_bar(min_val=1) |
| vlm_assert("computation_score_bar_yellow", |
| "Look at the number shown in the top score bar of this pinball " |
| "game. Are those score digits rendered in a YELLOW color?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="color") |
|
|
|
|
| |
| @and_test(expects=("computation_score_large_font_vlm",)) |
| def test_score_large_font(): |
| if and_start_game() is None: |
| record("computation_score_large_font_vlm", False, |
| "setup_failed: could not enter gameplay", depth=1, |
| jump_kind="value", tag="size") |
| return |
| _play_taps(5) |
| _wait_for_stable_numeric_bar(min_val=1) |
| vlm_assert("computation_score_large_font", |
| "Look at the top bar of this pinball game. Is the score number " |
| "rendered in a LARGE font, clearly larger than the small circular " |
| "icons in the corners of the same top bar?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="size") |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| COMMA_GROUP_RE = re.compile(r"[0-9]{1,3}(,[0-9]{3})*") |
|
|
|
|
| @and_test(expects=("computation_score_comma_formatted",)) |
| def test_score_comma_formatted(): |
| n = and_reach_high_scores_after_game() |
| if n is None: |
| record("computation_score_comma_formatted", False, |
| "setup_failed: could not play a game and open High Scores", depth=2, |
| jump_kind="value", |
| expect="high-score row uses comma grouping (comma iff value>=1000)") |
| return |
| texts = [x.get("text", "").strip() for x in n if x.get("text", "").strip()] |
| rows = [t for t in texts |
| if NUM_RE.fullmatch(t) and not t.lower().startswith("last score")] |
| if not rows: |
| record("computation_score_comma_formatted", False, |
| f"feature_missing: no bare numeric score row (texts={texts})", |
| depth=2, jump_kind="value", |
| expect="high-score row uses comma grouping (comma iff value>=1000)") |
| return |
| row = rows[0] |
| well_formed = COMMA_GROUP_RE.fullmatch(row) is not None |
| val = int(row.replace(",", "")) |
| comma_iff_big = ("," in row) == (val >= 1000) |
| ok = well_formed and comma_iff_big |
| record("computation_score_comma_formatted", ok, |
| "" if ok else (f"behavior_wrong: score row {row!r} is not correctly " |
| f"comma-grouped (well_formed={well_formed}, " |
| f"comma_iff>=1000={comma_iff_big})"), |
| depth=2, jump_kind="value", |
| expect=f"score row {row!r}: \\d{{1,3}}(,\\d{{3}})* with comma iff >=1000") |
|
|
|
|
| |
| @and_test(expects=("computation_table2_zero_at_start_vlm",)) |
| def test_table2_zero_at_start(): |
| if and_start_game_on_next_table(1) is None: |
| record("computation_table2_zero_at_start_vlm", False, |
| "setup_failed: could not switch table and start game", depth=1, |
| jump_kind="value", tag="content") |
| return |
| vlm_assert("computation_table2_zero_at_start", |
| "Look at the top score bar of this pinball game. Does the score " |
| "read exactly 0 (zero)?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_table2_positive_after_play_vlm",)) |
| def test_table2_positive_after_play(): |
| if and_start_game_on_next_table(1) is None: |
| record("computation_table2_positive_after_play_vlm", False, |
| "setup_failed: could not switch table and start game", depth=1, |
| jump_kind="value", tag="content") |
| return |
| _play_taps(6) |
| val = _wait_for_stable_numeric_bar(min_val=1) |
| if not (val and val > 0): |
| _play_taps(6) |
| _wait_for_stable_numeric_bar(min_val=1) |
| vlm_assert("computation_table2_positive_after_play", |
| "Look at the top score bar of this pinball game. Is the displayed " |
| "score a number strictly greater than zero (i.e. NOT 0)?", |
| RESULTS_DIR, depth=1, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_endgame_total_reflected_vlm",)) |
| def test_endgame_total_reflected(): |
| if and_reach_high_scores_after_game() is None: |
| record("computation_endgame_total_reflected_vlm", False, |
| "setup_failed: could not play a game and open High Scores", depth=2, |
| jump_kind="value", tag="content") |
| return |
| |
| vlm_assert("computation_endgame_total_reflected", |
| "Look at the very top bar of this screen (it starts with 'High " |
| "Score:'). Does it show a number that is greater than zero?", |
| RESULTS_DIR, depth=2, jump_kind="value", tag="content") |
|
|
|
|
| |
| @and_test(expects=("computation_last_score_matches_row",)) |
| def test_last_score_matches_row(): |
| n = and_reach_high_scores_after_game() |
| if n is None: |
| record("computation_last_score_matches_row", False, |
| "setup_failed: could not play a game and open High Scores", depth=2, |
| jump_kind="value", |
| expect="'Last Score: N' number == the numeric high-score row N") |
| return |
| texts = [x.get("text", "").strip() for x in n if x.get("text", "").strip()] |
| last_rows = [t for t in texts if t.lower().startswith("last score")] |
| |
| num_rows = [t for t in texts |
| if NUM_RE.fullmatch(t) and not t.lower().startswith("last score")] |
| if not last_rows: |
| record("computation_last_score_matches_row", False, |
| f"feature_missing: no 'Last Score:' row (texts={texts})", depth=2, |
| jump_kind="value", |
| expect="'Last Score: N' number == the numeric high-score row N") |
| return |
| if not num_rows: |
| record("computation_last_score_matches_row", False, |
| f"feature_missing: no bare numeric score row (texts={texts})", |
| depth=2, jump_kind="value", |
| expect="'Last Score: N' number == the numeric high-score row N") |
| return |
| last_num = re.sub(r"[^0-9]", "", NUM_RE.search(last_rows[0]).group(0)) |
| row_nums = {re.sub(r"[^0-9]", "", r) for r in num_rows} |
| ok = last_num in row_nums and last_num != "" |
| record("computation_last_score_matches_row", ok, |
| "" if ok else (f"behavior_wrong: Last Score {last_num!r} not among " |
| f"score rows {row_nums!r}"), |
| depth=2, jump_kind="value", |
| expect=f"'Last Score:' number ({last_num}) equals a high-score row") |
|
|
|
|
| |
| @and_test(expects=("computation_linewidth_roundtrip_12",)) |
| def test_linewidth_roundtrip_12(): |
| et = and_enter_line_width_dialog() |
| if et is None: |
| record("computation_linewidth_roundtrip_12", False, |
| "setup_failed: Line width dialog / EditText unreachable", depth=2, |
| jump_kind="value", expect="Line width EditText echoes '12'") |
| return |
| |
| type_text(et, "12") |
| fresh = find_by_class(ui(), "EditText") |
| got = (fresh[0].get("text", "") if fresh else "").strip() |
| got_digits = re.sub(r"[^0-9]", "", got) |
| ok = got_digits == "12" |
| record("computation_linewidth_roundtrip_12", ok, |
| "" if ok else f"behavior_wrong: EditText shows {got!r}, expected '12'", |
| depth=2, jump_kind="value", expect="Line width EditText echoes '12'") |
|
|
|
|
| |
| @and_test(expects=("computation_linewidth_roundtrip_0",)) |
| def test_linewidth_roundtrip_0(): |
| et = and_enter_line_width_dialog() |
| if et is None: |
| record("computation_linewidth_roundtrip_0", False, |
| "setup_failed: Line width dialog / EditText unreachable", depth=2, |
| jump_kind="value", expect="Line width EditText echoes '0'") |
| return |
| type_text(et, "0") |
| fresh = find_by_class(ui(), "EditText") |
| got = (fresh[0].get("text", "") if fresh else "").strip() |
| got_digits = re.sub(r"[^0-9]", "", got) |
| ok = got_digits == "0" |
| record("computation_linewidth_roundtrip_0", ok, |
| "" if ok else f"behavior_wrong: EditText shows {got!r}, expected '0'", |
| depth=2, jump_kind="value", expect="Line width EditText echoes '0'") |
|
|
|
|
| TESTS = [ |
| test_score_zero_at_start, |
| test_score_positive_after_play, |
| test_score_monotonic, |
| test_endgame_bar_matches_lastscore, |
| test_highscore_bar_yellow, |
| test_score_bar_yellow, |
| test_score_large_font, |
| test_score_comma_formatted, |
| test_table2_zero_at_start, |
| test_table2_positive_after_play, |
| test_endgame_total_reflected, |
| test_last_score_matches_row, |
| test_linewidth_roundtrip_12, |
| test_linewidth_roundtrip_0, |
| ] |
|
|
| if __name__ == "__main__": |
| if not device_online(): |
| print("Device offline — aborting; a whole module of setup_failed usually " |
| "means the emulator/tunnel dropped, not that the app is broken.") |
| run_suite(TESTS, "computation") |
|
|
