| """STRUCTURE lane — PyPlayer 0.6.0 beta (PyQt5 + libVLC) UIA suite.
|
|
|
| This module owns exactly two things and nothing else:
|
|
|
| 1. the GATE (``jump_kind="none"``, 3 of 12 tests) — the app's top-level surfaces are
|
| present at launch, plus one genuine geometry/layout check;
|
| 2. tree-SHAPE deltas — an interaction that changes the SHAPE of the widget tree:
|
| a control-type count changes (a view toggle adds/removes widgets, a mode switch
|
| adds a readout) or a new top-level window appears (a Qt dialog).
|
|
|
| Shape only. Never content, never CHECKED, never wording, never a window rectangle —
|
| those belong to the text / state / computation / menu / button lanes.
|
|
|
| How shape is measured here: per-control-type counts,
|
| ``len(rb_uia.find_all(app, control_type=...))``, corroborated by the total node count
|
| ``len(app.descendants())``. ``rb_showing()`` is NOT a shape metric for this app: most
|
| dock widgets have an empty UIA name, so four spinners collapse into a single
|
| ``"Spinner|"`` key (recon 0.7). It is used (via ``showing_all``) only for the NAMED
|
| things — the dialog windows and menu items. Absolute totals are never asserted; only
|
| the delta and the per-type change, because a faithful recreation may legitimately
|
| carry a different absolute node count.
|
| """
|
| import os
|
| import time
|
|
|
| import pytest
|
| import rb_uia
|
| from rb_uia import rb_showing, rb_reach, rb_flip, rb_value
|
|
|
| TOP_MENUS = ("File", "Edit", "Video", "Audio", "Window", "Player", "Help")
|
|
|
|
|
| def fixtures_dir():
|
| """FIXTURES_DIR when the eval runner sets it, else <parent-of-results>/fixtures."""
|
| d = os.environ.get("FIXTURES_DIR")
|
| if d and os.path.isdir(d):
|
| return d
|
| rd = os.environ.get("RB_RESULTS_DIR") or os.environ.get("RESULTS_DIR") or "."
|
| cand = os.path.join(os.path.dirname(os.path.abspath(rd)), "fixtures")
|
| if os.path.isdir(cand):
|
| return cand
|
| return os.path.join(os.path.abspath(rd), "fixtures")
|
|
|
|
|
| def find_ctl(root, control_type=None, name=None, aid_suffix=None):
|
| """Locate ONE control. Prefers visible name + control_type (framework independent);
|
| falls back to the Qt objectName tail only for the icon-only widgets that expose no name."""
|
| els = rb_uia.find_all(root, control_type=control_type) or []
|
| if name is not None:
|
| for e in els:
|
| try:
|
| if (e.window_text() or "") == name:
|
| return e
|
| except Exception:
|
| pass
|
| if aid_suffix is not None:
|
| for e in els:
|
| try:
|
| aid = e.element_info.automation_id or ""
|
| if aid.split(".")[-1] == aid_suffix:
|
| return e
|
| except Exception:
|
| pass
|
| return None
|
|
|
|
|
| def ctl_value(el):
|
| """Read a widget's UIA value (works for Edit / Slider / Spinner / QLabel)."""
|
| if el is None:
|
| return None
|
| try:
|
| v = el.legacy_properties().get("Value")
|
| if v not in (None, ""):
|
| return v
|
| except Exception:
|
| pass
|
| try:
|
| return el.window_text() or ""
|
| except Exception:
|
| return None
|
|
|
|
|
| def status_text(app):
|
| """Text currently shown on the QStatusBar ('' when empty)."""
|
| for sbar in rb_uia.find_all(app, control_type="StatusBar") or []:
|
| try:
|
| return " ".join(t for t in sbar.texts() if t)
|
| except Exception:
|
| return ""
|
| return ""
|
|
|
|
|
| def other_windows(app):
|
| """Top-level windows of the app's process other than the main window (Qt dialogs)."""
|
| from pywinauto import Desktop
|
| out = []
|
| try:
|
| pid, h = app.process_id(), app.handle
|
| except Exception:
|
| return out
|
| try:
|
| for w in Desktop(backend="uia").windows():
|
| try:
|
| if w.process_id() == pid and w.handle != h:
|
| out.append(w)
|
| except Exception:
|
| pass
|
| except Exception:
|
| pass
|
| return out
|
|
|
|
|
| def showing_all(app):
|
| """rb_showing(app) UNION every sibling top-level window (needed for Qt dialogs)."""
|
| s = set(rb_showing(app))
|
| for w in other_windows(app):
|
| try:
|
| s.add("Window|%s" % (w.window_text() or ""))
|
| s |= rb_showing(w)
|
| except Exception:
|
| pass
|
| return s
|
|
|
|
|
| def dialog_named(app, title, timeout=8.0):
|
| """Wait for and return the app-owned top-level window whose title contains `title`."""
|
| deadline = time.time() + timeout
|
| while time.time() < deadline:
|
| for w in other_windows(app):
|
| try:
|
| if title.lower() in (w.window_text() or "").lower():
|
| return w
|
| except Exception:
|
| pass
|
| time.sleep(0.3)
|
| return None
|
|
|
|
|
| def menu_item(app, label):
|
| """A currently-visible QMenu/QMenuBar item with this exact label."""
|
| for m in rb_uia.find_all(app, control_type="MenuItem") or []:
|
| try:
|
| if (m.window_text() or "") == label:
|
| return m
|
| except Exception:
|
| pass
|
| return None
|
|
|
|
|
| def close_menus():
|
| rb_uia.key("{ESC}")
|
| time.sleep(0.25)
|
| rb_uia.key("{ESC}")
|
| time.sleep(0.25)
|
|
|
|
|
| def open_menu(app, top):
|
| """Click a top-level menu; returns True when its popup is up."""
|
| close_menus()
|
| m = menu_item(app, top)
|
| if m is None:
|
| return False
|
| m.click_input()
|
| time.sleep(0.5)
|
| return True
|
|
|
|
|
| def click_menu_item(app, label):
|
| it = menu_item(app, label)
|
| if it is None:
|
| return False
|
| it.click_input()
|
| time.sleep(0.5)
|
| return True
|
|
|
|
|
|
|
| def rb_enter_menu(rb, app, top):
|
| """Open a top-level menu (surface crossing #1)."""
|
| ok = open_menu(app, top)
|
| if ok:
|
| rb.enter("menu:%s" % top)
|
| return ok
|
|
|
|
|
| def rb_enter_submenu(rb, app, label):
|
| """Open a submenu inside an already-open menu (surface crossing #2)."""
|
| ok = click_menu_item(app, label)
|
| if ok:
|
| rb.enter("submenu:%s" % label)
|
| return ok
|
|
|
|
|
| def rb_reach_media(rb, app, fixture):
|
| """Drive the app into its PRIMARY working state: File > Open... -> native dialog ->
|
| type the fixture path -> Enter -> media loaded. Two surface crossings (menu, dialog).
|
| Returns True once the window title shows the fixture name."""
|
| if not open_menu(app, "File"):
|
| return False
|
| rb.enter("menu:File")
|
| if not click_menu_item(app, "Open..."):
|
| return False
|
| rb.enter("dialog:open")
|
| time.sleep(1.5)
|
| edit = None
|
| deadline = time.time() + 10
|
| while time.time() < deadline and edit is None:
|
| edit = find_ctl(app, control_type="Edit", name="File name:")
|
| if edit is None:
|
| time.sleep(0.4)
|
| path = os.path.join(fixtures_dir(), fixture)
|
| if edit is not None:
|
| edit.click_input()
|
| time.sleep(0.2)
|
| try:
|
| edit.set_edit_text(path)
|
| except Exception:
|
| rb_uia.type_text(path)
|
| else:
|
|
|
|
|
|
|
|
|
| dialog_up = (find_ctl(app, control_type="Button", name="Cancel") is not None
|
| or find_ctl(app, control_type="Button", name="Open") is not None
|
| or bool(other_windows(app)))
|
| if not dialog_up:
|
| return False
|
| rb_uia.type_text(path)
|
| time.sleep(0.3)
|
| rb_uia.key("{ENTER}")
|
|
|
| deadline = time.time() + 12
|
| while time.time() < deadline:
|
| try:
|
| if fixture in (app.window_text() or ""):
|
| time.sleep(1.0)
|
| return True
|
| except Exception:
|
| pass
|
| time.sleep(0.4)
|
| return False
|
|
|
|
|
| def settle_media(seconds=5.0):
|
| """rb_silent.mp4 autoplays; after ~5 s it parks at its LAST frame — a deterministic
|
| state (time 00:04.00, progress 39, spinSecond 4, spinFrame '10 FPS: 39')."""
|
| time.sleep(seconds)
|
|
|
|
|
|
|
|
|
|
|
| def count_type(root, control_type):
|
| """How many nodes of one control_type live under `root` RIGHT NOW.
|
| This is THE framework-independent shape metric for this app."""
|
| return len(rb_uia.find_all(root, control_type=control_type) or [])
|
|
|
|
|
| def count_nodes(root):
|
| """Total node count of the tree under `root` (-1 when the walk itself fails)."""
|
| try:
|
| return len(root.descendants())
|
| except Exception:
|
| return -1
|
|
|
|
|
| def classify_sliders(root):
|
| """(horizontal, vertical) slider counts, told apart by their OWN geometry: the
|
| progress slider is wider than tall, the volume slider is taller than wide.
|
| Lets a test prove WHICH slider vanished without naming any framework internal."""
|
| horizontal = vertical = 0
|
| for s in rb_uia.find_all(root, control_type="Slider") or []:
|
| try:
|
| r = s.rectangle()
|
| w, h = r.right - r.left, r.bottom - r.top
|
| except Exception:
|
| continue
|
| if w > h:
|
| horizontal += 1
|
| elif h > w:
|
| vertical += 1
|
| return horizontal, vertical
|
|
|
|
|
| def top_of(root, control_type, pick="min"):
|
| """Top edge (y) of the requested control_type: the highest one, or the top of the
|
| largest-area one when pick='largest'. None when there is no such control."""
|
| best_top, best_area = None, -1
|
| for el in rb_uia.find_all(root, control_type=control_type) or []:
|
| try:
|
| r = el.rectangle()
|
| except Exception:
|
| continue
|
| area = max(0, r.right - r.left) * max(0, r.bottom - r.top)
|
| if pick == "largest":
|
| if area > best_area:
|
| best_area, best_top = area, r.top
|
| elif best_top is None or r.top < best_top:
|
| best_top = r.top
|
| return best_top
|
|
|
|
|
| def _norm_label(text):
|
| """Menu labels, tolerantly: drop mnemonics, unify '…' with '...', drop trailing dots."""
|
| s = (text or "").replace("&", "").replace("…", "...").strip()
|
| while s.endswith("."):
|
| s = s[:-1]
|
| return s.strip().lower()
|
|
|
|
|
| def menu_item_like(app, wanted, avoid=()):
|
| """menu_item() first (exact visible label), then a tolerant match that ignores
|
| mnemonics and trailing dots — 'About...' vs 'About…' must not decide a test."""
|
| exact = menu_item(app, wanted)
|
| if exact is not None:
|
| return exact
|
| target = _norm_label(wanted)
|
| skip = set(_norm_label(a) for a in avoid)
|
| for m in rb_uia.find_all(app, control_type="MenuItem") or []:
|
| try:
|
| label = _norm_label(m.window_text())
|
| except Exception:
|
| continue
|
| if label and label == target and label not in skip:
|
| return m
|
| return None
|
|
|
|
|
| def click_menu_item_like(app, wanted, avoid=()):
|
| it = menu_item_like(app, wanted, avoid)
|
| if it is None:
|
| return False
|
| it.click_input()
|
| time.sleep(0.5)
|
| return True
|
|
|
|
|
| def toggle_window_option(rb, app, label):
|
| """Flip one `Window`-menu view option through the real user path: open the Window
|
| menu (a surface crossing), click the item, the popup closes again."""
|
| if not rb_enter_menu(rb, app, "Window"):
|
| return False
|
| ok = click_menu_item_like(app, label)
|
| rb.back()
|
| time.sleep(0.7)
|
| return ok
|
|
|
|
|
| def leave_fullscreen(app, attempts=3):
|
| """{ESC} is the only way back out of fullscreen — the menu bar is hidden there."""
|
| for i in range(attempts):
|
| if i:
|
| try:
|
| rb_uia.focus_app_window(app)
|
| except Exception:
|
| pass
|
| time.sleep(0.3)
|
| rb_uia.key("{ESC}")
|
| time.sleep(1.2)
|
| if count_type(app, "MenuBar") > 0:
|
| return True
|
| return False
|
|
|
|
|
| def exit_crop_mode(app, baseline_texts, attempts=3):
|
| """`c` leaves crop mode. The menu route back does not exist: crop mode hides the
|
| menu bar and the window refuses to re-show it while crop is active."""
|
| for _ in range(attempts):
|
| try:
|
| rb_uia.focus_app_window(app)
|
| except Exception:
|
| pass
|
| time.sleep(0.2)
|
| rb_uia.key("c")
|
| time.sleep(1.0)
|
| if count_type(app, "Text") == baseline_texts:
|
| return True
|
| return False
|
|
|
|
|
| def click_dialog_ok(dlg):
|
| """Dismiss a Qt dialog through its own OK button ({ESC} only as a last resort)."""
|
| if dlg is None:
|
| rb_uia.key("{ESC}")
|
| time.sleep(0.4)
|
| return False
|
| btn = find_ctl(dlg, control_type="Button", name="OK")
|
| if btn is not None:
|
| try:
|
| btn.click_input()
|
| time.sleep(0.8)
|
| return True
|
| except Exception:
|
| pass
|
| rb_uia.key("{ESC}")
|
| time.sleep(0.4)
|
| return False
|
|
|
|
|
|
|
|
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="none", depth=0,
|
| expect="main window carries a non-empty title and an application MenuBar hosting the 7 "
|
| "menus File Edit Video Audio Window Player Help, left to right")
|
| def test_gate_window_hosts_seven_top_menus(app, rb):
|
|
|
|
|
| steps, title, n_menubars, captions = [], None, None, None
|
| try:
|
| title = app.window_text() or ""
|
| except Exception as e:
|
| steps.append("read window title raised: %r" % (e,))
|
| try:
|
| n_menubars = count_type(app, "MenuBar")
|
| except Exception as e:
|
| steps.append("count MenuBar raised: %r" % (e,))
|
| try:
|
| placed = []
|
| for m in rb_uia.find_all(app, control_type="MenuItem") or []:
|
| try:
|
| label = m.window_text() or ""
|
| if label == "System":
|
| continue
|
| placed.append((m.rectangle().left, label))
|
| except Exception:
|
| pass
|
| captions = [t for _, t in sorted(placed)]
|
| except Exception as e:
|
| steps.append("enumerate menu-bar MenuItems raised: %r" % (e,))
|
|
|
| assert (title not in (None, "") and (n_menubars or 0) >= 1
|
| and captions == list(TOP_MENUS)), (
|
| "title=%r menubars=%r captions=%r (expected %r left-to-right) steps=%s"
|
| % (title, n_menubars, captions, list(TOP_MENUS), steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="none", depth=0,
|
| expect="launch tree holds all four principal surfaces at once: MenuBar, the media "
|
| "Group, the control dock (2 Sliders / 4 Spinners / >=6 CheckBoxes incl. "
|
| "'Delete originals' and 'Skip marked files') and one StatusBar")
|
| def test_gate_principal_surfaces_coexist(app, rb, results_dir):
|
| steps, counts, checkbox_names = [], {}, []
|
| for ct in ("MenuBar", "Group", "StatusBar", "Slider", "Spinner", "CheckBox"):
|
| try:
|
| counts[ct] = count_type(app, ct)
|
| except Exception as e:
|
| counts[ct] = -1
|
| steps.append("count %s raised: %r" % (ct, e))
|
| try:
|
| for c in rb_uia.find_all(app, control_type="CheckBox") or []:
|
| try:
|
| checkbox_names.append(c.window_text() or "")
|
| except Exception:
|
| pass
|
| except Exception as e:
|
| steps.append("read CheckBox names raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_gate_launch_surfaces",
|
| "PyPlayer at launch in its dark 'Midnight' theme: a black playback area with "
|
| "the VLC traffic-cone logo centred, a menu row reading File Edit Video Audio "
|
| "Window Player Help across the top, a thin rainbow-gradient progress bar with "
|
| "a '--:--' time label at each end, and a bottom control dock holding round "
|
| "playback buttons, hour/minute/second/frame spin boxes, 'Start' and 'End' trim "
|
| "buttons and the 'Delete originals' / 'Skip marked files' checkboxes, with a "
|
| "narrow status bar along the very bottom edge.",
|
| results_dir, window=app)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
|
|
| ok = (counts.get("MenuBar", 0) >= 1
|
| and counts.get("Group", 0) >= 1
|
| and counts.get("StatusBar", 0) == 1
|
| and counts.get("Slider", 0) == 2
|
| and counts.get("Spinner", 0) == 4
|
| and counts.get("CheckBox", 0) >= 6
|
| and "Delete originals" in checkbox_names
|
| and "Skip marked files" in checkbox_names)
|
| assert ok, ("counts=%r (want MenuBar>=1, Group>=1, StatusBar==1, Slider==2, "
|
| "Spinner==4, CheckBox>=6) checkbox names=%r steps=%s"
|
| % (counts, checkbox_names, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="none", depth=0,
|
| expect="vertical stacking menu bar < media surface < progress slider < spin-box row "
|
| "< status bar, with the progress slider horizontal (>50% of the window width) "
|
| "and the volume slider vertical")
|
| def test_layout_vertical_stacking_and_slider_orientation(app, rb):
|
| steps, tops, geom = [], {}, {}
|
| for key, ct, pick in (("menubar", "MenuBar", "min"),
|
| ("media", "Group", "largest"),
|
| ("spins", "Spinner", "min"),
|
| ("statusbar", "StatusBar", "min")):
|
| try:
|
| tops[key] = top_of(app, ct, pick=pick)
|
| except Exception as e:
|
| tops[key] = None
|
| steps.append("top of %s raised: %r" % (ct, e))
|
| try:
|
| for s in rb_uia.find_all(app, control_type="Slider") or []:
|
| r = s.rectangle()
|
| w, h = r.right - r.left, r.bottom - r.top
|
| geom["progress" if w > h else "volume"] = (r.top, w, h)
|
| except Exception as e:
|
| steps.append("measure sliders raised: %r" % (e,))
|
| try:
|
| wr = app.rectangle()
|
| geom["window_w"] = wr.right - wr.left
|
| except Exception as e:
|
| geom["window_w"] = None
|
| steps.append("read window rect raised: %r" % (e,))
|
|
|
| prog, vol, win_w = geom.get("progress"), geom.get("volume"), geom.get("window_w")
|
| order_known = (all(tops.get(k) is not None
|
| for k in ("menubar", "media", "spins", "statusbar"))
|
| and prog is not None and vol is not None and win_w)
|
| ok = bool(order_known
|
| and tops["menubar"] < tops["media"] < prog[0] < tops["spins"] < tops["statusbar"]
|
| and prog[1] > prog[2] and prog[1] > 0.5 * win_w
|
| and vol[2] > vol[1])
|
| assert ok, ("tops=%r progress(top,w,h)=%r volume(top,w,h)=%r window_w=%r steps=%s"
|
| % (tops, prog, vol, win_w, steps))
|
|
|
|
|
|
|
|
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="Window > Status Bar deletes the status bar from the tree: StatusBar count "
|
| "1 -> 0 and the total node count drops; toggling it on again brings both back")
|
| def test_status_bar_toggle_removes_status_bar_node(app, rb):
|
| steps = []
|
| sb_before = sb_off = sb_back = None
|
| total_before = total_off = total_back = None
|
| hid = shown = False
|
| try:
|
| sb_before, total_before = count_type(app, "StatusBar"), count_nodes(app)
|
| except Exception as e:
|
| steps.append("baseline count raised: %r" % (e,))
|
| try:
|
| hid = toggle_window_option(rb, app, "Status Bar")
|
| if not hid:
|
| steps.append("nav: 'Status Bar' not clickable in the Window menu")
|
| except Exception as e:
|
| steps.append("Window > Status Bar (off) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| sb_off, total_off = count_type(app, "StatusBar"), count_nodes(app)
|
| except Exception as e:
|
| steps.append("count after hiding raised: %r" % (e,))
|
| try:
|
| shown = toggle_window_option(rb, app, "Status Bar")
|
| if not shown:
|
| steps.append("nav: could not re-enable 'Status Bar'")
|
| except Exception as e:
|
| steps.append("Window > Status Bar (on) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| sb_back, total_back = count_type(app, "StatusBar"), count_nodes(app)
|
| except Exception as e:
|
| steps.append("count after restoring raised: %r" % (e,))
|
|
|
| assert (rb_flip(sb_before, sb_off) and hid and shown
|
| and sb_before == 1 and sb_off == 0 and sb_back == sb_before
|
| and total_off < total_before and total_back > total_off), (
|
| "StatusBar count %r -> %r -> %r (want 1 -> 0 -> 1); total %r -> %r -> %r "
|
| "(want a drop then a recovery); clicked_off=%r clicked_on=%r steps=%s"
|
| % (sb_before, sb_off, sb_back, total_before, total_off, total_back,
|
| hid, shown, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="Window > Progress Bar removes the horizontal progress slider only: sliders "
|
| "(h,v) (1,1) -> (0,1) — the vertical volume slider survives — and (1,1) again "
|
| "after switching it back on")
|
| def test_progress_bar_toggle_removes_only_the_horizontal_slider(app, rb):
|
| steps = []
|
| before = off = back = None
|
| total_before = total_off = None
|
| hid = shown = False
|
| try:
|
| before, total_before = classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("baseline slider census raised: %r" % (e,))
|
| try:
|
| hid = toggle_window_option(rb, app, "Progress Bar")
|
| if not hid:
|
| steps.append("nav: 'Progress Bar' not clickable in the Window menu")
|
| except Exception as e:
|
| steps.append("Window > Progress Bar (off) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| off, total_off = classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("slider census after hiding raised: %r" % (e,))
|
| try:
|
| shown = toggle_window_option(rb, app, "Progress Bar")
|
| if not shown:
|
| steps.append("nav: could not re-enable 'Progress Bar'")
|
| except Exception as e:
|
| steps.append("Window > Progress Bar (on) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| back = classify_sliders(app)
|
| except Exception as e:
|
| steps.append("slider census after restoring raised: %r" % (e,))
|
|
|
| ok = (rb_flip(before, off) and hid and shown
|
| and before is not None and off is not None
|
| and before[0] >= 1 and off[0] == 0
|
| and off[1] == before[1] and off[1] >= 1
|
| and back == before
|
| and total_off < total_before)
|
| assert ok, ("(horizontal,vertical) sliders %r -> %r -> %r (want (1,1) -> (0,1) -> "
|
| "(1,1)); total %r -> %r; clicked_off=%r clicked_on=%r steps=%s"
|
| % (before, off, back, total_before, total_off, hid, shown, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="Window > Advanced Controls empties the bottom dock row: CheckBox 6 -> 0 and "
|
| "Spinner 4 -> 0, total node count collapses; both counts return on re-enable")
|
| def test_advanced_controls_toggle_collapses_dock_row(app, rb, results_dir):
|
| steps = []
|
| cb_before = cb_off = cb_back = None
|
| sp_before = sp_off = sp_back = None
|
| total_before = total_off = total_back = None
|
| hid = shown = False
|
| try:
|
| cb_before, sp_before = count_type(app, "CheckBox"), count_type(app, "Spinner")
|
| total_before = count_nodes(app)
|
| except Exception as e:
|
| steps.append("baseline count raised: %r" % (e,))
|
| try:
|
| hid = toggle_window_option(rb, app, "Advanced Controls")
|
| if not hid:
|
| steps.append("nav: 'Advanced Controls' not clickable in the Window menu")
|
| except Exception as e:
|
| steps.append("Window > Advanced Controls (off) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| cb_off, sp_off = count_type(app, "CheckBox"), count_type(app, "Spinner")
|
| total_off = count_nodes(app)
|
| except Exception as e:
|
| steps.append("count after hiding raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_advanced_controls_off",
|
| "PyPlayer with its advanced controls hidden: the whole bottom row of round "
|
| "playback buttons, time spin boxes, trim buttons and checkboxes has "
|
| "disappeared, leaving only the thin rainbow-gradient progress bar with its "
|
| "'--:--' time labels between the black player area and the status bar.",
|
| results_dir, window=app)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| shown = toggle_window_option(rb, app, "Advanced Controls")
|
| if not shown:
|
| steps.append("nav: could not re-enable 'Advanced Controls'")
|
| except Exception as e:
|
| steps.append("Window > Advanced Controls (on) raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| cb_back, sp_back = count_type(app, "CheckBox"), count_type(app, "Spinner")
|
| total_back = count_nodes(app)
|
| except Exception as e:
|
| steps.append("count after restoring raised: %r" % (e,))
|
|
|
| ok = (rb_flip((cb_before, sp_before), (cb_off, sp_off)) and hid and shown
|
| and cb_before is not None and sp_before is not None
|
| and cb_before >= 2 and sp_before >= 1
|
| and cb_off == 0 and sp_off == 0
|
| and cb_back == cb_before and sp_back == sp_before
|
| and total_off < total_before and total_back > total_off)
|
| assert ok, ("CheckBox %r -> %r -> %r (want 6 -> 0 -> 6); Spinner %r -> %r -> %r "
|
| "(want 4 -> 0 -> 4); total %r -> %r -> %r; clicked_off=%r clicked_on=%r "
|
| "steps=%s" % (cb_before, cb_off, cb_back, sp_before, sp_off, sp_back,
|
| total_before, total_off, total_back, hid, shown, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="hiding the Status Bar and then the Progress Bar compose: StatusBar 1 -> 0 "
|
| "then horizontal Slider 1 -> 0, the total node count shrinking at each step "
|
| "and growing back once both are re-enabled")
|
| def test_status_and_progress_toggles_compose(app, rb):
|
| steps = []
|
| sb0 = sb1 = sb3 = None
|
| h0 = h1 = h2 = h3 = None
|
| t0 = t1 = t2 = t3 = None
|
| clicks = []
|
| try:
|
| sb0, (h0, _v0), t0 = count_type(app, "StatusBar"), classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("baseline census raised: %r" % (e,))
|
| try:
|
| clicks.append(toggle_window_option(rb, app, "Status Bar"))
|
| close_menus()
|
| sb1, (h1, _v1), t1 = count_type(app, "StatusBar"), classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("step 1 (Status Bar off) raised: %r" % (e,))
|
| try:
|
| clicks.append(toggle_window_option(rb, app, "Progress Bar"))
|
| close_menus()
|
| (h2, _v2), t2 = classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("step 2 (Progress Bar off) raised: %r" % (e,))
|
| try:
|
| clicks.append(toggle_window_option(rb, app, "Progress Bar"))
|
| clicks.append(toggle_window_option(rb, app, "Status Bar"))
|
| close_menus()
|
| sb3, (h3, _v3), t3 = count_type(app, "StatusBar"), classify_sliders(app), count_nodes(app)
|
| except Exception as e:
|
| steps.append("restore step raised: %r" % (e,))
|
|
|
| ok = (rb_flip((sb0, h0, t0), (sb1, h2, t2)) and all(clicks) and len(clicks) == 4
|
| and sb0 == 1 and sb1 == 0 and h0 == 1 and h1 == 1 and h2 == 0
|
| and t0 is not None and t1 is not None and t2 is not None
|
| and t2 < t1 < t0
|
| and sb3 == sb0 and h3 == h0 and t3 is not None and t3 > t2)
|
| assert ok, ("StatusBar %r -> %r -> (unchanged) -> %r; horizontal sliders %r -> %r -> "
|
| "%r -> %r; totals %r -> %r -> %r -> %r (want a strict shrink at each step "
|
| "then a recovery); menu clicks=%r steps=%s"
|
| % (sb0, sb1, sb3, h0, h1, h2, h3, t0, t1, t2, t3, clicks, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="opening the Window menu materialises its item nodes (MenuItem count 7 -> 15, "
|
| "i.e. at least 6 new items) and {ESC} removes them again")
|
| def test_window_menu_popup_materialises_item_nodes(app, rb, results_dir):
|
| steps, closed_menu = [], None
|
| before = opened = after = None
|
| entered = False
|
| try:
|
| before = count_type(app, "MenuItem")
|
| except Exception as e:
|
| steps.append("baseline MenuItem count raised: %r" % (e,))
|
| try:
|
| entered = rb_enter_menu(rb, app, "Window")
|
| if not entered:
|
| steps.append("nav: the 'Window' menu did not open")
|
| except Exception as e:
|
| steps.append("open Window menu raised: %r" % (e,))
|
| try:
|
| opened = count_type(app, "MenuItem")
|
| except Exception as e:
|
| steps.append("MenuItem count with the popup up raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_window_menu_popup",
|
| "The 'Window' menu is open as a dropdown over the PyPlayer window, listing the "
|
| "view options: 'Fullscreen', three resize entries for the media's native size / "
|
| "aspect ratio, and the 'Menu Bar', 'Status Bar', 'Progress Bar' and 'Advanced "
|
| "Controls' toggles, the last four shown as ticked options.",
|
| results_dir)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| close_menus()
|
| rb.back()
|
| time.sleep(0.4)
|
| closed_menu = True
|
| after = count_type(app, "MenuItem")
|
| except Exception as e:
|
| closed_menu = False
|
| steps.append("close menu / recount raised: %r" % (e,))
|
|
|
| ok = (rb_flip(before, opened) and entered and closed_menu
|
| and before is not None and opened is not None
|
| and opened - before >= 6 and after == before)
|
| assert ok, ("MenuItem nodes %r -> %r (popup up) -> %r (popup closed); wanted a growth "
|
| "of at least 6 and a full restore; entered=%r steps=%s"
|
| % (before, opened, after, entered, steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=1,
|
| expect="Window > Fullscreen collapses the window chrome at once: MenuBar 2 -> 0, "
|
| "StatusBar 1 -> 0 and the total node count drops 48 -> 32; {ESC} restores")
|
| def test_fullscreen_collapses_window_chrome(app, rb, results_dir):
|
| steps = []
|
| mb_before = sb_before = sp_before = total_before = None
|
| mb_full = sb_full = sp_full = total_full = None
|
| mb_back = sb_back = total_back = None
|
| entered_fs = restored = False
|
| try:
|
| mb_before, sb_before = count_type(app, "MenuBar"), count_type(app, "StatusBar")
|
| sp_before, total_before = count_type(app, "Spinner"), count_nodes(app)
|
| except Exception as e:
|
| steps.append("baseline census raised: %r" % (e,))
|
| try:
|
| entered_fs = toggle_window_option(rb, app, "Fullscreen")
|
| if not entered_fs:
|
| steps.append("nav: 'Fullscreen' not clickable in the Window menu")
|
| time.sleep(1.2)
|
| except Exception as e:
|
| steps.append("Window > Fullscreen raised: %r" % (e,))
|
| try:
|
| mb_full, sb_full = count_type(app, "MenuBar"), count_type(app, "StatusBar")
|
| sp_full, total_full = count_type(app, "Spinner"), count_nodes(app)
|
| except Exception as e:
|
| steps.append("census in fullscreen raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_fullscreen_chrome_collapsed",
|
| "PyPlayer switched to fullscreen with no media loaded: the black playback "
|
| "surface with the VLC traffic-cone logo centred on it now covers the entire "
|
| "screen, and the menu row (File Edit Video Audio Window Player Help) and the "
|
| "status bar that framed the window before are both gone.",
|
| results_dir)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| restored = leave_fullscreen(app)
|
| if not restored:
|
| steps.append("restore: {ESC} did not bring the menu bar back")
|
| except Exception as e:
|
| steps.append("{ESC} out of fullscreen raised: %r" % (e,))
|
| try:
|
| mb_back, sb_back = count_type(app, "MenuBar"), count_type(app, "StatusBar")
|
| total_back = count_nodes(app)
|
| except Exception as e:
|
| steps.append("census after restoring raised: %r" % (e,))
|
|
|
|
|
|
|
|
|
| ok = (rb_flip((mb_before, sb_before, total_before), (mb_full, sb_full, total_full))
|
| and entered_fs
|
| and mb_before is not None and mb_before >= 1 and sb_before == 1
|
| and mb_full == 0 and sb_full == 0
|
| and total_full is not None and total_before is not None
|
| and total_before - total_full >= 10
|
| and mb_back == mb_before and sb_back == sb_before
|
| and total_back is not None and total_back > total_full)
|
| assert ok, ("MenuBar %r -> %r -> %r, StatusBar %r -> %r -> %r, Spinner %r -> %r, "
|
| "total %r -> %r -> %r (want the menu bar and status bar to hit 0 in "
|
| "fullscreen, the node total to shed >=10 nodes, and everything to come "
|
| "back after ESC); entered=%r restored=%r steps=%s"
|
| % (mb_before, mb_full, mb_back, sb_before, sb_full, sb_back,
|
| sp_before, sp_full, total_before, total_full, total_back,
|
| entered_fs, restored, steps))
|
|
|
|
|
|
|
|
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="reach", depth=1,
|
| expect="Edit > Settings adds a new top-level window titled 'Settings' (sibling-window "
|
| "count 0 -> 1) while the Edit menu's own items leave the tree")
|
| def test_settings_dialog_adds_top_level_window(app, rb, results_dir):
|
| steps, dlg = [], None
|
| before = after = set()
|
| windows_before = windows_after = None
|
| entered = clicked = False
|
| try:
|
| windows_before = len(other_windows(app))
|
| except Exception as e:
|
| steps.append("count sibling windows raised: %r" % (e,))
|
| try:
|
| entered = rb_enter_menu(rb, app, "Edit")
|
| if not entered:
|
| steps.append("nav: the 'Edit' menu did not open")
|
| except Exception as e:
|
| steps.append("open Edit menu raised: %r" % (e,))
|
| try:
|
| before = showing_all(app)
|
| except Exception as e:
|
| steps.append("snapshot before raised: %r" % (e,))
|
| try:
|
| clicked = click_menu_item_like(app, "Settings")
|
| rb.back()
|
| if not clicked:
|
| steps.append("nav: 'Settings' not clickable in the Edit menu")
|
| except Exception as e:
|
| steps.append("click Settings raised: %r" % (e,))
|
| try:
|
| dlg = dialog_named(app, "Settings", timeout=10.0)
|
| time.sleep(1.0)
|
| if dlg is None:
|
| steps.append("no top-level window titled 'Settings' appeared")
|
| except Exception as e:
|
| steps.append("wait for the Settings window raised: %r" % (e,))
|
| try:
|
| windows_after = len(other_windows(app))
|
| after = showing_all(app)
|
| except Exception as e:
|
| steps.append("snapshot after raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_settings_dialog_window",
|
| "A separate tall, narrow light-grey 'Settings' window is open in front of the "
|
| "PyPlayer main window, with a tab strip across the top reading General / "
|
| "Editing / Hotkeys / Updates, a 'Theme' drop-down showing 'Midnight', a column "
|
| "of option checkboxes below it and an OK button at the bottom.",
|
| results_dir)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| click_dialog_ok(dlg)
|
| except Exception as e:
|
| steps.append("closing the dialog raised: %r" % (e,))
|
|
|
| assert (rb_reach(before, after, target="Settings", source="Edit timestamps")
|
| and rb_flip(windows_before, windows_after)
|
| and windows_before is not None and windows_after == windows_before + 1), (
|
| "sibling top-level windows %r -> %r (want 0 -> 1); entered_menu=%r clicked=%r "
|
| "new keys=%r steps=%s"
|
| % (windows_before, windows_after, entered, clicked,
|
| sorted(k for k in (after - before) if "setting" in k.lower())[:6], steps))
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="reach", depth=1,
|
| expect="Help > About... adds a new top-level window titled 'About PyPlayer' "
|
| "(sibling-window count 0 -> 1) while the Help menu's items leave the tree")
|
| def test_about_dialog_adds_top_level_window(app, rb, results_dir):
|
| steps, dlg = [], None
|
| before = after = set()
|
| windows_before = windows_after = None
|
| entered = clicked = False
|
| try:
|
| windows_before = len(other_windows(app))
|
| except Exception as e:
|
| steps.append("count sibling windows raised: %r" % (e,))
|
| try:
|
| entered = rb_enter_menu(rb, app, "Help")
|
| if not entered:
|
| steps.append("nav: the 'Help' menu did not open")
|
| except Exception as e:
|
| steps.append("open Help menu raised: %r" % (e,))
|
| try:
|
| before = showing_all(app)
|
| except Exception as e:
|
| steps.append("snapshot before raised: %r" % (e,))
|
| try:
|
| clicked = click_menu_item_like(app, "About...", avoid=("About Qt...",))
|
| rb.back()
|
| if not clicked:
|
| steps.append("nav: 'About...' not clickable in the Help menu")
|
| except Exception as e:
|
| steps.append("click About raised: %r" % (e,))
|
| try:
|
| dlg = dialog_named(app, "About PyPlayer", timeout=10.0)
|
| time.sleep(0.8)
|
| if dlg is None:
|
| steps.append("no top-level window titled 'About PyPlayer' appeared")
|
| except Exception as e:
|
| steps.append("wait for the About window raised: %r" % (e,))
|
| try:
|
| windows_after = len(other_windows(app))
|
| after = showing_all(app)
|
| except Exception as e:
|
| steps.append("snapshot after raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_about_dialog_window",
|
| "A small separate 'About PyPlayer' window is open in front of the main "
|
| "PyPlayer window, showing the PyPlayer logo image, a heading naming the "
|
| "application and its version, a couple of description lines about the player "
|
| "and a single OK button.",
|
| results_dir)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| click_dialog_ok(dlg)
|
| except Exception as e:
|
| steps.append("closing the dialog raised: %r" % (e,))
|
|
|
| assert (rb_reach(before, after, target="About PyPlayer", source="Check for updates")
|
| and rb_flip(windows_before, windows_after)
|
| and windows_before is not None and windows_after == windows_before + 1), (
|
| "sibling top-level windows %r -> %r (want 0 -> 1); entered_menu=%r clicked=%r "
|
| "new keys=%r steps=%s"
|
| % (windows_before, windows_after, entered, clicked,
|
| sorted(k for k in (after - before) if "about" in k.lower())[:6], steps))
|
|
|
|
|
|
|
|
|
|
|
|
|
| @pytest.mark.rb(
|
| jump_kind="transition", depth=3,
|
| expect="Video > Crop with rb_silent.mp4 loaded adds exactly 6 new Text nodes (the "
|
| "Crop: / L: / R: / T: / B: / WxH readout); pressing 'c' removes them again")
|
| def test_crop_mode_adds_six_crop_readout_text_nodes(app, rb, results_dir):
|
| steps = []
|
| text_before = text_crop = text_after = None
|
| loaded = entered_menu = clicked = left_crop = False
|
| try:
|
| loaded = rb_reach_media(rb, app, "rb_silent.mp4")
|
| if not loaded:
|
| steps.append("nav: media did not load (title never showed rb_silent.mp4)")
|
| settle_media()
|
| except Exception as e:
|
| steps.append("open media raised: %r" % (e,))
|
| try:
|
| text_before = count_type(app, "Text")
|
| except Exception as e:
|
| steps.append("baseline Text count raised: %r" % (e,))
|
| try:
|
| entered_menu = rb_enter_menu(rb, app, "Video")
|
| if not entered_menu:
|
| steps.append("nav: the 'Video' menu did not open")
|
| clicked = click_menu_item_like(app, "Crop")
|
| rb.back()
|
| if not clicked:
|
| steps.append("nav: 'Crop' not clickable in the Video menu")
|
| time.sleep(1.2)
|
| except Exception as e:
|
| steps.append("Video > Crop raised: %r" % (e,))
|
| try:
|
| text_crop = count_type(app, "Text")
|
| except Exception as e:
|
| steps.append("Text count in crop mode raised: %r" % (e,))
|
| try:
|
| rb_uia.screenshot_assert(
|
| "structure_crop_mode_readout",
|
| "PyPlayer in crop mode with the colour-bar test video loaded: a crop rectangle "
|
| "is drawn over the video with the area outside it dimmed, and at the right-hand "
|
| "end of the control dock a readout labelled 'Crop:' shows L:, R:, T: and B: "
|
| "edge values with a WxH size beneath them.",
|
| results_dir, window=app)
|
| except Exception as e:
|
| steps.append("screenshot raised: %r" % (e,))
|
| try:
|
| left_crop = exit_crop_mode(app, text_before)
|
| if not left_crop:
|
| steps.append("restore: pressing 'c' did not take the crop readout back down")
|
| except Exception as e:
|
| steps.append("exit crop mode raised: %r" % (e,))
|
| try:
|
| text_after = count_type(app, "Text")
|
| except Exception as e:
|
| steps.append("Text count after leaving crop mode raised: %r" % (e,))
|
|
|
| ok = (rb_flip(text_before, text_crop) and loaded and clicked
|
| and text_before is not None and text_crop is not None
|
| and text_crop - text_before == 6
|
| and text_after == text_before)
|
| assert ok, ("Text nodes %r -> %r -> %r (want +6 in crop mode and a full restore); "
|
| "media_loaded=%r menu=%r clicked=%r left_crop=%r steps=%s"
|
| % (text_before, text_crop, text_after, loaded, entered_menu, clicked,
|
| left_crop, steps))
|
|
|
