Merge upstream main while preserving PowerVR integration

This commit is contained in:
wallentx committed 2026-10-11 19:30:00 -05:00
commit bf033f2f11
108 files changed
+9859 -2070

No files matched your search

+16
View File
@@ -208,6 +208,22 @@ class AgentTest(unittest.TestCase):
missing = self.ask({"kind": "cdp", "expression": "1", "target": "Nope"})
self.assertEqual("NO_TARGET", missing["error"]["code"])
def test_steam_selection(self):
with patch.object(agent, "cdp_eval", return_value={"value": "3180310"}) as evaluate:
answer = self.ask({"kind": "steam-selection"})
self.assertEqual(3180310, answer["appId"])
self.assertIn("document.activeElement", evaluate.call_args.args[1])
self.assertEqual("Steam Big Picture Mode", evaluate.call_args.kwargs["target"])
def test_steam_selection_allows_no_highlight(self):
with patch.object(agent, "cdp_eval", return_value={"value": None}):
self.assertIsNone(self.ask({"kind": "steam-selection"})["appId"])
def test_steam_selection_rejects_invalid_app_id(self):
with patch.object(agent, "cdp_eval", return_value={"value": "4294967296"}):
answer = self.ask({"kind": "steam-selection"})
self.assertEqual("INVALID_SELECTION", answer["error"]["code"])
def test_cdp_exception(self):
server = FakeDevTools({"result": {"result": {"type": "object"}, "exceptionDetails": {
"text": "Uncaught", "exception": {"description": "ReferenceError: SteamClient is not defined"}}}})
+19
View File
@@ -746,6 +746,16 @@ class SelectTest(SyncTestCase):
self.assertFalse((root / "wanted.tsv").exists())
self.assertFalse((root / "dist").exists())
def test_droiddeck_proton_has_esync_built_in(self):
root = self.store()
tool = make_tool(self.tools, "DroidDeck-Proton 11-7.5", "1791000000 DroidDeck-Proton-11-7.5", builtin=True, ge=True, fsync=True)
command, env, said = self.select(tool, self.env())
self.assertEqual(command[0], str(tool / "proton"))
self.assertNotIn("BL_SYNC_PACK", env)
self.assertEqual(said, "droiddeck-esync: DroidDeck-Proton 11-7.5 has esync built in\n")
self.assertFalse((root / "wanted.tsv").exists())
self.assertFalse((root / "dist").exists())
def test_wanted_rows_are_deduplicated(self):
root = self.store()
tool = make_tool(self.tools, "GE-Proton11-7", GE_LINE, ge=True)
@@ -906,6 +916,15 @@ class ReconcileTest(SyncTestCase):
self.assertTrue(self.dist_of("ge-GE-Proton11-7-r1", ge).is_dir())
self.assertIn("ge-GE-Proton11-7-r1", (root / "tools.tsv").read_text())
def test_droiddeck_proton_is_scanned_but_our_own_tools_are_not(self):
steam = self.tmp / "steam"
tools = steam / "compatibilitytools.d"
ours = make_tool(tools, "DroidDeck-Proton 11-7.5", "1791000000 DroidDeck-Proton-11-7.5", salt=b"dd", builtin=True, ge=True)
make_tool(tools, "droiddeck-proton-arm64", salt=b"own")
make_tool(tools, "droiddeck-proton-11-arm64", salt=b"own11")
with mock.patch.dict(GLOBALS, {"SD_LIBRARY": str(self.tmp / "sd")}):
self.assertEqual(SYNC["find_tools"](str(steam)), [str(ours)])
def test_steam_compatibility_reports_sync(self):
steam = self.tmp / "steam"
make_tool(steam / "steamapps/common", "Proton Experimental (ARM64)")
+217
View File
@@ -1,3 +1,4 @@
import hashlib
import json
import os
import shutil
@@ -158,6 +159,121 @@ class GameEnvironmentTest(unittest.TestCase):
self.assertEqual(env["REMOVE"], "inherited")
self.assertEqual(MODULE["apply_config"](env, config, "43")["CUSTOM"], "shared")
def test_component_profiles_override_general_and_restore_it_for_the_next_game(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
home = root / "home"
component_dir = home / ".local/share/droiddeck-components"
base = root / "proton"
target = base / "files/lib/wine/dxvk/aarch64-windows/d3d11.dll"
leftover = target.with_name("d3d8.dll")
component_dir.mkdir(parents=True)
target.parent.mkdir(parents=True)
(base / "version").write_text("1 build-1\n")
general = root / "general.dll"
game = root / "game.dll"
general.write_text("general")
game.write_text("game")
target.write_text("old")
leftover.write_text("old")
digest = lambda path: hashlib.sha256(path.read_bytes()).hexdigest()
(component_dir / "desired.tsv").write_text(
"*\tproton\tbuild-1\tdxvk\tfiles/lib/wine/dxvk/aarch64-windows/d3d11.dll\t%s\t%s\n"
"42\tproton\tbuild-1\tdxvk\tfiles/lib/wine/dxvk/aarch64-windows/d3d11.dll\t%s\t%s\n"
"42\tproton\tbuild-1\tdxvk\tfiles/lib/wine/dxvk/aarch64-windows/d3d8.dll\t-\t-\n"
% (digest(general), general, digest(game), game)
)
script = COMPAT["BL_COMPONENTS_SETUP"] + '\nverb=waitforexitandrun; bl_components "$1"\n'
env = dict(os.environ, HOME=str(home), STEAM_COMPAT_DATA_PATH="/steam/compatdata/42")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True)
self.assertEqual(target.read_text(), "game")
self.assertFalse(leftover.exists())
env["STEAM_COMPAT_DATA_PATH"] = "/steam/compatdata/43"
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True)
self.assertEqual(target.read_text(), "general")
def test_system_powervr_preserves_dxvk_profiles_without_applying_them(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
home = root / "home"
component_dir = home / ".local/share/droiddeck-components"
component_dir.mkdir(parents=True)
base = root / "proton"
paths = {
"dxvk": "files/lib/wine/dxvk/aarch64-windows/d3d11.dll",
"fex": "files/lib/wine/aarch64-windows/libarm64ecfex.dll",
"vkd3d": "files/lib/wine/vkd3d-proton/aarch64-windows/d3d12.dll",
}
rows = []
for comp, rel in paths.items():
target = base / rel
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text("bundled " + comp)
for scope in ("*", "42"):
source = root / (comp + ("-general" if scope == "*" else "-game"))
source.write_text(source.name)
rows.append("%s\tproton\tbuild-1\t%s\t%s\t%s\t%s\n" % (
scope, comp, rel, hashlib.sha256(source.read_bytes()).hexdigest(), source,
))
leftover = (base / paths["dxvk"]).with_name("d3d8.dll")
leftover.write_text("bundled d3d8")
rows.append("42\tproton\tbuild-1\tdxvk\t%s\t-\t-\n" % leftover.relative_to(base))
(base / "version").write_text("1 build-1\n")
selection = component_dir / "desired.tsv"
selection.write_text("".join(rows))
saved = selection.read_bytes()
script = COMPAT["BL_COMPONENTS_SETUP"] + '\nverb=waitforexitandrun; bl_components "$1"\n'
env = dict(os.environ, HOME=str(home), STEAM_COMPAT_DATA_PATH="/steam/compatdata/42",
DROIDDECK_POWERVR_RUNTIME="/system_vulkan/runtime")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True)
self.assertEqual((base / paths["dxvk"]).read_text(), "bundled dxvk")
self.assertEqual(leftover.read_text(), "bundled d3d8")
for comp in ("fex", "vkd3d"):
self.assertEqual((base / paths[comp]).read_text(), comp + "-game")
self.assertEqual(selection.read_bytes(), saved)
# A subsequent manual-driver session still applies the saved per-game DXVK choice.
env.pop("DROIDDECK_POWERVR_RUNTIME")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True)
self.assertEqual((base / paths["dxvk"]).read_text(), "dxvk-game")
self.assertFalse(leftover.exists())
self.assertEqual(selection.read_bytes(), saved)
def test_component_scope_matches_environment_scope_for_shortcut_ids(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
component_dir = root / ".local/share/droiddeck-components"
base = root / "proton"
target = base / "files/lib/wine/dxvk/aarch64-windows/d3d11.dll"
component_dir.mkdir(parents=True)
target.parent.mkdir(parents=True)
(base / "version").write_text("1 build-1\n")
rows = []
for scope in ("*", "42", "4294967295", "2147483648"):
source = root / ("default" if scope == "*" else scope)
source.write_text(scope)
rows.append("%s\tproton\tbuild-1\tdxvk\t%s\t%s\t%s\n" % (
scope, target.relative_to(base),
hashlib.sha256(source.read_bytes()).hexdigest(), source,
))
(component_dir / "desired.tsv").write_text("".join(rows))
script = COMPAT["BL_COMPONENTS_SETUP"] + '\nverb=waitforexitandrun; bl_components "$1"\n'
for value in (
"42", "00042", "43", "-1", "-0001", "4294967295", "-2147483648",
"2147483648", "-1///", "0", "-0", "000", "-2147483649", "4294967296",
"999999999999999999999999999", "not-an-id", "1+1", "",
):
with self.subTest(prefix=value):
env = dict(os.environ, HOME=str(root), STEAM_COMPAT_DATA_PATH="/steam/compatdata/" + value)
target.write_text("untouched")
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True, capture_output=True)
scope = MODULE["game_id"](env)
expected = "untouched" if scope is None else scope if scope in {"42", "4294967295", "2147483648"} else "*"
self.assertEqual(target.read_text(), expected)
def test_engine_fixes_follow_the_games_files(self):
with tempfile.TemporaryDirectory() as tmp:
game = Path(tmp) / "Godot Game"
@@ -215,6 +331,22 @@ class GameEnvironmentTest(unittest.TestCase):
with self.assertRaises(ValueError):
MODULE["apply_config"]({}, {**config, "dxvkConfig": bad}, "42")
def test_game_texture_filtering_overrides_default_without_leaking(self):
default = "d3d9.samplerAnisotropy = 16"
game = "d3d9.samplerAnisotropy = 4"
config = {
"version": 1,
"shared": {},
"games": {},
"dxvkConfig": default,
"dxvkConfigGames": {"42": game, "43": ""},
}
self.assertEqual(MODULE["apply_config"]({}, config, "42")["DXVK_CONFIG"], game)
self.assertNotIn("DXVK_CONFIG", MODULE["apply_config"]({}, config, "43"))
self.assertEqual(MODULE["apply_config"]({}, config, "44")["DXVK_CONFIG"], default)
with self.assertRaises(ValueError):
MODULE["apply_config"]({}, {**config, "dxvkConfigGames": []}, "42")
def test_game_ids_and_probes(self):
for prefix in ("", "/compatdata/0", "/compatdata/0-123", "/compatdata/nope", "/compatdata/4294967296"):
self.assertIsNone(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": prefix}))
@@ -363,6 +495,40 @@ class GameEnvironmentTest(unittest.TestCase):
self.assertIn('"$here/proton"', (extra / COMPAT["EXTRA_WRAPPER"]).read_text())
self.assertIn("GE-Proton11-7", [entry["name"] for entry in COMPAT["tool_catalog"](str(home), None)])
def test_droiddeck_proton_is_adopted_and_labelled_like_any_other_extra(self):
# Its folder has a space ("DroidDeck-Proton 11-7.5") and its internal name starts with
# "DroidDeck-Proton-", which lower-cases to our own tools' prefix: neither may matter.
with tempfile.TemporaryDirectory() as tmp:
home = Path(tmp)
(home / "label").write_text("Compatible\n")
COMPAT["display_name"].__globals__["LABEL_FILE"] = str(home / "label")
tools = home / "compatibilitytools.d"
extra = tools / "DroidDeck-Proton 11-7.5"
extra.mkdir(parents=True)
(extra / "proton").write_text("")
(extra / "toolmanifest.vdf").write_text('"manifest" { "version" "2" "commandline" "/proton %verb%" "require_tool_appid" "4185400" }')
(extra / "compatibilitytool.vdf").write_text(
'"compatibilitytools" { "compat_tools" { "DroidDeck-Proton-11-7.5" { "install_path" "." '
'"display_name" "DroidDeck-Proton 11-7.5" "from_oslist" "windows" "to_oslist" "linux" } } }')
COMPAT["build_tool"](str(tools / COMPAT["TOOL"]), None)
protect = COMPAT["adopt_extras"](str(tools))
self.assertEqual(protect, {"DroidDeck-Proton-11-7.5": "DroidDeck-Proton 11-7.5"})
compat = (extra / "compatibilitytool.vdf").read_text()
self.assertIn('"DroidDeck-Proton-11-7.5"', compat)
self.assertIn('"display_name" "DroidDeck-Proton 11-7.5 (Compatible)"', compat)
self.assertNotIn("require_tool_appid", (extra / "toolmanifest.vdf").read_text())
self.assertIn('"$here/proton"', (extra / COMPAT["EXTRA_WRAPPER"]).read_text())
catalog = COMPAT["tool_catalog"](str(home), None)
self.assertIn({"name": "DroidDeck-Proton-11-7.5", "display": "DroidDeck-Proton 11-7.5 (Compatible)",
"dir": "DroidDeck-Proton 11-7.5", "valve": False}, catalog)
config = home / "config.vdf"
config.write_text(config_text([("0", COMPAT["TOOL"]), ("42", "DroidDeck-Proton-11-7.5")]))
COMPAT["register_default"](str(config), ["42", "43"], protect=protect)
self.assertEqual(mapping_of(config.read_text()), {"0": COMPAT["TOOL"], "42": "DroidDeck-Proton-11-7.5", "43": COMPAT["TOOL"]})
# Once removed it is no longer runnable, and its games go back to the default.
changes, _ = COMPAT["plan_mapping"]({"0": COMPAT["TOOL"], "42": "DroidDeck-Proton-11-7.5"}, ["42"], [COMPAT["TOOL"]], COMPAT["TOOL"], {})
self.assertEqual(changes, {"42": COMPAT["TOOL"]})
def test_both_proton_wrappers_call_environment_launcher(self):
for script in (COMPAT["LAUNCHER_SH"], COMPAT["EXTRA_WRAPPER_SH"] % "proton"):
subprocess.run(["bash", "-n"], input=script, text=True, check=True)
@@ -425,6 +591,57 @@ class ProtonDefaultTest(unittest.TestCase):
changes, auto = self.plan({"0": self.TOOL}, [], self.TOOL, {"10": self.TOOL})
self.assertEqual((changes, auto), ({}, {}))
def test_per_game_proton_override_and_inherit_follow_steam_mappings(self):
current = {"0": self.TOOL, "10": self.TOOL, "11": "GE-Proton11-7", "12": self.TOOL}
overrides = {"10": "GE-Proton11-7", "11": None}
changes, auto = COMPAT["plan_mapping"](
current, ["10", "11", "12"], self.NAMES, COMPAT["TOOL_11"],
{"10": self.TOOL, "12": self.TOOL}, overrides=overrides)
self.assertEqual(changes, {"0": COMPAT["TOOL_11"], "10": "GE-Proton11-7", "11": COMPAT["TOOL_11"], "12": COMPAT["TOOL_11"]})
self.assertEqual(auto, {"11": COMPAT["TOOL_11"], "12": COMPAT["TOOL_11"]})
def test_per_game_requests_resolve_identity_and_defer_a_new_live_tool(self):
requests = {
"10": {"valve": False, "dir": "GE-Proton11-7"},
"11": None,
"12": {"valve": True, "dir": "Proton 11.0 (ARM64)"},
"0": None,
}
self.assertEqual(
COMPAT["requested_games"](requests, self.CATALOG),
{"10": "GE-Proton11-7", "11": None, "12": COMPAT["TOOL_11"]},
)
self.assertEqual(
COMPAT["requested_games"](requests, self.CATALOG, [self.TOOL, COMPAT["TOOL_11"]]),
{"10": COMPAT["DEFERRED_GAME_TOOL"], "11": None, "12": COMPAT["TOOL_11"]},
)
def test_missing_per_game_proton_is_preserved_during_default_registration(self):
with tempfile.TemporaryDirectory() as tmp:
config = Path(tmp) / "config.vdf"
config.write_text(config_text([
("0", self.TOOL),
("10", "GE-Proton9-1"),
("11", self.TOOL),
]))
(Path(tmp) / "games.json").write_text(json.dumps({
"version": 1,
"games": {
"10": {"valve": False, "dir": "GE-Proton9-1"},
},
}))
COMPAT["register_default"](
str(config), ["10", "11"], default=COMPAT["TOOL_11"],
catalog=self.CATALOG, directory=tmp,
)
self.assertEqual(mapping_of(config.read_text()), {
"0": COMPAT["TOOL_11"],
"10": "GE-Proton9-1",
"11": COMPAT["TOOL_11"],
})
def test_the_last_side_to_change_wins(self):
state = {"default": self.TOOL, "applied": 5}
default, state = COMPAT["choose_default"]("GE-Proton11-7", state, {"seq": 5, "dir": "Proton 11.0 (ARM64)", "valve": True}, self.CATALOG, now=100)
+220
View File
@@ -0,0 +1,220 @@
import json
import os
from pathlib import Path
import runpy
import tempfile
import unittest
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
MODULE = runpy.run_path(str(BIN / 'droiddeck-launcher-cores'))
Holder = MODULE['Holder']
Governor = MODULE['Governor']
NICE = MODULE['NICE']
HELPER = 'C:\\Program Files\\Rockstar Games\\Social Club\\SocialClubHelper.exe'
LAUNCHER = 'C:\\Program Files\\Rockstar Games\\Launcher\\Launcher.exe'
GAME = 'S:\\steamapps\\common\\Red Dead Redemption 2\\RDR2.exe'
ALL = set(range(8))
class FakeCores:
"""Per-thread masks and priorities, with every change recorded."""
def __init__(self):
self.state = {}
self.calls = []
def own(self):
return set(ALL)
def get(self, tid):
if tid not in self.state:
raise ProcessLookupError(tid)
return self.state[tid]
def set(self, tid, cpus, nice):
if tid not in self.state:
raise ProcessLookupError(tid)
self.calls.append((tid, set(cpus), nice))
self.state[tid] = (set(cpus), nice)
class LauncherCoresTest(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.root = Path(temp.name)
self.proc = self.root / 'proc'
self.proc.mkdir()
cpufreq = self.root / 'cpu'
for cpu in ALL: # 0-5 one cluster, 6-7 the fast one
(cpufreq / f'cpu{cpu}/cpufreq').mkdir(parents=True)
(cpufreq / f'cpu{cpu}/cpufreq/cpuinfo_max_freq').write_text('3532800\n' if cpu < 6 else '4320000\n')
self.cores = FakeCores()
self.holder = Holder(self.proc, cpufreq, self.cores)
self.focus = self.root / 'focus.json'
self.now = 0.0
self.governor = Governor(self.focus, self.holder, clock=lambda: self.now)
def process(self, pid, argv0, threads=(), cpus=ALL, nice=0):
directory = self.proc / str(pid)
(directory / 'task').mkdir(parents=True)
(directory / 'cmdline').write_bytes(argv0.encode() + b'\0--type=renderer\0')
for tid in (pid, *threads):
self.thread(pid, tid, cpus, nice)
def thread(self, pid, tid, cpus=ALL, nice=0):
(self.proc / str(pid) / 'task' / str(tid)).mkdir()
self.cores.state[tid] = (set(cpus), nice)
def end(self, pid):
for tid in os.listdir(self.proc / str(pid) / 'task'):
self.cores.state.pop(int(tid), None)
(self.proc / str(pid) / 'task' / tid).rmdir()
(self.proc / str(pid) / 'task').rmdir()
(self.proc / str(pid) / 'cmdline').unlink()
(self.proc / str(pid)).rmdir()
def focus_on(self, pid, app=1174180):
stamp = getattr(self, 'stamp', 1_000_000_000) + 1_000_000_000
self.stamp = stamp
self.focus.write_text(json.dumps({
'focusedApp': app, 'focusedWindow': 0x200001,
'focusableWindows': [{'window': 0x100001, 'appId': 769, 'pid': 9},
{'window': 0x200001, 'appId': app, 'pid': pid}]}))
os.utime(self.focus, ns=(stamp, stamp))
def held(self, tid):
return self.cores.state[tid] == ({5}, NICE)
def test_helpers_held_on_the_slow_clusters_last_core_while_the_game_has_focus(self):
self.process(100, LAUNCHER, (101,))
self.process(200, HELPER, (201, 202), nice=-2)
self.process(300, HELPER, (301,))
self.process(400, GAME, (401,))
self.focus_on(400)
self.governor.tick()
for tid in (200, 201, 202, 300, 301):
self.assertTrue(self.held(tid), tid)
for tid in (100, 101, 400, 401):
self.assertEqual((ALL, 0), self.cores.state[tid])
def test_launcher_focus_gives_each_thread_its_own_mask_and_priority_back(self):
self.process(100, LAUNCHER)
self.process(200, HELPER, (201,), cpus={0, 1, 2, 3}, nice=-2)
self.cores.state[201] = ({6, 7}, 4)
self.process(400, GAME)
self.focus_on(400)
self.governor.tick()
self.assertTrue(self.held(201))
self.focus_on(100)
self.governor.tick()
self.assertEqual(({0, 1, 2, 3}, -2), self.cores.state[200])
self.assertEqual(({6, 7}, 4), self.cores.state[201])
self.assertEqual({}, self.holder.held)
def test_nothing_is_touched_before_a_game_has_focus(self):
self.process(100, LAUNCHER)
self.process(200, HELPER)
self.process(9, '/root/.local/share/Steam/steamrtarm64/steam')
self.governor.tick() # no focus file yet
self.focus_on(9, app=769)
self.governor.tick()
self.focus_on(100)
self.governor.tick()
self.assertEqual([], self.cores.calls)
def test_a_launcher_left_after_its_game_stays_held_behind_the_client(self):
self.process(200, HELPER)
self.process(400, GAME)
self.process(9, '/root/.local/share/Steam/steamrtarm64/steam')
self.focus_on(400)
self.governor.tick()
self.end(400)
self.focus_on(9, app=769)
self.governor.tick()
self.assertTrue(self.held(200))
def test_a_thread_inheriting_the_hold_is_released_to_what_its_process_had(self):
self.process(200, HELPER, cpus={0, 1, 2, 3, 4, 5}, nice=1)
self.process(400, GAME)
self.focus_on(400)
self.governor.tick()
# A new thread, and a new helper process the held one started: both born held.
self.thread(200, 203, {5}, NICE)
self.process(500, HELPER, (501,), cpus={5}, nice=NICE)
self.now += 10
self.governor.tick()
self.focus_on(200)
self.governor.tick()
for tid in (200, 203, 500, 501):
self.assertEqual(({0, 1, 2, 3, 4, 5}, 1), self.cores.state[tid], tid)
def test_a_held_thread_the_program_moves_back_is_held_again_on_the_next_look(self):
self.process(200, HELPER, (201,))
self.process(400, GAME)
self.focus_on(400)
self.governor.tick()
self.cores.state[201] = (ALL, -5) # the program raised a thread's priority itself
self.now += 5
self.governor.tick()
self.assertFalse(self.held(201)) # not looked at again before the rescan
self.now += 5
self.governor.tick()
self.assertTrue(self.held(201))
self.focus_on(200)
self.governor.tick()
self.assertEqual((ALL, 0), self.cores.state[201]) # its first state, not the program's
def test_a_steady_hold_is_not_rewritten(self):
self.process(200, HELPER, (201,))
self.process(400, GAME)
self.focus_on(400)
self.governor.tick()
calls = len(self.cores.calls)
for _ in range(5):
self.now += 10
self.governor.tick()
self.assertEqual(calls, len(self.cores.calls))
def test_threads_that_end_are_skipped_and_ended_helpers_forgotten(self):
self.process(200, HELPER, (201,))
self.process(300, HELPER)
self.process(400, GAME)
del self.cores.state[201] # ended between the listing and the call
self.focus_on(400)
self.governor.tick()
self.assertNotIn(201, self.holder.held[200])
self.end(300)
self.now += 10
self.governor.tick()
self.assertEqual([200], list(self.holder.held))
def test_stop_releases(self):
self.process(200, HELPER)
self.process(400, GAME)
self.focus_on(400)
self.governor.tick()
with self.assertRaises(SystemExit):
self.governor.stop()
self.assertEqual((ALL, 0), self.cores.state[200])
def test_unreadable_focus_is_ignored(self):
self.process(200, HELPER)
self.focus.write_text('{"focusedApp": 1174')
self.governor.tick()
self.focus.write_text('[]')
os.utime(self.focus, ns=(5, 5))
self.governor.tick()
self.assertEqual([], self.cores.calls)
def test_window_without_a_pid_is_left_alone(self):
self.process(200, HELPER)
self.focus.write_text(json.dumps({'focusedApp': 1174180, 'focusedWindow': 7, 'focusableWindows': []}))
self.governor.tick()
self.assertEqual([], self.cores.calls)
if __name__ == '__main__':
unittest.main()
+107
View File
@@ -0,0 +1,107 @@
import contextlib
import hashlib
import io
import os
from pathlib import Path
import runpy
import subprocess
import tarfile
import tempfile
import unittest
from unittest import mock
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
EXTRA = runpy.run_path(str(BIN / "droiddeck-proton-extra"))
GLOBALS = EXTRA["pick_asset"].__globals__
def asset(name):
return {"name": name, "browser_download_url": "https://github.com/o/r/releases/download/t/" + name}
def droiddeck_release(ver, prerelease=False, draft=False):
stem = "DroidDeck-Proton-%s-aarch64" % ver
return {"tag_name": "DroidDeck-Proton-" + ver, "prerelease": prerelease, "draft": draft,
"assets": [asset(stem + ".build-info.json"), asset(stem + ".sha512sum"), asset(stem + ".tar.gz")]}
class ProtonExtraTest(unittest.TestCase):
def test_sources_and_their_arm64_assets(self):
self.assertEqual(list(EXTRA["SOURCES"]), ["ge", "cachyos", "droiddeck"])
repo, pattern = EXTRA["SOURCES"]["droiddeck"]
self.assertEqual(repo, "The412Banner/DroidDeck-Proton")
self.assertTrue(pattern.search("DroidDeck-Proton-11-7.5-aarch64.tar.gz"))
self.assertTrue(pattern.search("DroidDeck-Proton-11-8-aarch64.tar.xz"))
self.assertFalse(pattern.search("DroidDeck-Proton-11-7.5-aarch64.sha512sum"))
self.assertFalse(pattern.search("DroidDeck-Proton-11-7.5-aarch64.build-info.json"))
def test_the_newest_full_release_with_its_sha512_file(self):
releases = [droiddeck_release("11-8", prerelease=True), droiddeck_release("11-7.9", draft=True), droiddeck_release("11-7.5")]
with mock.patch.dict(GLOBALS, {"fetch_json": lambda url: releases}):
tag, url, sums = EXTRA["pick_asset"]("droiddeck")
self.assertEqual(tag, "DroidDeck-Proton-11-7.5")
self.assertTrue(url.endswith("/DroidDeck-Proton-11-7.5-aarch64.tar.gz"))
self.assertTrue(sums.endswith("/DroidDeck-Proton-11-7.5-aarch64.sha512sum"))
with mock.patch.dict(GLOBALS, {"fetch_json": lambda url: [droiddeck_release("11-8", prerelease=True)]}):
self.assertEqual(EXTRA["pick_asset"]("droiddeck"), (None, None, None))
def test_a_tagged_release_is_fetched_by_its_tag(self):
asked = []
with mock.patch.dict(GLOBALS, {"fetch_json": lambda url: asked.append(url) or droiddeck_release("11-7.5")}):
tag, url, sums = EXTRA["release_asset"]("droiddeck", "DroidDeck-Proton-11-7.5")
self.assertEqual(asked, ["https://api.github.com/repos/The412Banner/DroidDeck-Proton/releases/tags/DroidDeck-Proton-11-7.5"])
self.assertTrue(url.endswith(".tar.gz") and sums.endswith(".sha512sum"))
def test_a_ge_style_sha512_file_verifies_the_download(self):
with tempfile.TemporaryDirectory() as tmp:
tarball = Path(tmp) / "DroidDeck-Proton-11-7.5-aarch64.tar.gz"
tarball.write_bytes(b"tarball")
line = "%s %s\n" % (hashlib.sha512(b"tarball").hexdigest(), tarball.name)
class Reply(io.BytesIO):
def __exit__(self, *exc):
return False
with mock.patch.object(GLOBALS["urllib"].request, "urlopen", lambda req, timeout: Reply(line.encode())), \
contextlib.redirect_stdout(io.StringIO()) as said:
EXTRA["verify"](str(tarball), "https://example/sums")
self.assertIn("checksum ok", said.getvalue())
self.assertTrue(tarball.exists())
bad = "%s %s\n" % ("0" * 128, tarball.name)
with mock.patch.object(GLOBALS["urllib"].request, "urlopen", lambda req, timeout: Reply(bad.encode())), \
contextlib.redirect_stdout(io.StringIO()), self.assertRaises(SystemExit):
EXTRA["verify"](str(tarball), "https://example/sums")
self.assertFalse(tarball.exists())
def test_a_top_folder_with_a_space_is_installed_under_its_own_name(self):
with tempfile.TemporaryDirectory() as tmp:
src = Path(tmp) / "src" / "DroidDeck-Proton 11-7.5"
(src / "files/bin").mkdir(parents=True)
(src / "proton").write_text("#!/usr/bin/python3\n")
(src / "toolmanifest.vdf").write_text('"manifest" { "commandline" "/proton %verb%" }')
(src / "compatibilitytool.vdf").write_text(
'"compatibilitytools" { "compat_tools" { "DroidDeck-Proton-11-7.5" { "install_path" "." '
'"display_name" "DroidDeck-Proton 11-7.5" } } }')
(src / "version").write_text("1791000000 DroidDeck-Proton-11-7.5\n")
tarball = Path(tmp) / "DroidDeck-Proton-11-7.5-aarch64.tar.gz"
with tarfile.open(tarball, "w:gz") as tar:
tar.add(src, arcname=src.name)
steam = Path(tmp) / "Steam"
adopted = []
real = subprocess.call
# tar runs for real; steam-compatibility (the adoption step) is only recorded.
fake = lambda args, **kw: adopted.append(args) or 0 if args[0] == "steam-compatibility" else real(args, **kw)
with mock.patch.object(GLOBALS["subprocess"], "call", fake), contextlib.redirect_stdout(io.StringIO()) as said:
with mock.patch.object(GLOBALS["sys"], "argv", ["droiddeck-proton-extra", str(steam), str(tarball)]):
EXTRA["main"]()
tools = steam / "compatibilitytools.d"
self.assertEqual(sorted(os.listdir(tools)), [".droiddeck-download", "DroidDeck-Proton 11-7.5"])
self.assertTrue((tools / "DroidDeck-Proton 11-7.5" / "toolmanifest.vdf").is_file())
self.assertEqual(adopted, [["steam-compatibility", str(steam)]])
# The app reads the folder from this line, space and all.
self.assertIn("droiddeck-proton-extra: installed DroidDeck-Proton 11-7.5\n", said.getvalue())
self.assertEqual(EXTRA["installed"](str(tools)), ["DroidDeck-Proton 11-7.5"])
if __name__ == "__main__":
unittest.main()
+63
View File
@@ -22,6 +22,30 @@ GAME_SCRIPT = r'''"InstallScript"
}
'''
# Red Dead Redemption 2's own script: Proton needs Khronos' vulkan-1.dll for it, which only the
# Vulkan runtime installer puts in the prefix.
VULKAN_SCRIPT = r'''"InstallScript"
{
"Run Process"
{
"Vulkan111080"
{
"HasRunKey" "HKEY_LOCAL_MACHINE\\Software\\Valve\\Steam\\Apps\\1174180"
"process 1" "%INSTALLDIR%\\Redistributables\\VulkanRT-1.1.108.0-Installer.exe"
"command 1" "/S"
"NoCleanUp" "0"
}
"RockstarLauncher"
{
"HasRunKey" "HKEY_LOCAL_MACHINE\\Software\\Rockstar Games\\Steam\\Launcher"
"process 1" "%INSTALLDIR%\\Redistributables\\Rockstar-Games-Launcher.exe"
"command 1" "/s /t"
"NoCleanUp" "0"
}
}
}
'''
class SeedRedistsTest(unittest.TestCase):
def setUp(self):
@@ -91,6 +115,45 @@ class SeedRedistsTest(unittest.TestCase):
self.run_seed()
self.assertEqual(int(self.reg.stat().st_mtime), 1_000_000_000)
def rdr2(self):
path = self.steam / "steamapps/common/Red Dead Redemption 2/installscript.vdf"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(VULKAN_SCRIPT)
(self.steam / "steamapps/appmanifest_1174180.acf").write_text('"AppState" { "installdir" "Red Dead Redemption 2" }')
def test_a_vulkan_runtime_installer_is_left_to_run(self):
self.rdr2()
self.run_seed()
reg = self.reg.read_text()
self.assertNotIn("Vulkan111080", reg)
self.assertIn('"RockstarLauncher"=dword:00000001', reg)
self.assertNotIn("Vulkan111080", (self.reg.parent / ".droiddeck-redists").read_text())
def test_a_vulkan_marker_an_earlier_seeding_wrote_comes_out_once(self):
self.rdr2()
marker = "HKEY_LOCAL_MACHINE\\\\Software\\\\Valve\\\\Steam\\\\Apps\\\\1174180\tVulkan111080"
self.reg.write_text(
"WINE REGISTRY Version 2\n"
"\n[Software\\\\Valve\\\\Steam\\\\Apps\\\\1174180] 1791729070\n#time=1dd598d29161f72\n"
'"Other"=dword:00000001\n"Vulkan111080"=dword:00000001\n'
"\n[Software\\\\Wow6432Node\\\\Valve\\\\Steam\\\\Apps\\\\1174180] 1791729070\n"
'"Vulkan111080"=dword:00000001\n'
"\n[Software\\\\Valve\\\\Steam\\\\Apps\\\\22380] 1791311644\n"
'"Vulkan111080"=dword:00000001\n')
(self.reg.parent / ".droiddeck-redists").write_text(marker + "\n")
os.utime(self.reg, (1_000_000_000, 1_000_000_000))
self.run_seed()
reg = self.reg.read_text()
self.assertEqual(reg.count('"Vulkan111080"'), 1, "only the other app's value stays")
self.assertIn('"Other"=dword:00000001', reg)
self.assertNotIn("Vulkan111080", (self.reg.parent / ".droiddeck-redists").read_text())
self.assertEqual(int(self.reg.stat().st_mtime), 1_000_000_000)
# The client writes the marker itself once the installer has run; that one is left alone.
with self.reg.open("a") as out:
out.write('\n[Software\\\\Valve\\\\Steam\\\\Apps\\\\1174180] 1791730000\n"Vulkan111080"=dword:00000001\n')
self.run_seed()
self.assertEqual(self.reg.read_text().count('"Vulkan111080"'), 2)
if __name__ == "__main__":
unittest.main()
+95
View File
@@ -0,0 +1,95 @@
import os
import re
import shutil
import socket
import subprocess
import tempfile
import unittest
from pathlib import Path
SESSION = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-session"
STEAM = ["mangohud.Ab3dE6gH", ".com.valvesoftware.Steam.x1Y2z3/", "steam_chrome_shmem_uid10480_0", "steamADfAnd/"]
CHROMIUM = ["scoped_dir3yu9Xt/SingletonSocket"]
APPIMAGE = ["droiddeck-appimage.19PoOD"]
BUS = ["dbus-1zWfOP1IaR="] # = a socket
KDE = ["plasma-csd-generator.BVWIWA/"]
STALE = STEAM + CHROMIUM + APPIMAGE + BUS + KDE
KEPT = ["droiddeck-mangohud.conf", ".X11-unix/", "steamworks", "steamABCDEF/inside", "notes.txt",
"mangohud.conf", ".wine-10480/", "dbus-1zWfOP1IaR.log", "dbus-notasocket",
"plasma-csd-generator.CQGZSw/kept"]
def sweep_function(tmp):
match = re.search(r"^clear_stale_tmp\(\) \{\n.*?^\}\n", SESSION.read_text(), re.M | re.S)
return match.group(0).replace("find /tmp ", "find %s " % tmp)
class SessionTmpTest(unittest.TestCase):
def setUp(self):
self.root = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.root, True)
self.tmp = self.root / "tmp"
self.tmp.mkdir()
for name in STALE + KEPT:
path = self.tmp / name
if name.endswith("/"):
path.mkdir(parents=True)
elif name.endswith("="):
listener = socket.socket(socket.AF_UNIX)
listener.bind(str(self.tmp / name[:-1]))
listener.close()
else:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("x")
self.bin = self.root / "bin"
self.bin.mkdir()
def sweep(self, running=""):
pgrep = self.bin / "pgrep"
pgrep.write_text("#!/bin/sh\nprintf '%s' '" + running + "'\n")
pgrep.chmod(0o755)
env = dict(os.environ, PATH="%s:%s" % (self.bin, os.environ["PATH"]))
return subprocess.run(["bash", "-c", sweep_function(self.tmp) + "clear_stale_tmp"], env=env,
capture_output=True, text=True, timeout=30, check=True).stdout
def exists(self, name):
return os.path.lexists(self.tmp / name.rstrip("=").split("/")[0])
def test_what_killed_sessions_left_goes_and_nothing_else(self):
self.assertEqual("== /tmp: cleared 8 entries earlier sessions left\n", self.sweep())
for name in STALE:
self.assertFalse(self.exists(name), name)
for name in KEPT:
self.assertTrue((self.tmp / name).exists(), name)
def kept_while(self, running, owned):
self.sweep(running)
for name in STALE:
self.assertEqual(name in owned, self.exists(name), name)
def test_a_running_client_keeps_its_own(self):
self.kept_while("1234 /root/.local/share/Steam/steamrtarm64/steam -gamepadui\n", STEAM)
def test_a_running_chromium_keeps_its_singleton(self):
self.kept_while("88 /opt/Heroic/heroic --type=renderer --enable-features=x\n", CHROMIUM)
def test_a_running_appimage_keeps_its_stamp(self):
self.kept_while("77 /bin/bash /usr/local/bin/droiddeck-appimage-run /root/Apps/X.AppImage\n", APPIMAGE)
def test_a_running_session_bus_keeps_its_socket(self):
self.kept_while("66 dbus-daemon --config-file=/usr/share/dbus-1/session.conf --nofork --session\n", BUS)
def test_the_system_bus_is_not_a_session_bus(self):
self.kept_while("55 dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf --nofork\n", [])
def test_a_running_desktop_keeps_its_decorations(self):
self.kept_while("44 kwin_wayland --xwayland\n", KDE)
def test_a_clean_tmp_says_nothing(self):
self.sweep()
self.assertEqual("", self.sweep())
if __name__ == "__main__":
unittest.main()
+27
View File
@@ -208,6 +208,33 @@ class ReconcileTest(unittest.TestCase):
self.assertEqual((state["pending"], state.get("applied", 0)), (TOOL_11, 0))
self.assertTrue(self.helper.request_waiting())
def test_per_game_customize_and_inherit_apply_live(self):
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL_11}, [TOOL, TOOL_11])
(self.state / "games.json").write_text(json.dumps({
"version": 1,
"games": {
"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"},
"11": None,
},
}))
state = self.reconcile(page)
self.assertEqual(page.sets, [("10", TOOL_11), ("11", TOOL)])
self.assertEqual(state["auto"], {"11": TOOL})
def test_missing_per_game_proton_stays_deferred_live(self):
page = FakePage({"0": TOOL, "10": "GE-Proton9-1", "11": TOOL_11}, [TOOL, TOOL_11])
(self.state / "games.json").write_text(json.dumps({
"version": 1,
"games": {
"10": {"valve": False, "dir": "GE-Proton9-1"},
"11": None,
},
}))
state = self.reconcile(page)
self.assertEqual(page.sets, [("11", TOOL)])
self.assertEqual(page.mapping["10"], "GE-Proton9-1")
self.assertEqual(state["auto"], {"11": TOOL})
def test_file_mode_defers_to_the_live_helper(self):
(self.state / "live.pid").write_text("%d\n" % os.getpid())
self.assertTrue(COMPAT["live_helper_running"]())
+59
View File
@@ -14,6 +14,8 @@ DISPLAY = MODULE['DISPLAY']
seed_native_resolution = MODULE['seed_native_resolution']
initialize_native_resolution = MODULE['initialize_native_resolution']
NATIVE_RESOLUTION = MODULE['NATIVE_RESOLUTION']
seed_no_screensaver_in_game = MODULE['seed_no_screensaver_in_game']
initialize_screensaver = MODULE['initialize_screensaver']
class SteamUiScaleTest(unittest.TestCase):
@@ -151,3 +153,60 @@ class SteamNativeResolutionTest(unittest.TestCase):
initialize_native_resolution(self.root)
self.assertEqual(text, self.config.read_text())
self.assertFalse(self.marker.exists())
class SteamScreensaverTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.config = self.root / 'config/config.vdf'
self.config.parent.mkdir()
self.marker = self.config.with_name('droiddeck-screensaver-initialized')
def in_game(self, text):
return parse(text).get('InstallConfigStore').get('Customization').get('Screensaver').get('WhileInGame')
def test_fresh_client_shows_no_screensaver_over_a_game(self):
self.assertTrue(initialize_screensaver(self.root))
self.assertEqual('0', self.in_game(self.config.read_text()))
self.assertTrue(self.marker.exists())
def test_it_goes_beside_the_screensaver_the_user_picked(self):
text = ('"InstallConfigStore"\n{\n\t"Customization"\n\t{\n\t\t"Screensaver"\n\t\t{\n'
'\t\t\t"CurrentScreensaver"\t\t"steam-bouncinglogo"\n\t\t}\n\t}\n}\n')
updated, changed = seed_no_screensaver_in_game(text)
self.assertTrue(changed)
screensaver = parse(updated).get('InstallConfigStore').get('Customization').get('Screensaver')
self.assertEqual('steam-bouncinglogo', screensaver.get('CurrentScreensaver'))
self.assertEqual('0', screensaver.get('WhileInGame'))
self.assertIn('\t\t\t"WhileInGame"\t\t"0"\n\t\t}\n', updated)
def test_users_choice_is_kept(self):
text = '"InstallConfigStore" { "Customization" { "Screensaver" { "WhileInGame" "1" } } }'
self.assertEqual((text, False), seed_no_screensaver_in_game(text))
def test_turning_it_back_on_survives_restart(self):
initialize_screensaver(self.root)
text = '"InstallConfigStore" { "Customization" { } }'
self.config.write_text(text)
self.assertFalse(initialize_screensaver(self.root))
self.assertEqual(text, self.config.read_text())
def test_every_seeded_setting_lands_in_one_valid_config(self):
initialize(self.root, 2340, 1080)
initialize_native_resolution(self.root)
initialize_screensaver(self.root)
store = parse(self.config.read_text()).get('InstallConfigStore')
self.assertIsNotNone(store.get('UI').get('display').get(DISPLAY))
self.assertEqual('1', store.get('Gamescope').get(NATIVE_RESOLUTION))
self.assertEqual('0', store.get('Customization').get('Screensaver').get('WhileInGame'))
def test_invalid_config_is_never_rewritten_or_marked_initialized(self):
for text in ('"InstallConfigStore" {', '"InstallConfigStore" { "Customization" "bad" }',
'"InstallConfigStore" { "Customization" { "Screensaver" "bad" } }'):
self.config.write_text(text)
with self.assertRaises(ValueError):
initialize_screensaver(self.root)
self.assertEqual(text, self.config.read_text())
self.assertFalse(self.marker.exists())