Unify window presentation and frame-driven shell motion
Share window geometry across overview, resize snapshots and retained closes. Advance close handoffs and group retained rendering by stacking position. Drive shell motion from surface frames, reuse settled widget content, and synchronize notification materials with each card's fade. Replace physical config keys with duration and bounce, and update documentation and regression coverage.
This commit is contained in:
Samuel Onoja committed
1 parent
f8bc17e913
commit
64a80dc069
33 files changed
+1742
-600
No files matched your search
@@ -72,8 +72,17 @@ class OverviewDamageTest(unittest.TestCase):
|
||||
# The first report includes time before this call. The second
|
||||
# covers a full five seconds of the requested stationary scene.
|
||||
count = len(reports())
|
||||
wait_for(lambda: len(reports()) >= count + 2)
|
||||
return reports()[-1]
|
||||
for attempt in range(3):
|
||||
wait_for(lambda: len(reports()) >= count + 2)
|
||||
lines = log_path.read_text().splitlines()
|
||||
boundaries = [index for index, line in enumerate(lines)
|
||||
if "render performance" in line]
|
||||
interval = lines[boundaries[-2] + 1:boundaries[-1]]
|
||||
if not any("ferese::nested_input:" in line for line in interval):
|
||||
return reports()[-1]
|
||||
print("Discarding interval with host input; waiting for a quiet interval", flush=True)
|
||||
count = len(boundaries) - 1
|
||||
self.fail("No input-free interval for the stationary overview check")
|
||||
|
||||
def assert_quiet(label, report):
|
||||
print(label + ":", report, flush=True)
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
"""Exercise real shell frame-driven motion on a private nested desktop and bus.
|
||||
|
||||
FERESE_TEST_SHELL_MOTION=1 python3 scripts/tests/test_shell_motion_isolated.py
|
||||
Uses release binaries by default. Requires a Wayland host, dbus-daemon and gdbus.
|
||||
Protocol traces contain only this test's shell traffic, never the host desktop.
|
||||
"""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import signal
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(os.environ.get("FERESE_TEST_SHELL_MOTION") == "1", "opt-in nested shell test")
|
||||
class ShellMotionTest(unittest.TestCase):
|
||||
def test_notifications_and_modals_follow_frames_and_finish_closing(self):
|
||||
repo = Path(__file__).resolve().parents[2]
|
||||
binary = repo / os.environ.get("FERESE_TEST_BINARY", "target/release/ferese")
|
||||
shell = repo / os.environ.get("FERESE_TEST_SHELL", "target/release/ferese-shell")
|
||||
ctl = repo / os.environ.get("FERESE_TEST_CTL", "target/release/feresectl")
|
||||
children = []
|
||||
with tempfile.TemporaryDirectory(prefix="ferese-shell-motion-") as temporary:
|
||||
root = Path(temporary)
|
||||
runtime = root / "runtime"
|
||||
runtime.mkdir(mode=0o700)
|
||||
config = root / "config/ferese"
|
||||
config.mkdir(parents=True)
|
||||
(config / "config.kdl").write_text(
|
||||
'animations { speed 0.5; }\nstatus { keybinding-guide #false; }\n')
|
||||
display = Path(os.environ["WAYLAND_DISPLAY"])
|
||||
if not display.is_absolute():
|
||||
display = Path(os.environ["XDG_RUNTIME_DIR"]) / display
|
||||
env = dict(os.environ, XDG_RUNTIME_DIR=str(runtime), WAYLAND_DISPLAY=str(display),
|
||||
XDG_CONFIG_HOME=str(root / "config"), XDG_STATE_HOME=str(root / "state"),
|
||||
XDG_CACHE_HOME=str(root / "cache"), RUST_LOG="ferese=info,ferese::nested_input=debug")
|
||||
env.pop("WAYLAND_SOCKET", None)
|
||||
env.pop("FERESE_SHELL_CONTROL_SOCKET", None)
|
||||
log_path = root / "session.log"
|
||||
# No service directories: readiness checks must not auto-activate
|
||||
# the host's notification daemon on this private bus.
|
||||
bus_config = root / "bus.conf"
|
||||
bus_config.write_text(
|
||||
'<busconfig><type>session</type><listen>unix:tmpdir=/tmp</listen>'
|
||||
'<policy context="default"><allow send_destination="*"/>'
|
||||
'<allow receive_sender="*"/><allow own="*"/></policy></busconfig>')
|
||||
|
||||
def launch(command, **kwargs):
|
||||
process = subprocess.Popen(command, env=env, start_new_session=True, **kwargs)
|
||||
children.append(process)
|
||||
return process
|
||||
|
||||
def wait_for(predicate, timeout=15):
|
||||
deadline = time.monotonic() + timeout
|
||||
while time.monotonic() < deadline:
|
||||
value = predicate()
|
||||
if value:
|
||||
return value
|
||||
time.sleep(.025)
|
||||
trace = log_path.read_text()
|
||||
relevant = '\n'.join(line for line in trace.splitlines() if any(
|
||||
word in line for word in ('get_layer_surface', 'ERROR', 'WARN', 'notification')))
|
||||
self.fail("Timed out:\n" + relevant[-16000:] + '\n' + trace[-4000:])
|
||||
|
||||
def dbus(method, *args, check=True):
|
||||
return subprocess.run(["gdbus", "call", "--session", "--dest", "org.freedesktop.Notifications",
|
||||
"--object-path", "/org/freedesktop/Notifications", "--method",
|
||||
"org.freedesktop.Notifications." + method, *args],
|
||||
env=env, text=True, capture_output=True, timeout=5, check=check)
|
||||
|
||||
def layer_surface(namespace):
|
||||
matches = list(re.finditer(r'get_layer_surface\([^\n]*?wl_surface[@#](\d+)[^\n]*"' + namespace + '"', log_path.read_text()))
|
||||
# Wayland object IDs can be reused after destruction. Restrict
|
||||
# assertions to this surface's lifetime in the trace.
|
||||
return (matches[-1].group(1), matches[-1].start()) if matches else None
|
||||
|
||||
def frames(surface):
|
||||
identity, start = surface
|
||||
return len(re.findall(r'wl_surface[@#]' + identity + r'\.frame\(', log_path.read_text()[start:]))
|
||||
|
||||
def commits(surface):
|
||||
identity, start = surface
|
||||
return len(re.findall(r'wl_surface[@#]' + identity + r'\.commit\(', log_path.read_text()[start:]))
|
||||
|
||||
def destroyed(surface):
|
||||
identity, start = surface
|
||||
return re.search(r'wl_surface[@#]' + identity + r'\.destroy\(', log_path.read_text()[start:]) is not None
|
||||
|
||||
with log_path.open("w") as log:
|
||||
try:
|
||||
bus = launch(["dbus-daemon", "--config-file=" + str(bus_config), "--nofork", "--print-address=1"],
|
||||
stdout=subprocess.PIPE, stderr=log, text=True)
|
||||
env["DBUS_SESSION_BUS_ADDRESS"] = bus.stdout.readline().strip()
|
||||
compositor = launch([str(binary), "--backend", "nested", "--grant-effects", "--grant-shell-control",
|
||||
"--", "env", "WAYLAND_DEBUG=client", "ICED_BACKEND=tiny-skia", str(shell)],
|
||||
stdout=log, stderr=log)
|
||||
wait_for(lambda: (runtime / "ferese/control.sock").is_socket())
|
||||
wait_for(lambda: dbus("GetServerInformation", check=False).returncode == 0)
|
||||
wait_for(lambda: layer_surface("ferese-shell-top-bar"))
|
||||
time.sleep(.5)
|
||||
reply = dbus("Notify", "Ferese motion test", "0", "", "Frame cadence", "Synthetic test notification", "[]", "{}", "0").stdout
|
||||
notice = re.search(r'uint32 (\d+)', reply).group(1)
|
||||
surface = wait_for(lambda: layer_surface("ferese-shell-notifications"))
|
||||
time.sleep(1.5)
|
||||
opening_frames = frames(surface)
|
||||
self.assertGreater(opening_frames, 10, log_path.read_text()[-8000:])
|
||||
time.sleep(1)
|
||||
for attempt in range(3):
|
||||
trace_start = len(log_path.read_text())
|
||||
before = commits(surface)
|
||||
time.sleep(2)
|
||||
idle_frames = commits(surface) - before
|
||||
if 'ferese::nested_input:' not in log_path.read_text()[trace_start:]:
|
||||
break
|
||||
else:
|
||||
self.fail("Host input interrupted all three idle measurement intervals")
|
||||
# Clock/status updates still redraw settled surfaces. Count
|
||||
# commits: Iced can request two callbacks for one redraw.
|
||||
self.assertLessEqual(idle_frames, 12, "settled toast kept requesting animation frames")
|
||||
material_updates = log_path.read_text().count('.set_region_opacities(')
|
||||
dbus("CloseNotification", notice)
|
||||
wait_for(lambda: destroyed(surface), timeout=5)
|
||||
self.assertGreater(log_path.read_text().count('.set_region_opacities(') - material_updates, 5,
|
||||
"notification materials did not follow their fade")
|
||||
print(f"Toast: {opening_frames} opening callback requests, {idle_frames / 2:g} settled commits/s; destroyed", flush=True)
|
||||
|
||||
subprocess.run([str(ctl), "toggle-keybinding-guide"], env=env, check=True, capture_output=True)
|
||||
modal = wait_for(lambda: layer_surface("ferese-system-modal"))
|
||||
wait_for(lambda: frames(modal) >= 4)
|
||||
time.sleep(.3)
|
||||
subprocess.run([str(ctl), "toggle-keybinding-guide"], env=env, check=True, capture_output=True)
|
||||
wait_for(lambda: destroyed(modal), timeout=5)
|
||||
self.assertGreater(frames(modal), 10, "modal close did not follow frames")
|
||||
self.assertIsNone(compositor.poll(), log_path.read_text()[-8000:])
|
||||
self.assertNotIn("panicked at", log_path.read_text())
|
||||
print(f"Modal: {frames(modal)} callbacks; interrupted opening closed and destroyed", flush=True)
|
||||
finally:
|
||||
for child in reversed(children):
|
||||
if child.poll() is None:
|
||||
os.killpg(child.pid, signal.SIGTERM)
|
||||
try:
|
||||
child.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
os.killpg(child.pid, signal.SIGKILL)
|
||||
child.wait(timeout=5)
|
||||
if child.stdout is not None:
|
||||
child.stdout.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user