mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
Merge remote-tracking branch 'droiddeck/main' into maint/appimage-x64-wayland-runtime
This commit is contained in:
commit
0d6c18b300
562 files changed
+71029
-1963
No files matched your search
@@ -198,6 +198,155 @@ class ConfigAndMenuTest(Temp):
|
||||
self.assertEqual(path.stat().st_mtime_ns, mtime)
|
||||
|
||||
|
||||
class DriveTest(Temp):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.root = str(self.tmp / "Steam")
|
||||
self.devices = Path(BNET["dosdevices"](self.root))
|
||||
self.card = self.tmp / "card"
|
||||
self.library = self.card / "Games/Battle.net"
|
||||
self.library.mkdir(parents=True)
|
||||
self.running = []
|
||||
patcher = mock.patch.dict(BNET, {"say": lambda message: None, "wine_processes": lambda pfx, proc="/proc": list(self.running),
|
||||
"volume_root": lambda path: str(self.card) if BNET["inside"](path, str(self.card)) else "/"})
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_a_volume_ends_where_the_device_changes(self):
|
||||
devices = {"/": 1, "/mnt": 1, "/mnt/card": 7, "/mnt/card/Games": 7, "/mnt/card/Games/Battle.net": 7, "/root": 1, "/root/Games": 1}
|
||||
with mock.patch.object(os, "stat", lambda path: mock.Mock(st_dev=devices[path])):
|
||||
volume_root = runpy.run_path(str(BIN / "droiddeck-battlenet"))["volume_root"]
|
||||
self.assertEqual(volume_root("/mnt/card/Games/Battle.net"), "/mnt/card")
|
||||
self.assertEqual(volume_root("/mnt/card"), "/mnt/card")
|
||||
self.assertEqual(volume_root("/root/Games"), "/")
|
||||
self.assertEqual(volume_root("/"), "/")
|
||||
|
||||
def test_a_library_on_the_root_volume_keeps_its_path_and_gets_no_drive(self):
|
||||
library = self.tmp / "root/Games/Battle.net"
|
||||
library.mkdir(parents=True)
|
||||
self.assertEqual(BNET["install_path"](self.root, str(library) + "/"), "Z:" + str(library))
|
||||
self.assertFalse(self.devices.exists())
|
||||
|
||||
def test_a_library_on_another_volume_gets_a_drive_at_the_volume_root(self):
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
|
||||
self.assertEqual(os.readlink(self.devices / "d:"), str(self.card))
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library / "World of Warcraft")), "D:\\Games\\Battle.net\\World of Warcraft")
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.card)), "D:\\")
|
||||
self.assertEqual(sorted(os.listdir(self.devices)), ["d:"])
|
||||
|
||||
def test_drives_in_use_and_the_ones_proton_owns_are_left_alone(self):
|
||||
self.devices.mkdir(parents=True)
|
||||
os.symlink("/somewhere/else", self.devices / "d:")
|
||||
os.symlink(str(self.card), self.devices / "s:")
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "E:\\Games\\Battle.net")
|
||||
self.assertEqual(os.readlink(self.devices / "d:"), "/somewhere/else")
|
||||
for letter in BNET["DRIVES"]:
|
||||
if not os.path.lexists(self.devices / (letter + ":")):
|
||||
os.symlink("/somewhere/else", self.devices / (letter + ":"))
|
||||
os.unlink(self.devices / "e:")
|
||||
os.symlink("/somewhere/else", self.devices / "e:")
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "Z:" + str(self.library))
|
||||
self.assertNotIn("s", BNET["DRIVES"])
|
||||
self.assertNotIn("t", BNET["DRIVES"])
|
||||
|
||||
def test_a_running_prefix_gets_no_new_drive_but_uses_the_ones_it_started_with(self):
|
||||
self.running = [(5, ["C:\\Program Files (x86)\\Battle.net\\Battle.net.exe"])]
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "Z:" + str(self.library))
|
||||
self.assertFalse(self.devices.exists())
|
||||
self.running = []
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
|
||||
self.running = [(5, ["C:\\Program Files (x86)\\Battle.net\\Battle.net.exe"])]
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "D:\\Games\\Battle.net")
|
||||
|
||||
def test_a_drive_mapped_inside_the_volume_is_reused(self):
|
||||
self.devices.mkdir(parents=True)
|
||||
os.symlink(str(self.card / "Games"), self.devices / "g:")
|
||||
self.assertEqual(BNET["install_path"](self.root, str(self.library)), "G:\\Battle.net")
|
||||
self.assertEqual(sorted(os.listdir(self.devices)), ["g:"])
|
||||
|
||||
def test_the_config_stores_the_drive_path_once(self):
|
||||
path = self.tmp / ("Steam/steamapps/compatdata/%s/pfx/drive_c/users/steamuser/AppData/Roaming/Battle.net/Battle.net.config"
|
||||
% BNET["APP_ID"])
|
||||
BNET["write_config"](self.root)
|
||||
self.assertEqual(BNET["write_config"](self.root, str(self.library)), "library")
|
||||
self.assertEqual(json.loads(path.read_text())["Client"]["Install"]["DefaultInstallPath"], "D:\\Games\\Battle.net")
|
||||
self.assertIsNone(BNET["write_config"](self.root, str(self.library)))
|
||||
|
||||
def test_registered_paths_resolve_through_their_drive(self):
|
||||
BNET["install_path"](self.root, str(self.library))
|
||||
self.assertEqual(BNET["windows_path"](self.root, "D:/Games/Battle.net/World of Warcraft"),
|
||||
str(self.library / "World of Warcraft"))
|
||||
self.assertEqual(BNET["windows_path"](self.root, "Z:\\mnt\\card\\World of Warcraft"), "/mnt/card/World of Warcraft")
|
||||
self.assertEqual(BNET["windows_path"](self.root, "C:/Program Files (x86)/World of Warcraft"),
|
||||
os.path.join(BNET["drive_c"](self.root), "Program Files (x86)/World of Warcraft"))
|
||||
self.assertIsNone(BNET["windows_path"](self.root, "E:/Games/X"))
|
||||
self.assertIsNone(BNET["windows_path"](self.root, "D:/../etc"))
|
||||
self.assertEqual(BNET["windows_path"](self.root, "D:\\"), str(self.library.parent.parent))
|
||||
|
||||
def field(self, number, value):
|
||||
varint = BNET["encode_varint"]
|
||||
return varint(number << 3 | 2) + varint(len(value)) + value
|
||||
|
||||
def product(self, uid, folder, filler=b""):
|
||||
settings = self.field(1, folder.encode()) + self.field(2, b"us") + b"\x18\x02" + filler
|
||||
return self.field(1, self.field(1, uid.encode()) + self.field(2, uid.encode()) + self.field(3, settings)
|
||||
+ b"\x21" + bytes(8) + b"\x2d" + bytes(4))
|
||||
|
||||
def database(self, *products):
|
||||
path = Path(BNET["drive_c"](self.root)) / "ProgramData/Battle.net/Agent/product.db"
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(b"".join(products) + self.field(7, b"tail"))
|
||||
path.chmod(0o600)
|
||||
return path
|
||||
|
||||
def test_games_registered_through_the_root_drive_move_to_their_volume_drive(self):
|
||||
game = self.library / "World of Warcraft"
|
||||
game.mkdir()
|
||||
other = self.tmp / "root/Games/Other"
|
||||
other.mkdir(parents=True)
|
||||
client = self.product("battle.net", "C:/Program Files (x86)/Battle.net")
|
||||
local = self.product("other", "Z:" + str(other))
|
||||
gone = self.product("gone", "Z:" + str(self.card / "Missing"))
|
||||
path = self.database(client, self.product("wow", "Z:" + str(game), bytes(200)), local, gone)
|
||||
self.assertTrue(BNET["move_installs"](self.root))
|
||||
self.assertEqual(path.read_bytes(), client + self.product("wow", "D:/Games/Battle.net/World of Warcraft", bytes(200))
|
||||
+ local + gone + self.field(7, b"tail"))
|
||||
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
|
||||
self.assertEqual(os.readlink(self.devices / "d:"), str(self.card))
|
||||
self.assertFalse(BNET["move_installs"](self.root))
|
||||
|
||||
def test_registrations_stay_while_the_prefix_runs_or_the_database_is_unreadable(self):
|
||||
game = self.library / "World of Warcraft"
|
||||
game.mkdir()
|
||||
path = self.database(self.product("wow", "Z:" + str(game)))
|
||||
before = path.read_bytes()
|
||||
self.running = [(5, ["C:\\ProgramData\\Battle.net\\Agent\\Agent.exe"])]
|
||||
self.assertFalse(BNET["move_installs"](self.root))
|
||||
self.assertEqual(path.read_bytes(), before)
|
||||
self.running = []
|
||||
for broken in (before[:-3], b"\x0a\xff", b"\x0b\x01"):
|
||||
path.write_bytes(broken)
|
||||
self.assertFalse(BNET["move_installs"](self.root))
|
||||
self.assertEqual(path.read_bytes(), broken)
|
||||
os.unlink(path)
|
||||
self.assertFalse(BNET["move_installs"](self.root))
|
||||
|
||||
def test_a_database_written_while_it_was_being_read_is_left_as_written(self):
|
||||
game = self.library / "World of Warcraft"
|
||||
game.mkdir()
|
||||
path = self.database(self.product("wow", "Z:" + str(game)))
|
||||
newer = path.read_bytes() + self.field(7, b"newer")
|
||||
|
||||
def processes(pfx, proc="/proc"):
|
||||
path.write_bytes(newer)
|
||||
return []
|
||||
|
||||
with mock.patch.dict(BNET, {"wine_processes": processes}):
|
||||
self.assertFalse(BNET["move_installs"](self.root))
|
||||
self.assertEqual(path.read_bytes(), newer)
|
||||
self.assertTrue(BNET["move_installs"](self.root))
|
||||
|
||||
|
||||
class GamepadTest(Temp):
|
||||
def registry(self, *entries):
|
||||
rows = ["WINE REGISTRY Version 2"]
|
||||
@@ -772,7 +921,7 @@ class Harness(Temp):
|
||||
"stop": lambda processes, wait=0: self.calls.append(("stop", sorted(pid for pid, _ in processes))),
|
||||
"start": lambda exe, verb=None: self.calls.append(("start", os.path.basename(exe), verb)) or self.Proton(),
|
||||
"spawn": lambda program, verb, args=(): self.calls.append(("spawn", os.path.basename(program), verb, list(args))),
|
||||
"acquire": lambda folder=None: self.lock,
|
||||
"acquire": lambda folder=None: self.lock, "volume_root": lambda path: "/",
|
||||
"POLL": 0, "READY_SETTLE": 0, "GAME_GRACE": 0, "CLIENT_WAIT": 0,
|
||||
})
|
||||
patcher.start()
|
||||
@@ -1170,6 +1319,7 @@ class AgentTest(Temp):
|
||||
script = BNET["AGENT_SCRIPT"]
|
||||
self.assertIn("port = a(0), action = a(1), uid = a(2), product = a(3), dir = a(4)", script)
|
||||
self.assertIn("lang = a(5), country = a(6), region = a(7), out = a(8)", script)
|
||||
self.assertIn(r'''"game_dir":"' + dir.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '","geo''', script)
|
||||
self.assertIn('"--internalclienttools"', (BIN / "droiddeck-battlenet").read_text())
|
||||
|
||||
def test_the_driver_asks_blizzards_chinese_repository_for_chinese_installs(self):
|
||||
@@ -1230,6 +1380,40 @@ class AgentJobTest(Harness):
|
||||
self.assertEqual([kind for kind, _ in self.lines], ["STATE", "PROGRESS", "DONE"])
|
||||
self.assertEqual(json.loads(self.lines[-1][1]), {"install_dir": "Z:" + folder, "exe": "WarcraftRumble.exe", "version": "16.1.2.119725"})
|
||||
|
||||
def test_an_install_on_another_volume_is_handed_over_by_its_drive_once_the_prefix_is_stopped(self):
|
||||
self.install()
|
||||
card = self.tmp / "card"
|
||||
folder = str(card / "Games/Battle.net/Warcraft Rumble")
|
||||
self.files = {".json": json.dumps({"progress": 1.0, "download_complete": True, "state": 1004}),
|
||||
".game": json.dumps({"installed": True, "install_dir": "D:/Games/Battle.net/Warcraft Rumble", "local_version": "1",
|
||||
"binaries": {"game": {"relative_path": "WarcraftRumble.exe"}}})}
|
||||
self.states = [[(7, self.AGENT)]]
|
||||
events = []
|
||||
real_map = BNET["map_drive"]
|
||||
|
||||
def acquire(folder=None):
|
||||
events.append("lock")
|
||||
return self.lock
|
||||
|
||||
def stop(pfx):
|
||||
events.append(("stop", not self.lock.closed))
|
||||
self.states = [[]]
|
||||
return True
|
||||
|
||||
def map_drive(root, volume):
|
||||
events.append(("map", not self.lock.closed))
|
||||
return real_map(root, volume)
|
||||
|
||||
with mock.patch.dict(BNET, {"volume_root": lambda path: str(card), "stop_leftovers": stop, "map_drive": map_drive,
|
||||
"acquire": acquire}):
|
||||
code = BNET["agent_job"](self.root, "install", "gryphon", "gryphon", folder, "enUS", "USA", "US", poll=0)
|
||||
self.assertEqual(code, 0)
|
||||
self.assertEqual(events, ["lock", ("stop", True), ("map", True)])
|
||||
self.assertTrue(self.lock.closed)
|
||||
cmd = self.started[0]
|
||||
self.assertEqual(cmd[cmd.index("--") + 6], "D:\\Games\\Battle.net\\Warcraft Rumble")
|
||||
self.assertEqual(os.readlink(os.path.join(BNET["dosdevices"](self.root), "d:")), str(card))
|
||||
|
||||
def test_an_agent_error_is_reported_with_its_code(self):
|
||||
self.install()
|
||||
self.files = {".json": json.dumps({"error": 2421, "progress": 0.0})}
|
||||
@@ -1257,6 +1441,138 @@ class AgentJobTest(Harness):
|
||||
self.assertEqual(BNET["agent_job"](self.root, "update", "gryphon", poll=0), 1)
|
||||
self.assertEqual(self.lines[-1][0], "ERROR")
|
||||
|
||||
def test_a_job_that_stops_moving_is_ended_as_stalled_and_its_agent_stopped(self):
|
||||
self.install()
|
||||
self.files = {".json": json.dumps({"state": 1003, "paused": True, "download_current": [10, 0, 0], "download_total": [99, 0, 0]})}
|
||||
killed = []
|
||||
stopped = []
|
||||
|
||||
class Hung:
|
||||
returncode = None
|
||||
|
||||
def __init__(self, cmd, **kwargs):
|
||||
base = cmd[-1][2:].replace("\\", "/")
|
||||
with open(base + ".json", "wb") as f:
|
||||
f.write(self_files[".json"].encode("utf-16"))
|
||||
|
||||
def poll(self):
|
||||
return None
|
||||
|
||||
def kill(self):
|
||||
killed.append(True)
|
||||
|
||||
def wait(self):
|
||||
return -9
|
||||
|
||||
self_files = self.files
|
||||
with mock.patch.object(BNET["subprocess"], "Popen", Hung), \
|
||||
mock.patch.dict(BNET, {"wine_processes": lambda pfx: [(5, ["agent.exe"])], "stop": lambda p: stopped.append(p)}):
|
||||
code = BNET["agent_job"](self.root, "install", "s1", "s1", str(self.tmp / "S1"), "enUS", "USA", "US", poll=0, stall=0.05)
|
||||
self.assertEqual(code, 6)
|
||||
self.assertEqual(killed, [True])
|
||||
self.assertEqual(stopped, [[(5, ["agent.exe"])]])
|
||||
self.assertEqual(self.lines[-1], ("ERROR", "stalled"))
|
||||
|
||||
def test_a_stalled_job_leaves_a_game_or_client_in_the_prefix_running(self):
|
||||
self.install()
|
||||
self.files = {".json": json.dumps({"state": 1003, "download_current": [10, 0, 0], "download_total": [99, 0, 0]})}
|
||||
stopped = []
|
||||
calls = []
|
||||
|
||||
class Hung:
|
||||
returncode = None
|
||||
|
||||
def __init__(self, cmd, **kwargs):
|
||||
calls.append(True)
|
||||
|
||||
def poll(self):
|
||||
return None
|
||||
|
||||
def kill(self):
|
||||
pass
|
||||
|
||||
def wait(self):
|
||||
return -9
|
||||
|
||||
def processes(pfx):
|
||||
if not calls:
|
||||
return [(3, ["agent.exe"])]
|
||||
return [(3, ["agent.exe"]), (5, ["Agent.exe"]), (6, ["wineserver"]), (7, ["Wow.exe"])]
|
||||
|
||||
with mock.patch.object(BNET["subprocess"], "Popen", Hung), \
|
||||
mock.patch.dict(BNET, {"wine_processes": processes, "stop": lambda p: stopped.append(p)}):
|
||||
code = BNET["agent_job"](self.root, "install", "s1", "s1", str(self.tmp / "S1"), "enUS", "USA", "US", poll=0, stall=0.05)
|
||||
self.assertEqual(code, 6)
|
||||
self.assertEqual(stopped, [[(5, ["Agent.exe"])]])
|
||||
|
||||
def test_only_a_changing_rate_or_estimate_does_not_hold_off_the_stall(self):
|
||||
self.install()
|
||||
clock = [0.0]
|
||||
|
||||
class Spinning:
|
||||
returncode = None
|
||||
|
||||
def __init__(self, cmd, **kwargs):
|
||||
self.base = cmd[-1][2:].replace("\\", "/")
|
||||
self.polls = 0
|
||||
|
||||
def poll(self):
|
||||
self.polls += 1
|
||||
if self.polls > 10:
|
||||
raise AssertionError("the stall timeout never ended the job")
|
||||
clock[0] += 10
|
||||
with open(self.base + ".json", "wb") as f:
|
||||
f.write(json.dumps({"state": 1003, "download_current": [4, 0, 0], "download_total": [9, 0, 0],
|
||||
"download_rate": self.polls, "estimated_time_in_sec": self.polls}).encode("utf-16"))
|
||||
return None
|
||||
|
||||
def kill(self):
|
||||
pass
|
||||
|
||||
def wait(self):
|
||||
return -9
|
||||
|
||||
fake = mock.Mock(monotonic=lambda: clock[0], sleep=lambda s: None)
|
||||
with mock.patch.object(BNET["subprocess"], "Popen", Spinning), mock.patch.dict(BNET, {"time": fake, "stop": lambda p: None}):
|
||||
code = BNET["agent_job"](self.root, "update", "gryphon", poll=0, stall=25)
|
||||
self.assertEqual(code, 6)
|
||||
self.assertEqual(self.lines[-1], ("ERROR", "stalled"))
|
||||
|
||||
def test_a_moving_job_is_not_ended_as_stalled(self):
|
||||
self.install()
|
||||
done = json.dumps({"installed": True, "playable": True, "install_dir": "Z:/g", "local_version": "2"})
|
||||
clock = [0.0]
|
||||
|
||||
class Moving:
|
||||
returncode = 0
|
||||
|
||||
def __init__(self, cmd, **kwargs):
|
||||
self.base = cmd[-1][2:].replace("\\", "/")
|
||||
self.polls = 0
|
||||
|
||||
def poll(self):
|
||||
self.polls += 1
|
||||
clock[0] += 10
|
||||
with open(self.base + ".json", "wb") as f:
|
||||
f.write(json.dumps({"state": 1003, "download_current": [self.polls, 0, 0], "download_total": [9, 0, 0]}).encode("utf-16"))
|
||||
if self.polls < 6:
|
||||
return None
|
||||
with open(self.base + ".game", "wb") as f:
|
||||
f.write(done.encode("utf-16"))
|
||||
return 0
|
||||
|
||||
fake = mock.Mock(monotonic=lambda: clock[0], sleep=lambda s: None)
|
||||
with mock.patch.object(BNET["subprocess"], "Popen", Moving), mock.patch.dict(BNET, {"time": fake}):
|
||||
code = BNET["agent_job"](self.root, "update", "gryphon", poll=0, stall=15)
|
||||
self.assertEqual(code, 0)
|
||||
self.assertNotIn(("ERROR", "stalled"), self.lines)
|
||||
|
||||
def test_only_a_real_job_reply_counts_as_started(self):
|
||||
script = BNET["AGENT_SCRIPT"]
|
||||
self.assertIn("if (state == 1000 || state == 1003 || job(s) && !complete) started = true;", script)
|
||||
self.assertIn('return /"state"\\s*:\\s*\\d+/.test(bare) || /"download_current"\\s*:/.test(bare);', script)
|
||||
self.assertIn('if (/"error"\\s*:\\s*[1-9]/.test(text)) return false;', script)
|
||||
|
||||
def test_the_driver_only_stops_once_the_agent_has_really_run(self):
|
||||
script = BNET["AGENT_SCRIPT"]
|
||||
self.assertIn("if (started && (state == 1004 || complete && /\"playable\"\\s*:\\s*true/.test(s))) break;", script)
|
||||
|
||||
@@ -22,22 +22,29 @@ extern char **environ;
|
||||
int main(int argc, char **argv) {
|
||||
if (argc < 3) return 2;
|
||||
const char *how = argv[1], *file = argv[2];
|
||||
char *node_env[] = {"ELECTRON_RUN_AS_NODE=1", NULL};
|
||||
char *const *child_env = !strcmp(how, "execve-node") || !strcmp(how, "execvpe-node") ||
|
||||
!strcmp(how, "spawn-node") || !strcmp(how, "spawnp-node") ? node_env : environ;
|
||||
char **args = argv + 2;
|
||||
if (!strcmp(how, "access")) {
|
||||
int result = access(file, X_OK);
|
||||
printf("access %d %d\n", result, result ? errno : 0);
|
||||
return 0;
|
||||
}
|
||||
if (!strcmp(how, "spawn") || !strcmp(how, "spawnp")) {
|
||||
if (!strcmp(how, "spawn") || !strcmp(how, "spawnp") || !strcmp(how, "spawn-node") ||
|
||||
!strcmp(how, "spawnp-node")) {
|
||||
pid_t pid;
|
||||
int error = how[5] ? posix_spawnp(&pid, file, NULL, NULL, args, environ) : posix_spawn(&pid, file, NULL, NULL, args, environ);
|
||||
int spawnp = !strcmp(how, "spawnp") || !strcmp(how, "spawnp-node");
|
||||
int error = spawnp ? posix_spawnp(&pid, file, NULL, NULL, args, child_env)
|
||||
: posix_spawn(&pid, file, NULL, NULL, args, child_env);
|
||||
if (error) { printf("errno %d\n", error); return 3; }
|
||||
int status;
|
||||
waitpid(pid, &status, 0);
|
||||
printf("exit %d\n", WEXITSTATUS(status));
|
||||
return 0;
|
||||
}
|
||||
if (!strcmp(how, "execve")) execve(file, args, environ);
|
||||
if (!strcmp(how, "execve") || !strcmp(how, "execve-node")) execve(file, args, (char *const *)child_env);
|
||||
else if (!strcmp(how, "execvpe-node")) execvpe(file, args, (char *const *)child_env);
|
||||
else if (!strcmp(how, "execv")) execv(file, args);
|
||||
else if (!strcmp(how, "execvp")) execvp(file, args);
|
||||
else if (!strcmp(how, "execvpe")) execvpe(file, args, environ);
|
||||
@@ -88,6 +95,15 @@ class BinfmtPreloadTest(unittest.TestCase):
|
||||
path.chmod(mode)
|
||||
return path
|
||||
|
||||
def chromium_script(self):
|
||||
folder = self.dir / "vscode"
|
||||
folder.mkdir()
|
||||
executable = folder / "code"
|
||||
executable.write_text("#!/bin/sh\nprintf '%s\\n' \"$@\"\n")
|
||||
executable.chmod(0o755)
|
||||
(folder / "chrome-sandbox").touch()
|
||||
return executable
|
||||
|
||||
def environment(self, desktop=True, **extra):
|
||||
env = {"PATH": "%s:/usr/bin:/bin" % self.dir, "LD_PRELOAD": str(self.library), "HANDLER_LOG": str(self.log)}
|
||||
if desktop:
|
||||
@@ -161,6 +177,17 @@ class BinfmtPreloadTest(unittest.TestCase):
|
||||
self.file("script.sh", b"#!/bin/sh\nexit 5\n")
|
||||
self.assertEqual(self.run_program("spawnp", "script.sh"), (0, "exit 5", None))
|
||||
|
||||
def test_explicit_node_child_environment_skips_injection_for_execve_and_spawn(self):
|
||||
code = self.chromium_script()
|
||||
self.assertEqual(self.run_program("execve-node", code, "--version"), (0, "--version", None))
|
||||
self.assertEqual(self.run_program("execvpe-node", code, "--version"), (0, "--version", None))
|
||||
self.assertEqual(self.run_program("spawn-node", code, "--version"), (0, "--version\nexit 0", None))
|
||||
self.assertEqual(self.run_program("spawnp-node", code, "--version"), (0, "--version\nexit 0", None))
|
||||
|
||||
def test_chromium_gui_launch_without_node_mode_still_receives_no_sandbox(self):
|
||||
code = self.chromium_script()
|
||||
self.assertEqual(self.run_program("execve", code, "--version"), (0, "--no-sandbox\n--version", None))
|
||||
|
||||
def test_the_hand_off_switch_works_without_the_desktop(self):
|
||||
tool = self.x86()
|
||||
for how in ("execve", "execvp"):
|
||||
|
||||
@@ -58,11 +58,17 @@ class CiChecksTest(unittest.TestCase):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
sudo = root / 'sudo'
|
||||
sudo.write_text('#!/bin/bash\nprintf "%s\\n" "$*" >> "$APT_LOG"\nexit "${APT_RESULT:-0}"\n')
|
||||
sudo.write_text('#!/bin/bash\nprintf "%s\\n" "$*" >> "$APT_LOG"\n'
|
||||
'for arg; do case "$arg" in Dir::Etc::sourcelist=*) '
|
||||
'grep -h "^URIs:" "${arg#*=}" >> "$APT_LOG.mirrors";; esac; done\n'
|
||||
'exit "${APT_RESULT:-0}"\n')
|
||||
sudo.chmod(0o755)
|
||||
query = root / 'dpkg-query'
|
||||
query.write_text('#!/bin/sh\nexit 1\n')
|
||||
query.chmod(0o755)
|
||||
dpkg = root / 'dpkg'
|
||||
dpkg.write_text('#!/bin/sh\necho "${DPKG_ARCH:-amd64}"\n')
|
||||
dpkg.chmod(0o755)
|
||||
log = root / 'apt.log'
|
||||
sources = root / 'ubuntu.sources'
|
||||
sources.write_text('URIs: http://mirror.invalid/ubuntu\n')
|
||||
@@ -71,8 +77,23 @@ class CiChecksTest(unittest.TestCase):
|
||||
installer = ROOT / 'tools/ci/install-ubuntu-packages.sh'
|
||||
result = subprocess.run(['bash', str(installer), 'qemu-user'], env=dict(env, APT_RESULT='17'))
|
||||
self.assertEqual(result.returncode, 17)
|
||||
self.assertEqual(len(log.read_text().splitlines()), 2)
|
||||
self.assertEqual(len(log.read_text().splitlines()), 3)
|
||||
mirrors = Path(str(log) + '.mirrors')
|
||||
self.assertEqual(mirrors.read_text().splitlines(), [
|
||||
'URIs: http://mirror.invalid/ubuntu',
|
||||
'URIs: https://archive.ubuntu.com/ubuntu',
|
||||
'URIs: https://mirrors.edge.kernel.org/ubuntu',
|
||||
])
|
||||
log.unlink()
|
||||
mirrors.unlink()
|
||||
result = subprocess.run(['bash', str(installer), 'qemu-user'], env=dict(env, APT_RESULT='17', DPKG_ARCH='arm64'))
|
||||
self.assertEqual(result.returncode, 17)
|
||||
self.assertEqual(mirrors.read_text().splitlines()[1:], [
|
||||
'URIs: https://ports.ubuntu.com/ubuntu-ports',
|
||||
'URIs: https://mirrors.ocf.berkeley.edu/ubuntu-ports',
|
||||
])
|
||||
log.unlink()
|
||||
mirrors.unlink()
|
||||
subprocess.run(['bash', str(installer), 'qemu-user'], env=env, check=True)
|
||||
update, install = log.read_text().splitlines()
|
||||
for command in (update, install):
|
||||
|
||||
@@ -121,6 +121,7 @@ step() { :; }
|
||||
bl_zram_scan() { :; }
|
||||
bl_memory_read() { :; }
|
||||
bl_client_pressure() { :; }
|
||||
bl_client_pressure_finish() { :; }
|
||||
bl_session_pressure() { :; }
|
||||
bl_client_can_pageout() { return 0; }
|
||||
bl_client_can_readback() { [ "${readback:-1}" = 1 ]; }
|
||||
|
||||
@@ -1,19 +1,34 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import queue
|
||||
import re
|
||||
import shlex
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
|
||||
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
||||
|
||||
|
||||
def clock_reset_command(control):
|
||||
script = (PRELOAD.parent / "overlay/usr/local/bin/droiddeck-session").read_text()
|
||||
start = script.index('if [ -z "${BL_INSIDE:-}" ]; then\n if [ "${BL_ZRAM:-0}"')
|
||||
end = script.index("\nfi", start) + len("\nfi")
|
||||
paths = {"/tmp/.bl-clock": shlex.quote(str(control)),
|
||||
"/tmp/.bl-zram": shlex.quote(str(control.parent / "zram"))}
|
||||
pattern = "|".join(re.escape(token) for token in paths)
|
||||
return 'BL_INSIDE=; BL_ZRAM=0; ' + re.sub(pattern, lambda match: paths[match.group(0)], script[start:end])
|
||||
|
||||
PROGRAM = r"""
|
||||
#define _GNU_SOURCE
|
||||
#include <linux/futex.h>
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/timerfd.h>
|
||||
@@ -36,12 +51,26 @@ static int64_t start;
|
||||
static void begin(void) { start = ns(CLOCK_BOOTTIME); }
|
||||
static void end(const char *name) { printf("%s %lld\n", name, (long long)((ns(CLOCK_BOOTTIME) - start) / 1000000LL)); }
|
||||
|
||||
static unsigned long long memory_probe(void) {
|
||||
static volatile unsigned char memory[4 * 1024 * 1024];
|
||||
unsigned long long checksum = 0;
|
||||
for (size_t i = 0; i < sizeof(memory); i += 4096) memory[i] = (unsigned char)(i / 4096 + 1);
|
||||
for (size_t i = 0; i < sizeof(memory); i += 4096) checksum += memory[i];
|
||||
return checksum;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
const int64_t wait = 60000000LL;
|
||||
printf("gap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
|
||||
struct timespec raw;
|
||||
syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &raw);
|
||||
printf("rawgap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ((int64_t)raw.tv_sec * 1000000000LL + raw.tv_nsec)) / 1000000LL));
|
||||
printf("memory %llu\n", memory_probe());
|
||||
if (getenv("CLOCK_PAUSE_WAIT")) { puts("ready"); fflush(stdout); getchar(); }
|
||||
if (getenv("CLOCK_PAUSE_WAIT")) {
|
||||
printf("livegap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
|
||||
printf("livememory %llu\n", memory_probe());
|
||||
}
|
||||
|
||||
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
pthread_condattr_t attr;
|
||||
@@ -124,14 +153,124 @@ class ClockPausePreloadTest(unittest.TestCase):
|
||||
self.assertGreaterEqual(paused[name], 50, name)
|
||||
self.assertLess(paused[name], 1000, name)
|
||||
|
||||
def test_other_programs_keep_the_real_clock(self):
|
||||
def test_program_without_preload_keeps_the_real_clock(self):
|
||||
plain = self.run_program(self.other, 0, preload=False)
|
||||
paused = self.run_program(self.other, SHIFT_MS)
|
||||
paused = self.run_program(self.other, SHIFT_MS, preload=False)
|
||||
self.assertAlmostEqual(paused["gap"], plain["gap"], delta=50)
|
||||
for name in ("cond_mono", "clockwait", "sem", "nanosleep", "timerfd", "futex"):
|
||||
self.assertGreaterEqual(paused[name], 50, name)
|
||||
self.assertLess(paused[name], 1000, name)
|
||||
|
||||
def test_every_session_program_stops_monotonic_clock_and_keeps_memory_access(self):
|
||||
plain = self.run_program(self.other, 0)
|
||||
paused = self.run_program(self.other, SHIFT_MS)
|
||||
self.assertAlmostEqual(paused["gap"] - plain["gap"], SHIFT_MS, delta=50)
|
||||
self.assertAlmostEqual(paused["rawgap"] - plain["rawgap"], SHIFT_MS, delta=50)
|
||||
self.assertEqual(plain["memory"], 130560)
|
||||
self.assertEqual(paused["memory"], 130560)
|
||||
|
||||
def test_running_session_program_observes_pause_offset_update(self):
|
||||
self.check_running_offset_update(False)
|
||||
|
||||
def test_session_reset_preserves_live_guest_mapping(self):
|
||||
self.check_running_offset_update(True)
|
||||
|
||||
def check_running_offset_update(self, reset):
|
||||
self.control.write_bytes(struct.pack("<q", 0))
|
||||
env = dict(os.environ)
|
||||
env["LD_PRELOAD"] = str(self.preload)
|
||||
env["CLOCK_PAUSE_WAIT"] = "1"
|
||||
with tempfile.TemporaryFile(mode="w+") as errors:
|
||||
process = subprocess.Popen([str(self.other)], env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
||||
stderr=errors, text=True)
|
||||
lines = queue.Queue()
|
||||
|
||||
def read_handshake():
|
||||
for _ in range(4):
|
||||
line = process.stdout.readline()
|
||||
lines.put(line)
|
||||
if not line:
|
||||
break
|
||||
|
||||
threading.Thread(target=read_handshake, daemon=True).start()
|
||||
try:
|
||||
handshake = []
|
||||
for _ in range(4):
|
||||
try:
|
||||
line = lines.get(timeout=5)
|
||||
except queue.Empty:
|
||||
line = ""
|
||||
if not line:
|
||||
if process.poll() is None:
|
||||
process.kill()
|
||||
process.wait(timeout=5)
|
||||
errors.seek(0)
|
||||
self.fail(f"child handshake timed out or ended early (exit {process.returncode}): {errors.read()}")
|
||||
handshake.append(line.strip())
|
||||
self.assertEqual(handshake[3], "ready")
|
||||
self.assertTrue(handshake[0].startswith("gap "))
|
||||
initial_gap = int(handshake[0].split()[1])
|
||||
rawgap = handshake[1]
|
||||
memory = handshake[2]
|
||||
self.assertTrue(rawgap.startswith("rawgap "))
|
||||
self.assertEqual(memory, "memory 130560")
|
||||
if reset:
|
||||
inode = self.control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(self.control)],
|
||||
check=True, timeout=5)
|
||||
self.assertEqual(self.control.stat().st_ino, inode)
|
||||
self.assertEqual(self.control.read_bytes(), struct.pack("<q", 0))
|
||||
with self.control.open("r+b") as control:
|
||||
control.write(struct.pack("<q", SHIFT_MS * 1000000))
|
||||
control.flush()
|
||||
process.stdin.write("\n")
|
||||
process.stdin.flush()
|
||||
output, _ = process.communicate(timeout=5)
|
||||
errors.seek(0)
|
||||
self.assertEqual(process.returncode, 0, errors.read())
|
||||
values = dict(line.split() for line in output.splitlines())
|
||||
self.assertAlmostEqual(int(values["livegap"]) - initial_gap, SHIFT_MS, delta=50)
|
||||
self.assertEqual(int(values["livememory"]), 130560)
|
||||
finally:
|
||||
if process.poll() is None:
|
||||
process.kill()
|
||||
process.communicate()
|
||||
|
||||
|
||||
class ClockResetCommandTest(unittest.TestCase):
|
||||
def test_reset_keeps_paths_with_spaces_and_shell_syntax_as_single_arguments(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
folder = root / "session dir; touch injected $(touch substituted) 'quoted'"
|
||||
folder.mkdir()
|
||||
control = folder / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000) + b"tail")
|
||||
(folder / "zram").write_text("1")
|
||||
bystander = root / "session"
|
||||
bystander.write_text("keep")
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(control.read_bytes(), struct.pack("<q", 0) + b"tail")
|
||||
self.assertFalse((folder / "zram").exists())
|
||||
self.assertEqual(bystander.read_text(), "keep")
|
||||
self.assertEqual(sorted(path.name for path in root.iterdir()), sorted([folder.name, bystander.name]))
|
||||
|
||||
def test_reset_does_not_rewrite_placeholders_inside_substituted_paths(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
folder = root / "tmp/.bl-zram/$(touch injected)"
|
||||
folder.mkdir(parents=True)
|
||||
control = folder / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
(folder / "zram").write_text("1")
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(control.read_bytes(), struct.pack("<q", 0))
|
||||
self.assertFalse((folder / "zram").exists())
|
||||
self.assertEqual([path.name for path in root.iterdir()], ["tmp"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,69 @@
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / 'agent/dd-lab-build'
|
||||
|
||||
|
||||
class LabBuildPackageTest(unittest.TestCase):
|
||||
def test_package_override_survives_app_handoff_without_its_environment(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
root = Path(tmp)
|
||||
inbox = root / 'agent'
|
||||
inbox.mkdir()
|
||||
cache = root / '.cache'
|
||||
env = {**os.environ, 'HOME': tmp, 'DD_AGENT': '1',
|
||||
'DD_AGENT_INBOX': str(inbox), 'DROIDDECK_PACKAGE': 'com.example.target'}
|
||||
env.pop('DD_LAB_DETACHED', None)
|
||||
child = subprocess.Popen(['bash', str(SCRIPT), '--prepare'], env=env,
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
|
||||
try:
|
||||
request = inbox / 'lab-request'
|
||||
deadline = time.monotonic() + 10
|
||||
while not request.exists() and child.poll() is None and time.monotonic() < deadline:
|
||||
time.sleep(0.01)
|
||||
self.assertTrue(request.exists())
|
||||
payload = json.loads(request.read_text())
|
||||
self.assertEqual(['--prepare', '--package=com.example.target'], payload['args'])
|
||||
progress = cache / 'dd-lab-build.json'
|
||||
progress.write_text('{"stage":"prepared"}')
|
||||
stdout, stderr = child.communicate(timeout=10)
|
||||
self.assertEqual(0, child.returncode, stdout + stderr)
|
||||
finally:
|
||||
if child.poll() is None:
|
||||
child.kill()
|
||||
child.communicate()
|
||||
|
||||
bin_dir = root / 'bin'
|
||||
bin_dir.mkdir()
|
||||
(bin_dir / 'adb').write_text('#!/bin/sh\nexit 0\n')
|
||||
(bin_dir / 'python3').write_text(
|
||||
'#!/bin/sh\nprintf "%s" "$DROIDDECK_PACKAGE" > "$HOME/selected-package"\nexit 1\n')
|
||||
for tool in bin_dir.iterdir():
|
||||
tool.chmod(0o755)
|
||||
env.pop('DROIDDECK_PACKAGE')
|
||||
env['DD_LAB_DETACHED'] = '1'
|
||||
env['PATH'] = str(bin_dir) + os.pathsep + env['PATH']
|
||||
result = subprocess.run(['bash', str(SCRIPT), *payload['args']], env=env,
|
||||
capture_output=True, text=True, timeout=10, cwd=SCRIPT.parents[2])
|
||||
self.assertNotEqual(0, result.returncode)
|
||||
self.assertIn('could not read DroidDeck', result.stderr)
|
||||
self.assertEqual('com.example.target', (root / 'selected-package').read_text())
|
||||
|
||||
def test_invalid_packages_are_rejected_before_handoff(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
inbox = Path(tmp) / 'agent'
|
||||
inbox.mkdir()
|
||||
for package in ('bad;touch injected', '../other', '', 'com.example/other'):
|
||||
with self.subTest(package=package):
|
||||
env = {**os.environ, 'HOME': tmp, 'DD_AGENT': '1', 'DD_AGENT_INBOX': str(inbox)}
|
||||
result = subprocess.run(['bash', str(SCRIPT), '--package=' + package], env=env,
|
||||
capture_output=True, text=True, timeout=10)
|
||||
self.assertNotEqual(0, result.returncode)
|
||||
self.assertIn('invalid Android package', result.stderr)
|
||||
self.assertFalse((inbox / 'lab-request').exists())
|
||||
@@ -0,0 +1,245 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
||||
|
||||
FAKE = r"""
|
||||
#define _GNU_SOURCE
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static int answer(int fd) {
|
||||
char link[32], path[4096];
|
||||
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
|
||||
long n = syscall(SYS_readlinkat, AT_FDCWD, link, path, sizeof(path) - 1);
|
||||
path[n > 0 ? n : 0] = '\0';
|
||||
if (strstr(path, "/card/")) return ENOTSUP;
|
||||
if (strstr(path, "/denied/")) return EACCES;
|
||||
return ENODATA;
|
||||
}
|
||||
|
||||
ssize_t fgetxattr(int fd, const char *name, void *value, size_t size) {
|
||||
(void)name; (void)value; (void)size;
|
||||
errno = answer(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int fsetxattr(int fd, const char *name, const void *value, size_t size, int flags) {
|
||||
(void)name; (void)value; (void)size; (void)flags;
|
||||
int error = answer(fd);
|
||||
if (error == ENODATA) return 0;
|
||||
errno = error;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int fremovexattr(int fd, const char *name) {
|
||||
(void)name;
|
||||
errno = answer(fd);
|
||||
return -1;
|
||||
}
|
||||
"""
|
||||
|
||||
PROGRAM = r"""
|
||||
#define _GNU_SOURCE
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/xattr.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static const char *error(void) {
|
||||
return errno == ENOTSUP ? "unsupported" : errno == ENODATA ? "none" : errno == ERANGE ? "range" :
|
||||
errno == EACCES ? "denied" : "other";
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
for (int i = 1; i < argc; i++) {
|
||||
const char *op = argv[i];
|
||||
if (!strcmp(op, "unlink") || !strcmp(op, "rmdir")) {
|
||||
const char *path = argv[++i];
|
||||
printf("%s\n", (op[0] == 'u' ? unlink(path) : rmdir(path)) == 0 ? "ok" : "failed");
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(op, "remove-path")) {
|
||||
printf("%s\n", remove(argv[++i]) == 0 ? "ok" : "failed");
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(op, "rename")) {
|
||||
const char *from = argv[++i], *to = argv[++i];
|
||||
printf("%s\n", rename(from, to) == 0 ? "ok" : "failed");
|
||||
continue;
|
||||
}
|
||||
int fd = open(argv[++i], O_RDONLY);
|
||||
char value[64];
|
||||
if (!strcmp(op, "set")) {
|
||||
const char *text = argv[++i];
|
||||
errno = 1234;
|
||||
int result = fsetxattr(fd, "user.wine.sd", text, strlen(text), 0);
|
||||
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
|
||||
} else if (!strcmp(op, "get")) {
|
||||
ssize_t n = fgetxattr(fd, "user.wine.sd", value, sizeof(value));
|
||||
if (n < 0) printf("%s\n", error());
|
||||
else printf("=%.*s\n", (int)n, value);
|
||||
} else if (!strcmp(op, "size")) {
|
||||
ssize_t n = fgetxattr(fd, "user.wine.sd", NULL, 0);
|
||||
if (n < 0) printf("%s\n", error());
|
||||
else printf("%d\n", (int)n);
|
||||
} else if (!strcmp(op, "short")) {
|
||||
ssize_t n = fgetxattr(fd, "user.wine.sd", value, 2);
|
||||
printf("%s\n", n < 0 ? error() : "read");
|
||||
} else if (!strcmp(op, "remove")) {
|
||||
errno = 1234;
|
||||
int result = fremovexattr(fd, "user.wine.sd");
|
||||
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
|
||||
} else if (!strcmp(op, "other")) {
|
||||
ssize_t n = fgetxattr(fd, "user.other", value, sizeof(value));
|
||||
printf("%s\n", n < 0 ? error() : "read");
|
||||
}
|
||||
close(fd);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
|
||||
class DescriptorPreloadTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.build_dir = tempfile.TemporaryDirectory()
|
||||
build = Path(cls.build_dir.name)
|
||||
(build / "fake.c").write_text(FAKE)
|
||||
(build / "program.c").write_text(PROGRAM)
|
||||
cls.preload = build / "libblsession.so"
|
||||
cls.fake = build / "fake.so"
|
||||
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(cls.preload),
|
||||
*map(str, sorted(PRELOAD.glob("*.c"))), "-ldl"], check=True)
|
||||
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-o", str(cls.fake), str(build / "fake.c")], check=True)
|
||||
cls.wineserver = build / "wineserver"
|
||||
subprocess.run(["cc", "-O2", "-o", str(cls.wineserver), str(build / "program.c")], check=True)
|
||||
cls.other = build / "wine64-preloader"
|
||||
shutil.copy(cls.wineserver, cls.other)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.build_dir.cleanup()
|
||||
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.dir = Path(os.path.realpath(self.temp.name))
|
||||
self.prefix = self.dir / "prefix"
|
||||
self.prefix.mkdir()
|
||||
self.store = self.prefix / ".droiddeck-descriptors"
|
||||
for kind in ("card", "disk", "denied"):
|
||||
(self.dir / kind / "game").mkdir(parents=True)
|
||||
(self.dir / kind / "game" / "file").write_text("x")
|
||||
|
||||
def tearDown(self):
|
||||
self.temp.cleanup()
|
||||
|
||||
def path(self, *parts):
|
||||
return str(self.dir.joinpath(*parts))
|
||||
|
||||
def run_as(self, program, *args, prefix=True):
|
||||
env = dict(os.environ, LD_PRELOAD="%s:%s" % (self.preload, self.fake))
|
||||
env.pop("WINEPREFIX", None)
|
||||
if prefix:
|
||||
env["WINEPREFIX"] = str(self.prefix)
|
||||
result = subprocess.run([str(program), *args], env=env, capture_output=True, text=True, check=True)
|
||||
return result.stdout.split()
|
||||
|
||||
def server(self, *args, **kwargs):
|
||||
return self.run_as(self.wineserver, *args, **kwargs)
|
||||
|
||||
def test_a_descriptor_is_kept_where_the_volume_cannot_store_it(self):
|
||||
file, folder = self.path("card", "game", "file"), self.path("card", "game")
|
||||
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "set", file, "one", "set", folder, "two"))
|
||||
self.assertEqual(["=one", "3", "=two"], self.server("get", file, "size", file, "get", folder))
|
||||
|
||||
def test_a_descriptor_is_replaced_and_removed(self):
|
||||
file = self.path("card", "game", "file")
|
||||
self.assertEqual(["ok", "ok", "=longer"], self.server("set", file, "one", "set", file, "longer", "get", file))
|
||||
self.assertEqual(["range", "ok", "none", "none"], self.server("short", file, "remove", file, "get", file, "remove", file))
|
||||
|
||||
def test_a_volume_that_stores_descriptors_is_left_alone(self):
|
||||
file = self.path("disk", "game", "file")
|
||||
self.assertEqual(["ok", "none", "none"], self.server("set", file, "one", "get", file, "remove", file))
|
||||
self.assertFalse(self.store.exists())
|
||||
|
||||
def test_other_failures_keep_their_error(self):
|
||||
file = self.path("denied", "game", "file")
|
||||
self.assertEqual(["denied", "denied", "denied"], self.server("set", file, "one", "get", file, "remove", file))
|
||||
self.assertFalse(self.store.exists())
|
||||
|
||||
def test_other_programs_and_other_attributes_are_unchanged(self):
|
||||
file = self.path("card", "game", "file")
|
||||
self.assertEqual(["unsupported", "unsupported", "unsupported"],
|
||||
self.run_as(self.other, "set", file, "one", "get", file, "remove", file))
|
||||
self.assertEqual(["ok", "unsupported"], self.server("set", file, "one", "other", file))
|
||||
self.assertEqual(["unsupported"], self.run_as(self.other, "get", file))
|
||||
|
||||
def test_nothing_is_kept_without_a_prefix(self):
|
||||
file = self.path("card", "game", "file")
|
||||
self.assertEqual(["unsupported", "unsupported", "unsupported"],
|
||||
self.server("set", file, "one", "get", file, "remove", file, prefix=False))
|
||||
|
||||
def test_a_deleted_file_loses_its_descriptor(self):
|
||||
file, folder = self.path("card", "game", "file"), self.path("card", "game")
|
||||
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "unlink", file))
|
||||
Path(file).write_text("x")
|
||||
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "unlink", file, "rmdir", folder))
|
||||
Path(folder).mkdir()
|
||||
self.assertEqual(["none"], self.server("get", folder))
|
||||
|
||||
def test_a_removed_file_or_folder_loses_its_descriptor(self):
|
||||
file, folder = self.path("card", "game", "file"), self.path("card", "game")
|
||||
self.assertEqual(["ok", "ok", "ok", "ok"],
|
||||
self.server("set", file, "one", "set", folder, "two", "remove-path", file, "remove-path", folder))
|
||||
Path(folder).mkdir()
|
||||
Path(file).write_text("x")
|
||||
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
|
||||
|
||||
def test_a_file_deleted_through_a_link_loses_its_descriptor(self):
|
||||
file = self.path("card", "game", "file")
|
||||
os.symlink(self.path("card"), self.path("drive"))
|
||||
self.assertEqual(["ok", "ok"], self.server("set", file, "one", "unlink", self.path("drive", "game", "file")))
|
||||
Path(file).write_text("x")
|
||||
self.assertEqual(["none"], self.server("get", file))
|
||||
|
||||
def test_a_descriptor_follows_a_rename(self):
|
||||
file, moved = self.path("card", "game", "file"), self.path("card", "game", "moved")
|
||||
self.assertEqual(["ok", "ok", "=one"], self.server("set", file, "one", "rename", file, moved, "get", moved))
|
||||
Path(file).write_text("x")
|
||||
self.assertEqual(["none", "ok", "none"], self.server("get", file, "rename", file, moved, "get", moved))
|
||||
|
||||
def test_descriptors_follow_a_renamed_folder(self):
|
||||
file, folder, moved = self.path("card", "game", "file"), self.path("card", "game"), self.path("card", "moved")
|
||||
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "rename", folder, moved))
|
||||
self.assertEqual(["=two", "=one"], self.server("get", moved, "get", self.path("card", "moved", "file")))
|
||||
Path(folder).mkdir()
|
||||
(Path(folder) / "file").write_text("x")
|
||||
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
|
||||
|
||||
def test_deletes_outside_the_store_cost_nothing_before_it_exists(self):
|
||||
file = self.path("disk", "game", "file")
|
||||
self.assertEqual(["ok"], self.server("unlink", file))
|
||||
self.assertFalse(self.store.exists())
|
||||
|
||||
def test_a_name_too_long_to_keep_reports_no_support(self):
|
||||
long_file = self.path("card", "game", "n" * 254)
|
||||
Path(long_file).write_text("x")
|
||||
self.assertEqual(["unsupported", "unsupported"], self.server("set", long_file, "one", "get", long_file))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -136,6 +136,30 @@ class CommandTest(Temp):
|
||||
self.assertEqual(OPEN["command"](script, [], "x86 script")[0],
|
||||
[OPEN["FEX"], "run", "--mode", "on", "--for", str(self.tmp), "--", "/bin/sh", script])
|
||||
|
||||
def test_a_store_games_exe_runs_through_its_launcher(self):
|
||||
exe, launcher = str(self.tmp / "game.exe"), str(self.tmp / "launch.bat")
|
||||
with mock.patch.dict(OPEN, {"store_launcher": lambda path: launcher if path == exe else None,
|
||||
"exe_prefix": lambda path: ["--prefix", "4242", "--compatdata", "/c/4242"]}):
|
||||
keep = ["--prefix", "4242", "--compatdata", "/c/4242"]
|
||||
self.assertEqual(OPEN["command"](exe, [], "windows")[0], [OPEN["PROTON_RUN"]] + keep + [launcher])
|
||||
self.assertEqual(OPEN["command"](exe, [], "windows", True)[0],
|
||||
[OPEN["PROTON_RUN"], "--window"] + keep + [launcher])
|
||||
self.assertEqual(OPEN["command"](exe, ["-x"], "windows")[0], [OPEN["PROTON_RUN"], exe, "-x"])
|
||||
other = str(self.tmp / "other.exe")
|
||||
self.assertEqual(OPEN["command"](other, [], "windows")[0], [OPEN["PROTON_RUN"], other])
|
||||
|
||||
def test_a_store_games_launcher_keeps_the_exes_prefix(self):
|
||||
exe = self.tmp / "game.exe"
|
||||
exe.write_text("x")
|
||||
root = str(self.tmp / "steam")
|
||||
with mock.patch.dict(os.environ, {"STEAM_COMPAT_CLIENT_INSTALL_PATH": root}), \
|
||||
mock.patch.dict(OPEN, {"PROTON_RUN": str(BIN / "droiddeck-proton-run"),
|
||||
"store_launcher": lambda path: str(self.tmp / "launch.bat")}):
|
||||
command = OPEN["command"](str(exe), [], "windows")[0]
|
||||
located = RUN["locate"](str(exe), root)
|
||||
self.assertEqual(command[1:5], ["--prefix", located.appid, "--compatdata", located.compatdata])
|
||||
self.assertEqual(str(RUN["own_id"](str(exe))), str(RUN["locate"](str(exe), root).appid))
|
||||
|
||||
def test_a_native_program_on_noexec_storage_runs_from_a_copy(self):
|
||||
program = self.write("storage/tool", elf(183))
|
||||
x86 = self.write("storage/game.x86_64", elf(62))
|
||||
@@ -737,6 +761,20 @@ class ProtonRunTest(Temp):
|
||||
self.assertEqual(env["STEAM_COMPAT_DATA_PATH"], str(signed))
|
||||
self.assertFalse((self.root / "steamapps/compatdata/2733369024").exists())
|
||||
|
||||
def test_a_launcher_run_keeps_the_resolved_compatdata_folder(self):
|
||||
bat = self.write("Games/Epic/Game/.droiddeck-launch.bat", b"@echo off")
|
||||
signed = self.root / "steamapps/compatdata/-1561598272"
|
||||
signed.mkdir(parents=True)
|
||||
other = self.tmp / "Library2/steamapps/compatdata/555"
|
||||
other.mkdir(parents=True)
|
||||
for compatdata, appid in ((signed, "2733369024"), (other, "555")):
|
||||
with self.subTest(compatdata=str(compatdata)):
|
||||
code, calls, dirs = self.run_main(["--prefix", appid, "--compatdata", str(compatdata), str(bat)])
|
||||
self.assertIsNone(code)
|
||||
self.assertEqual(calls[0][2]["STEAM_COMPAT_DATA_PATH"], str(compatdata))
|
||||
code, calls, dirs = self.run_main(["--prefix", "555", str(bat)])
|
||||
self.assertEqual(calls[0][2]["STEAM_COMPAT_DATA_PATH"], str(self.root / "steamapps/compatdata/555"))
|
||||
|
||||
def test_prefix_folder_prefers_initialized_unsigned_over_empty_signed(self):
|
||||
signed = self.root / "steamapps/compatdata/-1561598272"
|
||||
signed.mkdir(parents=True)
|
||||
|
||||
@@ -83,9 +83,25 @@ int inotify_add_watch(int fd, const char *path, uint32_t mask) {
|
||||
errno = ENOSPC;
|
||||
return -1;
|
||||
}
|
||||
if (getenv("NESTED") && (mask & IN_ONLYDIR)) {
|
||||
static DIR *(*uncounted)(const char *);
|
||||
if (!uncounted) uncounted = dlsym(RTLD_NEXT, "opendir");
|
||||
mkdir(path, 0755);
|
||||
DIR *d = uncounted("/proc/self/fd");
|
||||
while (d && readdir(d)) {}
|
||||
if (d) closedir(d);
|
||||
}
|
||||
return next(fd, path, mask);
|
||||
}
|
||||
|
||||
int remove(const char *path) {
|
||||
static int (*next)(const char *);
|
||||
if (!next) next = dlsym(RTLD_NEXT, "remove");
|
||||
if (!getenv("NESTED")) return next(path);
|
||||
if (unlink(path) == 0) return 0;
|
||||
return errno == EISDIR ? rmdir(path) : -1;
|
||||
}
|
||||
|
||||
int statfs(const char *path, struct statfs *out) {
|
||||
static int (*next)(const char *, struct statfs *);
|
||||
if (!next) next = dlsym(RTLD_NEXT, "statfs");
|
||||
@@ -337,9 +353,9 @@ class DirCachePreloadTest(unittest.TestCase):
|
||||
environment.update(env or {})
|
||||
return environment
|
||||
|
||||
def run_program(self, *args, program=None, env=None):
|
||||
def run_program(self, *args, program=None, env=None, timeout=60):
|
||||
result = subprocess.run([str(program or self.steam), *map(str, args)], env=self.environment(env),
|
||||
capture_output=True, text=True, check=True, timeout=60)
|
||||
capture_output=True, text=True, check=True, timeout=timeout)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def run_paused(self, *args, between, env=None):
|
||||
@@ -675,6 +691,20 @@ class DirCachePreloadTest(unittest.TestCase):
|
||||
env={"BL_NO_DIR_CACHE": "1"})
|
||||
self.assertEqual(["-1 2", "-1 2", "2"], out[1:])
|
||||
|
||||
def test_a_preload_below_calling_back_while_a_folder_is_watched_does_not_hang(self):
|
||||
common = self.lib / "common/Game"
|
||||
common.mkdir(parents=True)
|
||||
(common / "game.exe").touch()
|
||||
out = self.run_program("list", self.staging, "list", common, "list", common, "opens",
|
||||
env={"NESTED": "1"}, timeout=20)
|
||||
self.assertEqual(["a.bundle,b.bundle", "game.exe", "game.exe", "2"], out)
|
||||
|
||||
def test_a_preload_below_removing_through_unlink_does_not_hang(self):
|
||||
s = self.staging
|
||||
out = self.run_program("list", s, "remove", s / "a.bundle", "list", s, "raw", s, "opens",
|
||||
env={"NESTED": "1"}, timeout=20)
|
||||
self.assertEqual(["a.bundle,b.bundle", "b.bundle", "b.bundle", "1"], out)
|
||||
|
||||
def test_can_be_turned_off(self):
|
||||
out = self.run_program("list", self.staging, "list", self.staging, "opens", env={"BL_NO_DIR_CACHE": "1"})
|
||||
self.assertEqual("2", out[-1])
|
||||
|
||||
@@ -175,17 +175,27 @@ class RuntimeExtractTest(EpicTestCase):
|
||||
old = self.state / "app/0.1"
|
||||
old.mkdir(parents=True)
|
||||
|
||||
def extract_app(image, dest):
|
||||
os.makedirs(os.path.join(dest, "usr/bin"))
|
||||
Path(dest, "AppRun").write_text("run")
|
||||
Path(dest, "usr/bin/EpicGamesLauncher").write_text("bin")
|
||||
layers = []
|
||||
|
||||
def extract_app(image, dest, desktop=()):
|
||||
layers.append(list(desktop))
|
||||
os.makedirs(os.path.join(dest, "usr/bin"))
|
||||
os.makedirs(os.path.join(dest, "desktop/usr/lib/x86_64-linux-gnu"))
|
||||
Path(dest, "usr/bin/EpicGamesLauncher").write_text("bin")
|
||||
Path(dest, "desktop/usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0").write_text("webkit")
|
||||
|
||||
package = self.tmp / "libwebkit.deb"
|
||||
package.write_bytes(b"x")
|
||||
with mock.patch.dict(G, {"extract_app": extract_app, "fex_tool": lambda request=False: {"bin": "/fex", "server": "/s"}}), \
|
||||
mock.patch("sys.stdout", new_callable=io.StringIO) as out:
|
||||
image = self.tmp / "image"
|
||||
image.write_bytes(b"x")
|
||||
with self.assertRaises(G["Failure"]):
|
||||
G["install"]({"app": str(image), "app-version": "0.95.2+g1", "runtime": str(tarball),
|
||||
"runtime-version": "4.0.1", "gles": str(deb), "desktop": [str(self.tmp / "missing.deb")]})
|
||||
code = G["install"]({"app": str(image), "app-version": "0.95.2+g1", "runtime": str(tarball),
|
||||
"runtime-version": "4.0.1", "gles": str(deb)})
|
||||
"runtime-version": "4.0.1", "gles": str(deb), "desktop": [str(package)]})
|
||||
self.assertEqual([[str(package)]], layers)
|
||||
self.assertEqual(0, code)
|
||||
report = json.loads(out.getvalue())
|
||||
self.assertTrue(report["installed"])
|
||||
@@ -197,6 +207,147 @@ class RuntimeExtractTest(EpicTestCase):
|
||||
self.assertTrue((self.state / "app/0.95.2+g1/.droiddeck-ready").is_file())
|
||||
|
||||
|
||||
def deb(path, entries, compression="gz"):
|
||||
data = io.BytesIO()
|
||||
with tarfile.open(fileobj=data, mode="w:" + compression) as archive:
|
||||
for entry in entries:
|
||||
tar_add(archive, *entry[:1], **entry[1])
|
||||
path.write_bytes(ar([("debian-binary", b"2.0\n"), ("control.tar.xz", b"c"), ("data.tar." + compression, data.getvalue())]))
|
||||
return path
|
||||
|
||||
|
||||
class LauncherDebTest(EpicTestCase):
|
||||
def launcher(self, extra=()):
|
||||
return deb(self.tmp / "EpicGamesLauncher-x86_64.deb", [
|
||||
("./usr", {"kind": "dir"}),
|
||||
("./usr/bin/EpicGamesLauncher", {"data": b"egl", "mode": 0o755}),
|
||||
("./usr/lib/epic-games-launcher/libEOSSDK-Linux-Shipping.so", {"data": b"eos"}),
|
||||
("./usr/share/icons/hicolor/256x256@2/apps/EpicGamesLauncher.png", {"data": b"png"}),
|
||||
("./usr/share/applications/epic-games-launcher.desktop", {"data": b"[Desktop Entry]\n"}),
|
||||
("./usr/bin/egl", {"link": "/usr/bin/EpicGamesLauncher"}),
|
||||
("../escape", {"data": b"x"}),
|
||||
*extra,
|
||||
])
|
||||
|
||||
def webkit(self):
|
||||
return deb(self.tmp / "libwebkit2gtk-4.1-0_amd64.deb", [
|
||||
("./usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0.19.1", {"data": b"webkit"}),
|
||||
("./usr/lib/x86_64-linux-gnu/libwebkit2gtk-4.1.so.0", {"link": "libwebkit2gtk-4.1.so.0.19.1"}),
|
||||
("./usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/WebKitNetworkProcess", {"data": b"net", "mode": 0o755}),
|
||||
("./usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/injected-bundle/libwebkit2gtkinjectedbundle.so", {"data": b"bundle"}),
|
||||
("./usr/share/glib-2.0/schemas/org.gnome.GWeather4.gschema.xml", {"data": b"schema"}),
|
||||
("./usr/share/doc/libwebkit2gtk-4.1-0/copyright", {"data": b"c"}),
|
||||
("./usr/share/locale/fr/LC_MESSAGES/WebKitGTK-4.1.mo", {"data": b"fr"}),
|
||||
], "xz")
|
||||
|
||||
def test_the_launcher_and_its_desktop_layer_come_out_of_debs(self):
|
||||
dest = self.state / "app/0.113.0+g1"
|
||||
G["extract_app"](str(self.launcher()), str(dest), [str(self.webkit())])
|
||||
self.assertEqual(b"egl", (dest / "usr/bin/EpicGamesLauncher").read_bytes())
|
||||
self.assertTrue(os.access(dest / "usr/bin/EpicGamesLauncher", os.X_OK))
|
||||
self.assertEqual(b"eos", (dest / "usr/lib/epic-games-launcher/libEOSSDK-Linux-Shipping.so").read_bytes())
|
||||
self.assertEqual("EpicGamesLauncher", os.readlink(dest / "usr/bin/egl"))
|
||||
self.assertEqual(b"png", (dest / "epic-games-launcher.png").read_bytes())
|
||||
libs = dest / "desktop/usr/lib/x86_64-linux-gnu"
|
||||
self.assertEqual(b"webkit", (libs / "libwebkit2gtk-4.1.so.0").read_bytes())
|
||||
self.assertEqual(b"net", (libs / "webkit2gtk-4.1/WebKitNetworkProcess").read_bytes())
|
||||
self.assertEqual(b"schema", (dest / "desktop/usr/share/glib-2.0/schemas/org.gnome.GWeather4.gschema.xml").read_bytes())
|
||||
self.assertFalse((dest / "desktop/usr/share/doc").exists())
|
||||
self.assertFalse((self.state / "app/escape").exists())
|
||||
self.assertFalse((self.state / "app/0.113.0+g1.staging").exists())
|
||||
self.assertTrue(G["app_complete"](str(dest)))
|
||||
self.assertEqual(str(dest / "usr/bin/EpicGamesLauncher"), G["app_command"](str(dest)))
|
||||
self.assertEqual(str(libs), G["desktop_libs"](str(dest)))
|
||||
|
||||
def test_archive_symlinks_cannot_redirect_the_desktop_layer_or_icon(self):
|
||||
outside = self.tmp / "outside"
|
||||
outside.mkdir()
|
||||
dest = self.state / "app/0.113.0+g1"
|
||||
escape = os.path.relpath(outside, Path(str(dest) + ".staging"))
|
||||
launcher = self.launcher([("./desktop", {"link": escape}),
|
||||
("./epic-games-launcher.png", {"link": escape + "/target"})])
|
||||
with self.assertRaises(G["Failure"]) as caught:
|
||||
G["extract_app"](str(launcher), str(dest), [str(self.webkit())])
|
||||
self.assertEqual("app-extract", str(caught.exception))
|
||||
self.assertFalse((outside / "usr").exists())
|
||||
self.assertFalse((outside / "target").exists())
|
||||
|
||||
icon_dest = self.state / "app/0.113.0+g2"
|
||||
icon_escape = os.path.relpath(outside / "target", Path(str(icon_dest) + ".staging"))
|
||||
G["extract_app"](str(self.launcher([("./epic-games-launcher.png", {"link": icon_escape})])),
|
||||
str(icon_dest), [str(self.webkit())])
|
||||
self.assertEqual(b"png", (icon_dest / "epic-games-launcher.png").read_bytes())
|
||||
self.assertFalse((outside / "target").exists())
|
||||
|
||||
def test_a_launcher_without_its_desktop_layer_is_refused(self):
|
||||
dest = self.state / "app/0.113.0+g1"
|
||||
with self.assertRaises(G["Failure"]) as caught:
|
||||
G["extract_app"](str(self.launcher()), str(dest))
|
||||
self.assertEqual("app-extract", str(caught.exception))
|
||||
self.assertFalse(dest.exists())
|
||||
self.assertFalse(Path(str(dest) + ".staging").exists())
|
||||
|
||||
def test_anything_but_a_deb_is_refused_and_leaves_nothing_behind(self):
|
||||
image = self.tmp / "EpicGamesLauncher-x86_64.AppImage"
|
||||
image.write_bytes(b"\x7fELF\x02\x01\x01\x00AI\x02" + bytes(64))
|
||||
dest = self.state / "app/0.95.2+g1"
|
||||
with self.assertRaises(G["Failure"]) as caught:
|
||||
G["extract_app"](str(image), str(dest), [str(self.webkit())])
|
||||
self.assertEqual("app-format", str(caught.exception))
|
||||
plain = self.tmp / "plain.deb"
|
||||
plain.write_bytes(ar([("data.tar.gz", b"x")]))
|
||||
with self.assertRaises(G["Failure"]) as caught:
|
||||
G["extract_app"](str(self.launcher()), str(dest), [str(plain)])
|
||||
self.assertEqual("desktop-format", str(caught.exception))
|
||||
self.assertFalse(dest.exists())
|
||||
self.assertFalse(Path(str(dest) + ".staging").exists())
|
||||
|
||||
def test_an_installed_appimage_launcher_still_runs_through_apprun(self):
|
||||
app = self.state / "app/0.95.2+g1"
|
||||
(app / "usr/bin").mkdir(parents=True)
|
||||
(app / "AppRun").write_text("run")
|
||||
(app / "usr/bin/EpicGamesLauncher").write_text("bin")
|
||||
self.assertTrue(G["app_complete"](str(app)))
|
||||
self.assertEqual(str(app / "AppRun"), G["app_command"](str(app)))
|
||||
self.assertIsNone(G["desktop_libs"](str(app)))
|
||||
(app / "usr/bin/EpicGamesLauncher").unlink()
|
||||
self.assertFalse(G["app_complete"](str(app)))
|
||||
|
||||
def test_the_webkit_helpers_are_linked_into_the_runtime(self):
|
||||
dest = self.state / "app/0.113.0+g1"
|
||||
G["extract_app"](str(self.launcher()), str(dest), [str(self.webkit())])
|
||||
files = self.state / "runtime/4.0.1/files"
|
||||
(files / "lib/x86_64-linux-gnu").mkdir(parents=True)
|
||||
link = files / "lib/x86_64-linux-gnu/webkit2gtk-4.1"
|
||||
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
|
||||
self.assertFalse(os.path.isabs(os.readlink(link)))
|
||||
self.assertEqual(b"net", (link / "WebKitNetworkProcess").read_bytes())
|
||||
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
|
||||
self.assertEqual(b"net", (link / "WebKitNetworkProcess").read_bytes())
|
||||
G["link_webkit"](str(files), None)
|
||||
self.assertFalse(os.path.lexists(link))
|
||||
link.mkdir()
|
||||
(link / "own").write_text("x")
|
||||
G["link_webkit"](str(files), G["desktop_libs"](str(dest)))
|
||||
self.assertTrue((link / "own").is_file())
|
||||
self.assertTrue((dest / "desktop/usr/lib/x86_64-linux-gnu/webkit2gtk-4.1/WebKitNetworkProcess").is_file())
|
||||
|
||||
def test_only_the_deb_launcher_gets_the_desktop_libraries(self):
|
||||
with mock.patch.dict(G, {"fex_environment": lambda fex, files, base: {}}):
|
||||
plain = G["client_environment"]({"LD_LIBRARY_PATH": "/host"}, None, None, ":0", "bus", "broker")
|
||||
layered = G["client_environment"]({}, None, None, ":0", "bus", "broker", libs="/app/desktop/usr/lib/x86_64-linux-gnu")
|
||||
self.assertNotIn("LD_LIBRARY_PATH", plain)
|
||||
self.assertEqual("/app/desktop/usr/lib/x86_64-linux-gnu", layered["LD_LIBRARY_PATH"])
|
||||
self.assertEqual("/app/desktop/usr/share:/usr/local/share:/usr/share", layered["XDG_DATA_DIRS"])
|
||||
self.assertEqual("/app/desktop/usr/share/glib-2.0/schemas", layered["GSETTINGS_SCHEMA_DIR"])
|
||||
|
||||
def test_every_desktop_package_reaches_the_install(self):
|
||||
options, rest = G["parse_options"](["--app", "a.deb", "--desktop", "one.deb", "--desktop", "two.deb", "x"], lists=("desktop",))
|
||||
self.assertEqual({"app": "a.deb", "desktop": ["one.deb", "two.deb"]}, options)
|
||||
self.assertEqual(["x"], rest)
|
||||
self.assertEqual({"desktop": "two.deb"}, G["parse_options"](["--desktop", "one.deb", "--desktop", "two.deb"])[0])
|
||||
|
||||
|
||||
class ArgumentsTest(EpicTestCase):
|
||||
def test_client_arguments_win_and_paths_become_windows_paths(self):
|
||||
ovt = self.tmp / "ovt"
|
||||
|
||||
@@ -213,6 +213,18 @@ class DroiddeckctlTest(FakeAdbTest):
|
||||
started = [e["args"] for e in self.calls() if e["args"][:3] == ["shell", "am", "start"]]
|
||||
self.assertIn("com.antutu.benchmark.full/com.droiddeck.launcher.agent.AgentStartActivity", started[0])
|
||||
|
||||
def test_a_start_delivered_to_an_existing_task_is_a_failure(self):
|
||||
output = (b"Starting: Intent { cmp=com.droiddeck.launcher/.agent.AgentStartActivity (has extras) }\n"
|
||||
b"Warning: Activity not started, intent has been delivered to currently running top-most instance.\n"
|
||||
b"Status: ok\nActivity: com.droiddeck.launcher/.FrontEndActivity\nComplete\n")
|
||||
|
||||
def adb(_adb, _serial, *args, timeout=30):
|
||||
return ctl.subprocess.CompletedProcess(args, 0, output, b"")
|
||||
|
||||
with unittest.mock.patch.object(ctl, "run_adb", adb), self.assertRaises(ctl.ControlError) as caught:
|
||||
ctl.start_agent_activity("adb", "fake-1", {"mode": "steam"})
|
||||
self.assertEqual("ACTIVITY_START_FAILED", caught.exception.code)
|
||||
|
||||
def test_a_malformed_package_is_refused_before_adb(self):
|
||||
with unittest.mock.patch.dict(os.environ, {"DROIDDECK_PACKAGE": "com.example;reboot"}):
|
||||
variant = load("droiddeckctl")
|
||||
@@ -291,7 +303,7 @@ class DroiddeckctlTest(FakeAdbTest):
|
||||
code, out = self.run_ctl("run", "/usr/bin/sh", "--", "-c", "true")
|
||||
self.assertEqual(7, code)
|
||||
self.assertEqual("AGENT_COMMANDS_DISABLED", out["error"]["code"])
|
||||
self.assertIn("Setup > Diagnostics > Debugging tools", out["error"]["message"])
|
||||
self.assertIn("Setup > Developer > Debugging tools", out["error"]["message"])
|
||||
self.assertEqual(["access"], [c.get("method") for c in self.calls()])
|
||||
|
||||
def test_override_checks_names_before_pushing_any_file(self):
|
||||
@@ -417,12 +429,14 @@ class DroiddeckctlTest(FakeAdbTest):
|
||||
return ctl.subprocess.CompletedProcess(args, 127, b"", b"/system/bin/sh: content: inaccessible or not found")
|
||||
if args[:2] == ("shell", "am"):
|
||||
return ctl.subprocess.CompletedProcess(args, 0, b"Broadcast completed: result=0", b"")
|
||||
if args[:2] == ("shell", "pidof " + ctl.PACKAGE):
|
||||
return ctl.subprocess.CompletedProcess(args, 0, b"4940\n", b"")
|
||||
return ctl.subprocess.CompletedProcess(args, 0, next(answers), b"")
|
||||
|
||||
with unittest.mock.patch.object(ctl, "run_adb", adb), unittest.mock.patch.object(ctl.time, "sleep"):
|
||||
answer = ctl.provider_call("adb", "fake-1", "state", arg="a b", request={"x": 1})
|
||||
self.assertEqual({"ok": True, "command": "state"}, answer)
|
||||
broadcast = calls[1]
|
||||
broadcast = next(c for c in calls if c[:2] == ("shell", "am"))
|
||||
self.assertEqual(("shell", "am", "broadcast", "-a", ctl.PACKAGE + ".AGENT_CALL", "-p", ctl.PACKAGE), broadcast[:7])
|
||||
self.assertIn("'a b'", broadcast)
|
||||
self.assertEqual(ctl.encode_request({"x": 1}), broadcast[broadcast.index("request") + 1])
|
||||
@@ -823,5 +837,48 @@ class ScenarioTest(FakeAdbTest):
|
||||
self.assertEqual([{"appId": 7, "timeout": 15.0}] * 2, [c["request"] for c in self.calls("quit")])
|
||||
|
||||
|
||||
class ProviderFallbackTest(unittest.TestCase):
|
||||
MISSING = "/system/bin/sh: content: inaccessible or not found\n"
|
||||
|
||||
def adb(self, answers):
|
||||
calls = []
|
||||
|
||||
def run(adb, serial, *args, timeout=None):
|
||||
calls.append(args)
|
||||
for prefix, (code, out, err) in answers:
|
||||
if " ".join(args).startswith(" ".join(prefix)):
|
||||
return unittest.mock.Mock(returncode=code, stdout=out.encode(), stderr=err.encode())
|
||||
raise AssertionError(f"unexpected adb call {args}")
|
||||
return calls, unittest.mock.patch.object(ctl, "run_adb", run)
|
||||
|
||||
def test_a_command_that_prints_the_shell_error_is_not_run_again(self):
|
||||
result = 'Result: Bundle[{json={"ok":true,"stdout":{"text":"' + self.MISSING.strip() + '"}}}]'
|
||||
calls, patch = self.adb([(["shell", "content"], (0, result, ""))])
|
||||
with patch:
|
||||
self.assertTrue(ctl.provider_call("adb", "s", "native", request={"argv": ["x"]})["ok"])
|
||||
self.assertEqual(1, len(calls))
|
||||
|
||||
def test_a_shell_without_content_uses_the_broadcast(self):
|
||||
calls, patch = self.adb([
|
||||
(["shell", "content"], (127, "", self.MISSING)),
|
||||
(["shell", "pidof"], (0, "4940\n", "")),
|
||||
(["shell", "am", "broadcast"], (0, "Broadcast completed", "")),
|
||||
(["shell"], (0, '{"ok": true}', "")),
|
||||
])
|
||||
with patch:
|
||||
self.assertTrue(ctl.provider_call("adb", "s", "state")["ok"])
|
||||
self.assertEqual(["shell", "am", "broadcast"], list(calls[2][:3]))
|
||||
|
||||
def test_the_broadcast_needs_the_app_running(self):
|
||||
calls, patch = self.adb([
|
||||
(["shell", "content"], (127, "", self.MISSING)),
|
||||
(["shell", "pidof"], (1, "", "")),
|
||||
])
|
||||
with patch, self.assertRaises(ctl.ControlError) as raised:
|
||||
ctl.provider_call("adb", "s", "state")
|
||||
self.assertEqual("APP_NOT_RUNNING", raised.exception.code)
|
||||
self.assertFalse(any(c[:3] == ("shell", "am", "broadcast") for c in calls))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,314 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
USERNS = shutil.which("unshare") is not None and subprocess.run(["unshare", "-Urm", "true"], capture_output=True).returncode == 0
|
||||
|
||||
FASTPATH = Path(__file__).resolve().parents[1] / "proot/fastpath/fastpath.c"
|
||||
|
||||
PROGRAM = r"""
|
||||
#include "FASTPATH"
|
||||
#include <sys/mount.h>
|
||||
|
||||
static const char *race_from, *race_to;
|
||||
static dev_t race_dev;
|
||||
static ino_t race_ino;
|
||||
|
||||
static long trapped_nr = -1, unsupported_nr = -1;
|
||||
|
||||
static long host_sys(long nr, long a, long b, long c, long d, long e, long f) {
|
||||
if (nr == trapped_nr || (nr == unsupported_nr && a != -1)) return -ENOSYS;
|
||||
long r = syscall(nr, a, b, c, d, e, f);
|
||||
struct stat fs;
|
||||
if (r >= 0 && nr == SYS_fcntl && b == F_DUPFD_CLOEXEC && c == DIR_FD_FLOOR && race_from
|
||||
&& syscall(SYS_fstat, a, &fs) == 0 && fs.st_dev == race_dev && fs.st_ino == race_ino) {
|
||||
syscall(SYS_renameat, AT_FDCWD, race_from, AT_FDCWD, race_to);
|
||||
race_from = NULL;
|
||||
}
|
||||
return r < 0 ? -errno : r;
|
||||
}
|
||||
|
||||
static void show(long r) {
|
||||
if (r == FP_SLOW) puts("SLOW");
|
||||
else if (r < 0) printf("E%ld\n", -r);
|
||||
else puts("ok");
|
||||
}
|
||||
|
||||
static int high_fds(void) {
|
||||
int n = 0;
|
||||
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + 4 * DIRS; fd++)
|
||||
if (fcntl(fd, F_GETFD) >= 0) n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
static char hosts[MAX_BINDS][PATH_MAX], guests[MAX_BINDS][512];
|
||||
static int taken[DIRS];
|
||||
int ntaken = 0;
|
||||
fp_sys = host_sys;
|
||||
snprintf(root, sizeof root, "%s", argv[1]);
|
||||
rootlen = strlen(root);
|
||||
int i = 2;
|
||||
for (; i + 1 < argc && strcmp(argv[i], "--"); i += 2) {
|
||||
struct bind *bd = &binds[nbinds];
|
||||
bd->host = hosts[nbinds];
|
||||
bd->guest = guests[nbinds];
|
||||
snprintf(bd->host, PATH_MAX, "%s", argv[i]);
|
||||
snprintf(bd->guest, sizeof guests[0], "%s", argv[i + 1]);
|
||||
bd->hlen = strlen(bd->host);
|
||||
bd->glen = strlen(bd->guest);
|
||||
nbinds++;
|
||||
}
|
||||
pthread_once(&init_once, fp_init);
|
||||
fp_on = 1;
|
||||
for (i++; i < argc; i++) {
|
||||
const char *op = argv[i];
|
||||
if (!strcmp(op, "fuse")) {
|
||||
for (int b = 0; b < nbinds; b++) binds[b].fuse = 1;
|
||||
} else if (!strcmp(op, "touch")) {
|
||||
long fd = fp_open(AT_FDCWD, argv[++i], O_CREAT | O_WRONLY | O_CLOEXEC, 0644);
|
||||
if (fd >= 0) close((int)fd);
|
||||
show(fd);
|
||||
} else if (!strcmp(op, "stat")) {
|
||||
struct stat st;
|
||||
show(fp_stat(AT_FDCWD, argv[++i], AT_SYMLINK_NOFOLLOW, &st));
|
||||
} else if (!strcmp(op, "symlink")) {
|
||||
long r = fp_symlink("target", AT_FDCWD, argv[++i]);
|
||||
if (refused()) puts("REFUSED");
|
||||
else show(r);
|
||||
} else if (!strcmp(op, "trap-symlink")) {
|
||||
trapped_nr = SYS_symlinkat;
|
||||
} else if (!strcmp(op, "no-symlinks")) {
|
||||
unsupported_nr = SYS_symlinkat;
|
||||
} else if (!strcmp(op, "on")) {
|
||||
printf("%d\n", fp_ready());
|
||||
} else if (!strcmp(op, "no-folders")) {
|
||||
unsupported_nr = SYS_mkdirat;
|
||||
} else if (!strcmp(op, "busy-cache")) {
|
||||
pthread_mutex_lock(&dir_lock);
|
||||
} else if (!strcmp(op, "mkdir")) {
|
||||
long r = fp_mkdir(AT_FDCWD, argv[++i], 0755);
|
||||
if (refused()) puts("REFUSED");
|
||||
else show(r);
|
||||
} else if (!strcmp(op, "mv")) {
|
||||
show(fp_rename(AT_FDCWD, argv[i + 1], AT_FDCWD, argv[i + 2], 0));
|
||||
i += 2;
|
||||
} else if (!strcmp(op, "rm")) {
|
||||
show(fp_unlink(AT_FDCWD, argv[++i], 0));
|
||||
} else if (!strcmp(op, "host-mv")) {
|
||||
show(host_sys(SYS_renameat, AT_FDCWD, (long)argv[i + 1], AT_FDCWD, (long)argv[i + 2], 0, 0));
|
||||
i += 2;
|
||||
} else if (!strcmp(op, "race-mv")) {
|
||||
struct stat rs;
|
||||
race_from = argv[i + 1];
|
||||
race_to = argv[i + 2];
|
||||
i += 2;
|
||||
show(host_sys(SYS_newfstatat, AT_FDCWD, (long)race_from, (long)&rs, 0, 0, 0));
|
||||
race_dev = rs.st_dev;
|
||||
race_ino = rs.st_ino;
|
||||
} else if (!strcmp(op, "host-rmdir")) {
|
||||
show(host_sys(SYS_unlinkat, AT_FDCWD, (long)argv[++i], AT_REMOVEDIR, 0, 0, 0));
|
||||
} else if (!strcmp(op, "host-mkdir")) {
|
||||
show(host_sys(SYS_mkdirat, AT_FDCWD, (long)argv[++i], 0755, 0, 0, 0));
|
||||
} else if (!strcmp(op, "clobber")) {
|
||||
long null = host_sys(SYS_openat, AT_FDCWD, (long)"/dev/null", O_RDONLY, 0, 0, 0);
|
||||
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + DIRS; fd++) host_sys(SYS_dup3, null, fd, 0, 0, 0, 0);
|
||||
host_sys(SYS_close, null, 0, 0, 0, 0, 0);
|
||||
puts("ok");
|
||||
} else if (!strcmp(op, "first-fd")) {
|
||||
char link[40], out[PATH_MAX];
|
||||
snprintf(link, sizeof link, "/proc/self/fd/%d", DIR_FD_FLOOR);
|
||||
long n = host_sys(SYS_readlinkat, AT_FDCWD, (long)link, (long)out, sizeof out - 1, 0, 0);
|
||||
out[n > 0 ? n : 0] = 0;
|
||||
puts(out);
|
||||
} else if (!strcmp(op, "fds")) {
|
||||
printf("%d\n", high_fds());
|
||||
} else if (!strcmp(op, "ttl")) {
|
||||
ttl_ns = atoll(argv[++i]) * 1000000LL;
|
||||
} else if (!strcmp(op, "sleep")) {
|
||||
usleep(atoi(argv[++i]) * 1000);
|
||||
} else if (!strcmp(op, "chmod")) {
|
||||
show(fp_chmod(AT_FDCWD, argv[i + 1], strtol(argv[i + 2], NULL, 8), 0));
|
||||
i += 2;
|
||||
} else if (!strcmp(op, "host-mount")) {
|
||||
show(mount("tmpfs", argv[++i], "tmpfs", 0, NULL) == 0 ? 0 : -errno);
|
||||
} else if (!strcmp(op, "take-over")) {
|
||||
for (int fd = DIR_FD_FLOOR; fd < DIR_FD_FLOOR + DIRS; fd++) {
|
||||
char link[40], out[PATH_MAX];
|
||||
snprintf(link, sizeof link, "/proc/self/fd/%d", fd);
|
||||
long n = host_sys(SYS_readlinkat, AT_FDCWD, (long)link, (long)out, sizeof out - 1, 0, 0);
|
||||
if (n <= 0) continue;
|
||||
out[n] = 0;
|
||||
long mine = host_sys(SYS_openat, AT_FDCWD, (long)out, O_RDONLY | O_DIRECTORY, 0, 0, 0);
|
||||
host_sys(SYS_dup3, mine, fd, 0, 0, 0, 0);
|
||||
host_sys(SYS_close, mine, 0, 0, 0, 0, 0);
|
||||
taken[ntaken++] = fd;
|
||||
}
|
||||
puts("ok");
|
||||
} else if (!strcmp(op, "taken")) {
|
||||
int open_fds = 0;
|
||||
for (int t = 0; t < ntaken; t++)
|
||||
if (lseek(taken[t], 0, SEEK_CUR) == 0) open_fds++;
|
||||
printf("%d/%d\n", open_fds, ntaken);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
class FastPathFuseDirsTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
if shutil.which("gcc") is None:
|
||||
raise unittest.SkipTest("gcc is not available")
|
||||
cls.build = tempfile.TemporaryDirectory()
|
||||
source = Path(cls.build.name) / "fuse_dirs.c"
|
||||
source.write_text(PROGRAM.replace("FASTPATH", str(FASTPATH)))
|
||||
cls.program = Path(cls.build.name) / "fuse_dirs"
|
||||
subprocess.run(["gcc", "-O1", "-Wall", "-Wextra", "-Werror", "-Wno-format-truncation", "-pthread", "-o", str(cls.program), str(source), "-ldl"], check=True)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.build.cleanup()
|
||||
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
base = Path(self.temp.name)
|
||||
self.root = base / "root"
|
||||
(self.root / "mnt").mkdir(parents=True)
|
||||
self.card = base / "card"
|
||||
(self.card / "Games/steamapps/common/Game/Data").mkdir(parents=True)
|
||||
|
||||
def ask(self, *ops, wrap=()):
|
||||
argv = [*wrap, str(self.program), str(self.root), str(self.card), "/mnt/card", "--", *ops]
|
||||
return subprocess.run(argv, capture_output=True, text=True, timeout=20, check=True).stdout.split()
|
||||
|
||||
def test_files_deep_in_a_fuse_library_are_created_renamed_and_removed(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "touch", f"{data}/a.tmp", "mv", f"{data}/a.tmp", f"{data}/a.idx",
|
||||
"stat", f"{data}/a.idx", "stat", f"{data}/a.tmp", "rm", f"{data}/a.idx",
|
||||
"stat", f"{data}/a.idx", "fds")
|
||||
self.assertEqual(["ok", "ok", "ok", "E2", "ok", "E2"], out[:-1])
|
||||
self.assertGreater(int(out[-1]), 0)
|
||||
self.assertEqual([], list((self.card / "Games/steamapps/common/Game/Data").iterdir()))
|
||||
|
||||
def test_a_folder_renamed_behind_the_cache_is_not_reused(self):
|
||||
game = self.card / "Games/steamapps/common/Game"
|
||||
(game / "Data/keep").write_text("x")
|
||||
out = self.ask("fuse", "stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
|
||||
"host-mv", str(game), str(game.parent / "Moved"),
|
||||
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
|
||||
"stat", "/mnt/card/Games/steamapps/common/Moved/Data/keep")
|
||||
self.assertEqual(["ok", "ok", "E2", "ok"], out)
|
||||
|
||||
def test_a_folder_renamed_while_it_is_opened_is_not_used_under_its_old_name(self):
|
||||
game = self.card / "Games/steamapps/common/Game"
|
||||
(game / "Data/keep").write_text("x")
|
||||
out = self.ask("fuse", "race-mv", str(game / "Data"), str(game / "Moved"),
|
||||
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
|
||||
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new", "fds")
|
||||
self.assertEqual(["ok", "E2", "E2"], out[:3])
|
||||
self.assertEqual(["keep"], [p.name for p in (game / "Moved").iterdir()])
|
||||
self.assertLessEqual(int(out[-1]), 64)
|
||||
|
||||
def test_a_folder_deleted_and_made_again_is_looked_up_fresh(self):
|
||||
data = self.card / "Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "touch", "/mnt/card/Games/steamapps/common/Game/Data/old",
|
||||
"rm", "/mnt/card/Games/steamapps/common/Game/Data/old",
|
||||
"host-rmdir", str(data), "host-mkdir", str(data),
|
||||
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new")
|
||||
self.assertEqual(["ok"] * 5, out)
|
||||
self.assertEqual(["new"], [p.name for p in data.iterdir()])
|
||||
|
||||
def test_folders_deleted_and_made_again_many_times_keep_descriptors_bounded(self):
|
||||
data = self.card / "Games/steamapps/common/Game/Data"
|
||||
ops = ["fuse"]
|
||||
for _ in range(200):
|
||||
ops += ["touch", "/mnt/card/Games/steamapps/common/Game/Data/x",
|
||||
"rm", "/mnt/card/Games/steamapps/common/Game/Data/x",
|
||||
"host-rmdir", str(data), "host-mkdir", str(data)]
|
||||
out = self.ask(*ops, "fds")
|
||||
self.assertEqual(["ok"] * 800, out[:-1])
|
||||
self.assertLessEqual(int(out[-1]), 64)
|
||||
|
||||
def test_descriptors_the_program_takes_over_are_left_alone(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "touch", f"{data}/a", "clobber", "touch", f"{data}/b",
|
||||
"stat", f"{data}/a", "first-fd")
|
||||
self.assertEqual(["ok", "ok", "ok", "ok", "/dev/null"], out)
|
||||
self.assertEqual({"a", "b"}, {p.name for p in (self.card / "Games/steamapps/common/Game/Data").iterdir()})
|
||||
|
||||
def test_a_folder_the_program_opened_itself_stays_open_when_the_cache_moves_on(self):
|
||||
data = self.card / "Games/steamapps/common/Game/Data"
|
||||
ops = ["fuse", "touch", "/mnt/card/Games/steamapps/common/Game/Data/a", "take-over"]
|
||||
for n in range(200):
|
||||
(data / f"d{n}").mkdir()
|
||||
ops += ["touch", f"/mnt/card/Games/steamapps/common/Game/Data/d{n}/x"]
|
||||
out = self.ask(*ops, "taken")
|
||||
self.assertEqual(["ok"] * 202, out[:-1])
|
||||
opened, total = map(int, out[-1].split("/"))
|
||||
self.assertGreater(total, 0)
|
||||
self.assertEqual(total, opened)
|
||||
self.assertEqual(200, len(list(data.glob("d*/x"))))
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root passes folder permissions")
|
||||
def test_a_parent_folder_closed_by_the_program_stops_cached_access_at_once(self):
|
||||
game = self.card / "Games/steamapps/common/Game"
|
||||
(game / "Data/keep").write_text("x")
|
||||
self.addCleanup(os.chmod, game, 0o755)
|
||||
out = self.ask("fuse", "stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
|
||||
"chmod", "/mnt/card/Games/steamapps/common/Game", "000",
|
||||
"stat", "/mnt/card/Games/steamapps/common/Game/Data/keep",
|
||||
"touch", "/mnt/card/Games/steamapps/common/Game/Data/new")
|
||||
self.assertEqual(["ok", "ok"], out[:2])
|
||||
self.assertNotIn("ok", out[2:])
|
||||
os.chmod(game, 0o755)
|
||||
self.assertEqual(["keep"], [p.name for p in (game / "Data").iterdir()])
|
||||
|
||||
@unittest.skipUnless(USERNS, "mount namespaces are not available")
|
||||
def test_a_mount_placed_over_a_cached_folder_receives_later_writes(self):
|
||||
data = self.card / "Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "ttl", "1", "touch", "/mnt/card/Games/steamapps/common/Game/Data/under",
|
||||
"host-mount", str(data), "sleep", "20",
|
||||
"touch", "/mnt/card/Games/steamapps/common/Game/Data/over",
|
||||
"stat", "/mnt/card/Games/steamapps/common/Game/Data/under", wrap=("unshare", "-Urm"))
|
||||
self.assertEqual(["ok", "ok", "ok", "E2"], out)
|
||||
self.assertEqual(["under"], [p.name for p in data.iterdir()])
|
||||
|
||||
def test_a_call_the_filesystem_does_not_implement_leaves_the_fast_path_on(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "no-symlinks", "touch", f"{data}/a", "symlink", f"{data}/link", "on",
|
||||
"stat", f"{data}/a", "symlink", f"{data}/link", "on", "touch", f"{data}/b")
|
||||
self.assertEqual(["ok", "REFUSED", "1", "ok", "REFUSED", "1", "ok"], out)
|
||||
self.assertEqual(["a", "b"], sorted(p.name for p in (self.card / "Games/steamapps/common/Game/Data").iterdir()))
|
||||
|
||||
def test_repeated_unsupported_calls_close_the_folders_they_opened(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
ops = [op for n in range(40) for op in ("mkdir", f"{data}/new{n}")]
|
||||
out = self.ask("fuse", "no-folders", "busy-cache", *ops, "on", "fds")
|
||||
self.assertEqual(["REFUSED"] * 40 + ["1", "0"], out)
|
||||
|
||||
def test_a_trapped_call_still_stops_the_fast_path_for_the_process(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "trap-symlink", "symlink", f"{data}/link", "on")
|
||||
self.assertEqual(["REFUSED", "0"], out)
|
||||
|
||||
def test_a_symlink_is_made_where_the_filesystem_allows_it(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("fuse", "symlink", f"{data}/link", "on")
|
||||
self.assertEqual(["ok", "1"], out)
|
||||
self.assertEqual("target", os.readlink(self.card / "Games/steamapps/common/Game/Data/link"))
|
||||
|
||||
def test_other_filesystems_keep_absolute_paths_and_open_no_folders(self):
|
||||
data = "/mnt/card/Games/steamapps/common/Game/Data"
|
||||
out = self.ask("touch", f"{data}/a", "mv", f"{data}/a", f"{data}/b", "rm", f"{data}/b", "fds")
|
||||
self.assertEqual(["ok", "ok", "ok", "0"], out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -950,6 +950,22 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
self.assertEqual(MODULE["apply_config"](env, config, "42")["TU_DEBUG"], "sysmem")
|
||||
self.assertNotIn("TU_DEBUG", MODULE["apply_config"](env, config, "43"))
|
||||
|
||||
def test_games_run_with_gl_error_checks_unless_the_user_turns_them_off(self):
|
||||
gpu = MODULE["game_gpu"]
|
||||
session = {"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "", "KEEP": "1"}
|
||||
self.assertEqual(gpu(session), {"KEEP": "1"})
|
||||
self.assertEqual(gpu(session, True), {"MESA_NO_ERROR": "1", "KEEP": "1"})
|
||||
self.assertEqual(gpu({"MESA_NO_ERROR": "1"}), {"MESA_NO_ERROR": "1"})
|
||||
self.assertEqual(gpu({"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "1"}), {"MESA_NO_ERROR": "1"})
|
||||
both = gpu({"MESA_NO_ERROR": "1", "DROIDDECK_GAME_MESA_NO_ERROR": "", "TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"})
|
||||
self.assertEqual(both, {"TU_DEBUG": "nolrz"})
|
||||
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "MESA_NO_ERROR": "1"}),
|
||||
{"MESA_NO_ERROR": "1"})
|
||||
config = {"version": 1, "games": {"42": {"MESA_NO_ERROR": "1"}}}
|
||||
env = gpu(session)
|
||||
self.assertEqual(MODULE["apply_config"](env, config, "42")["MESA_NO_ERROR"], "1")
|
||||
self.assertNotIn("MESA_NO_ERROR", MODULE["apply_config"](env, config, "43"))
|
||||
|
||||
def test_a_chromium_app_keeps_the_sessions_turnip_debug(self):
|
||||
gpu = MODULE["game_gpu"]
|
||||
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "KEEP": "1"}, True),
|
||||
@@ -992,9 +1008,11 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
|
||||
def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self):
|
||||
cap = MODULE["vram_cap"]
|
||||
self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096")
|
||||
self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096; dxgi.maxSharedMemory = 4096")
|
||||
self.assertEqual(cap({"BL_VRAM_MB": "8192"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 8192; dxgi.maxSharedMemory = 8192")
|
||||
self.assertEqual(cap({"BL_VRAM_MB": "4095"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4095; dxgi.maxSharedMemory = 4095; d3d9.maxAvailableMemory = 4095")
|
||||
self.assertEqual(cap({"BL_VRAM_MB": "2048", "DXVK_CONFIG": "dxvk.maxFrameRate = 60;"})["DXVK_CONFIG"],
|
||||
"dxgi.maxDeviceMemory = 2048; dxvk.maxFrameRate = 60")
|
||||
"dxgi.maxDeviceMemory = 2048; dxgi.maxSharedMemory = 2048; d3d9.maxAvailableMemory = 2048; dxvk.maxFrameRate = 60")
|
||||
for off in ({}, {"BL_VRAM_MB": "0"}, {"BL_VRAM_MB": "lots"}, {"BL_VRAM_MB": "²"}, {"BL_VRAM_MB": "-1"}):
|
||||
self.assertNotIn("DXVK_CONFIG", cap(off))
|
||||
self.assertNotIn("DROIDDECK_VRAM_CAP", cap(off))
|
||||
@@ -1124,6 +1142,23 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
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)
|
||||
for app, expected in (("42", "42"), ("4294967295", "4294967295"), ("43", "*"), ("", "*"), ("x", "*")):
|
||||
with self.subTest(shared=app):
|
||||
env = dict(os.environ, HOME=str(root), STEAM_COMPAT_DATA_PATH="/steam/compatdata/2929927072", SteamAppId=app)
|
||||
target.write_text("untouched")
|
||||
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True, capture_output=True)
|
||||
self.assertEqual(MODULE["game_id"](env), app if app in {"42", "4294967295", "43"} else "2929927072")
|
||||
self.assertEqual(target.read_text(), expected)
|
||||
for game, expected in (
|
||||
(str(42 << 32 | 0x02000000), "42"), (str(4294967295 << 32 | 0x02000000), "4294967295"),
|
||||
(str(42 << 32 | 0x02000001), "*"), (str(42 << 32 | 0x02000000 | 1 << 64), "*"), ("33554432", "*"), ("x", "*"),
|
||||
):
|
||||
with self.subTest(direct=game):
|
||||
env = dict(os.environ, HOME=str(root), STEAM_COMPAT_DATA_PATH="/steam/compatdata/2929927072", SteamAppId="0", SteamGameId=game)
|
||||
target.write_text("untouched")
|
||||
subprocess.run(["bash", "-c", script, "test", str(base)], env=env, check=True, capture_output=True)
|
||||
self.assertEqual(MODULE["game_id"](env), expected if expected != "*" else "2929927072")
|
||||
self.assertEqual(target.read_text(), expected)
|
||||
|
||||
def test_engine_fixes_follow_the_games_files(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
@@ -1503,6 +1538,19 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
config = {"version": 1, "shared": {}, "games": {"42": values}}
|
||||
self.assertEqual(MODULE["apply_config"]({}, config, "42", env), values, name)
|
||||
|
||||
def test_ff7_rebirth_runs_at_feature_level_12_2_unless_the_game_overrides_it(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
root = Path(tmp) / "FINAL FANTASY VII REBIRTH"
|
||||
game = root / "End/Binaries/Win64/ff7rebirth_.exe"
|
||||
game.parent.mkdir(parents=True)
|
||||
for exe in (root / "ff7rebirth.exe", game):
|
||||
exe.touch()
|
||||
env, extra, notes = MODULE["engine_fixes"](str(exe), [])
|
||||
self.assertEqual(env, {"VKD3D_FEATURE_LEVEL": "12_2"}, exe.name)
|
||||
self.assertTrue(notes)
|
||||
config = {"version": 1, "shared": {}, "games": {"42": {"VKD3D_FEATURE_LEVEL": "12_1"}}}
|
||||
self.assertEqual(MODULE["apply_config"]({}, config, "42", env), {"VKD3D_FEATURE_LEVEL": "12_1"})
|
||||
|
||||
def test_unity_players_keep_tso_over_the_preset(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
def game(*names):
|
||||
@@ -1628,6 +1676,10 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
self.assertIsNone(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": prefix}))
|
||||
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/42/"}), "42")
|
||||
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/-1"}), "4294967295")
|
||||
shared = {"STEAM_COMPAT_DATA_PATH": "/a/compatdata/2929927072", "SteamAppId": "2424921676"}
|
||||
self.assertEqual(MODULE["game_id"](shared), "2424921676")
|
||||
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/2929927072"}), "2929927072")
|
||||
self.assertEqual(MODULE["game_id"]({"STEAM_COMPAT_DATA_PATH": "/a/compatdata/42", "SteamAppId": "7"}), "42")
|
||||
|
||||
def test_launch_reads_updates_preserves_argv_and_does_not_execute_values(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
@@ -2717,6 +2769,17 @@ class ForeignSystemDllTest(unittest.TestCase):
|
||||
self.assertFalse((system32 / "ucrtbase.dll").is_symlink())
|
||||
self.assertEqual(0x8664, MODULE["pe_machine"](system32 / "userlib.dll"))
|
||||
|
||||
def test_x64_visual_cpp_runtime_in_arm64_system32_is_kept(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
proton, compat, windows = self.prefix(tmp)
|
||||
builtins = proton.parent / "files/lib/wine/aarch64-windows"
|
||||
for name in ("msvcp140.dll", "VCRUNTIME140.dll", "msvcp_win.dll"):
|
||||
(builtins / name.lower()).write_bytes(pe_image(0xAA64))
|
||||
(windows / "system32" / name).write_bytes(pe_image(0x8664))
|
||||
self.assertEqual(["system32/msvcp_win.dll (machine 0x8664)"], self.run_repair(compat, proton))
|
||||
self.assertFalse((windows / "system32/msvcp140.dll").is_symlink())
|
||||
self.assertFalse((windows / "system32/VCRUNTIME140.dll").is_symlink())
|
||||
|
||||
def test_final_arm64ec_image_is_not_repaired_as_a_foreign_x64_dll(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
proton, compat, windows = self.prefix(tmp)
|
||||
|
||||
@@ -9,7 +9,7 @@ from pathlib import Path
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
||||
KEYS = ("TU_DEBUG", "DROIDDECK_GAME_TU_DEBUG", "MESA_LOADER_DRIVER_OVERRIDE", "GALLIUM_DRIVER",
|
||||
"LIBGL_KOPPER_DRI2", "VK_ICD_FILENAMES", "VK_DRIVER_FILES")
|
||||
"LIBGL_KOPPER_DRI2", "VK_ICD_FILENAMES", "VK_DRIVER_FILES", "MESA_NO_ERROR", "DROIDDECK_GAME_MESA_NO_ERROR")
|
||||
SESSION = {"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": ""}
|
||||
GPU_SESSION = {"MESA_LOADER_DRIVER_OVERRIDE": "zink", "GALLIUM_DRIVER": "zink",
|
||||
"LIBGL_KOPPER_DRI2": "true", "VK_ICD_FILENAMES": "/runtime/turnip.json",
|
||||
@@ -68,6 +68,15 @@ class GameGpuLaunchersTest(unittest.TestCase):
|
||||
self.chromium()
|
||||
self.assertEqual("sysmem", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"])
|
||||
|
||||
def test_programs_get_gl_error_checks_back_while_chromium_keeps_the_client_setting(self):
|
||||
session = dict(GPU_SESSION, MESA_NO_ERROR="1", DROIDDECK_GAME_MESA_NO_ERROR="")
|
||||
values = self.wrapper(session=session)
|
||||
self.assertEqual(("unset", "unset"), (values["MESA_NO_ERROR"], values["DROIDDECK_GAME_MESA_NO_ERROR"]))
|
||||
self.assertEqual(GPU_SESSION, {key: values[key] for key in GPU_SESSION})
|
||||
self.assertEqual("1", self.wrapper("--chromium", session=session)["MESA_NO_ERROR"])
|
||||
self.assertEqual("unset", self.flatpak(session)["MESA_NO_ERROR"])
|
||||
self.assertEqual("1", self.wrapper(session={"MESA_NO_ERROR": "1"})["MESA_NO_ERROR"])
|
||||
|
||||
def test_without_the_game_setting_the_wrapper_changes_nothing(self):
|
||||
self.assertEqual("sysmem", self.wrapper(session={"TU_DEBUG": "sysmem"})["TU_DEBUG"])
|
||||
self.assertEqual("unset", self.wrapper(session={})["TU_DEBUG"])
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
SESSION = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-session'
|
||||
|
||||
|
||||
class GameResolutionTest(unittest.TestCase):
|
||||
def launch(self, mode, **overrides):
|
||||
source = SESSION.read_text()
|
||||
start = source.index(' width=${BL_WIDTH:-1280}')
|
||||
end = source.index('\nfi\n\nbl_displays()', start)
|
||||
block = source[start:end].replace('/usr/local/bin/droiddeck-pipewire', 'pipewire_stub')
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
env = dict(os.environ, XDG_RUNTIME_DIR=directory, BL_REFRESH='60', BL_MANGOAPP='0',
|
||||
BL_WIDTH='2560', BL_HEIGHT='1600')
|
||||
for name in ('BL_GAME_WIDTH', 'BL_GAME_HEIGHT', 'BL_FOLLOW_OUTPUT', 'BL_GAMESCOPE_STRETCH_16X9'):
|
||||
env.pop(name, None)
|
||||
env.update(overrides)
|
||||
fake = Path(directory) / 'gamescope'
|
||||
fake.write_text('#!/bin/bash\nprintf "ARG:%s\\n" "$@"\n')
|
||||
fake.chmod(0o755)
|
||||
env['PATH'] = directory + os.pathsep + env['PATH']
|
||||
script = f'''
|
||||
set -u
|
||||
mode={mode}
|
||||
pipewire_stub() {{ return 1; }}
|
||||
run_gamescope() {{ printf 'ARG:%s\n' "$@"; }}
|
||||
''' + block
|
||||
result = subprocess.run(['bash', '-c', script], env=env, capture_output=True, text=True, timeout=5)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
return [line.removeprefix('ARG:') for line in result.stdout.splitlines() if line.startswith('ARG:')]
|
||||
|
||||
def test_a_game_started_without_steam_runs_at_its_resolution_with_proportions_kept(self):
|
||||
args = self.launch('run', BL_GAME_WIDTH='1280', BL_GAME_HEIGHT='720')
|
||||
self.assertEqual(['2560', '1600'], [args[args.index('-W') + 1], args[args.index('-H') + 1]])
|
||||
self.assertEqual(['1280', '720'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
|
||||
self.assertNotIn('-S', args)
|
||||
|
||||
def test_without_a_game_resolution_the_game_matches_the_output(self):
|
||||
args = self.launch('run')
|
||||
self.assertEqual(['2560', '1600'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
|
||||
|
||||
def test_steam_ignores_the_game_resolution(self):
|
||||
args = self.launch('steam', BL_GAME_WIDTH='1280', BL_GAME_HEIGHT='720')
|
||||
self.assertEqual(['2560', '1600'], [args[args.index('-w') + 1], args[args.index('-h') + 1]])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -2,7 +2,7 @@ from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_client_zram_focus import function_source, run_bash
|
||||
from tools.tests.test_client_zram_focus import SCRIPT, function_source, run_bash
|
||||
|
||||
|
||||
class MemoryPressureTest(unittest.TestCase):
|
||||
@@ -20,8 +20,8 @@ class MemoryPressureTest(unittest.TestCase):
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'bl_memory_read', 'bl_memory_tight', 'bl_client_can_pageout',
|
||||
'bl_client_can_readback', 'bl_client_pressure'))
|
||||
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_client_can_pageout',
|
||||
'bl_client_can_readback', 'bl_client_pressure', 'bl_client_pressure_result', 'bl_zram_has_room'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
@@ -29,7 +29,7 @@ set -u
|
||||
_bl_pids=(123) _bl_game=1 _bl_packed=-1 _bl_pressure_at=-1 _bl_pressure_backoff=30
|
||||
rss=$((384 * 1024)) client_swap=$((512 * 1024)) reclaimed=$((128 * 1024))
|
||||
step() { :; }
|
||||
bl_zram_usage() { _bl_rss=$rss _bl_swap=$client_swap; }
|
||||
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$client_swap; }
|
||||
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - reclaimed)); _bl_pageout_complete=${pageout_complete:-1}; }
|
||||
''' + functions + '\nbl_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
@@ -80,6 +80,13 @@ if bl_client_can_readback; then echo yes; else echo no; fi
|
||||
self.assertEqual(['no'], self.run_policy('''
|
||||
bl_client_pressure
|
||||
if bl_client_can_pageout; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_client_swap_budget_excludes_file_backed_memory(self):
|
||||
self.memory(swap_free=1536)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('''
|
||||
rss=$((2048 * 1024)) anon=$((256 * 1024))
|
||||
bl_client_pressure
|
||||
'''))
|
||||
|
||||
def test_without_swap_automatic_pageout_is_disabled(self):
|
||||
@@ -152,20 +159,20 @@ class SessionPressureTest(unittest.TestCase):
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_low_ram',
|
||||
'bl_session_pressure', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
|
||||
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
|
||||
'bl_session_pressure', 'bl_zram_has_room', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
set -u
|
||||
_bl_game=1 _bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0 _bl_tier_back=0 _bl_tier_targets=() _bl_tier_swaps=() _bl_tier_starts=() _bl_pids=(999)
|
||||
_bl_pressure_at=-1 _bl_packed=-1
|
||||
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive=999 started=100 complete=1
|
||||
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1
|
||||
step() { :; }
|
||||
bl_proc_start() { _bl_start=; case " $alive " in *" $1 "*) _bl_start=$started; return 0 ;; esac; return 1; }
|
||||
nap() { echo "nap:$1"; }
|
||||
bl_session_others() { _bl_session=(321 654); }
|
||||
bl_zram_usage() { _bl_rss=$rss _bl_swap=$swap; }
|
||||
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$swap; }
|
||||
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed)); _bl_pageout_complete=$complete; }
|
||||
''' + functions + '\nbl_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
@@ -174,19 +181,27 @@ bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_low_headroom_compresses_the_game_session_at_most_every_30_seconds(self):
|
||||
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
SECONDS=10; bl_session_pressure
|
||||
SECONDS=29; bl_session_pressure
|
||||
SECONDS=30; bl_session_pressure
|
||||
'''))
|
||||
|
||||
def test_twelve_gigabyte_devices_are_included_and_larger_ones_are_not(self):
|
||||
for total, expected in ((11264, ['send:1:game']), (12288, ['send:1:game']), (15360, [])):
|
||||
def test_pressure_policy_is_independent_of_ram_size(self):
|
||||
for total, expected in ((11264, ['send:1:session']), (12288, ['send:1:session']), (16384, ['send:1:session'])):
|
||||
with self.subTest(total=total):
|
||||
self.memory(total=total)
|
||||
self.assertEqual(expected, self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_large_device_with_real_headroom_does_not_reclaim(self):
|
||||
self.memory(total=16384, available=5120, psi='12.34')
|
||||
self.assertEqual([], self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_large_device_with_psi_and_moderate_headroom_reclaims(self):
|
||||
self.memory(total=16384, available=3072, psi='1.23')
|
||||
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_no_game_does_not_compress_the_session(self):
|
||||
self.assertEqual([], self.run_policy('_bl_game=0; bl_session_pressure'))
|
||||
|
||||
@@ -196,15 +211,26 @@ SECONDS=30; bl_session_pressure
|
||||
|
||||
def test_stalls_with_moderate_headroom_compress_before_the_hard_limit(self):
|
||||
self.memory(available=2048, psi='1.50')
|
||||
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
|
||||
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_moderate_headroom_without_stalls_waits(self):
|
||||
self.memory(available=2048)
|
||||
self.assertEqual([], self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_same_second_memory_read_preserves_the_pressure_baseline(self):
|
||||
self.memory(available=2048)
|
||||
meminfo = self.root / 'meminfo'
|
||||
self.assertEqual(['1048576:524288:2097152'], self.run_policy(f'''
|
||||
SECONDS=100
|
||||
_bl_sample_at=100 _bl_sample_available=2097152 _bl_growth=0 _bl_fall=524288
|
||||
sed -i 's/MemAvailable: 2097152 kB/MemAvailable: 1048576 kB/' {meminfo}
|
||||
bl_memory_read
|
||||
echo "$_bl_available:$_bl_fall:$_bl_sample_available"
|
||||
'''))
|
||||
|
||||
def test_game_reading_back_most_of_a_pageout_skips_and_doubles_the_wait(self):
|
||||
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game', 'backoff:60',
|
||||
'send:1:game', 'backoff:30'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:60',
|
||||
'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
pushed=$((512 * 1024))
|
||||
SECONDS=0; bl_session_pressure
|
||||
swap=$((swap / 4))
|
||||
@@ -226,7 +252,7 @@ echo "backoff:$_bl_tier_backoff"
|
||||
|
||||
def test_nearly_out_of_memory_ignores_the_backoff_but_keeps_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
_bl_tier_backoff=300
|
||||
SECONDS=0; bl_session_pressure
|
||||
SECONDS=20; bl_session_pressure
|
||||
@@ -235,7 +261,7 @@ SECONDS=30; bl_session_pressure
|
||||
|
||||
def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; bl_session_pressure
|
||||
@@ -247,7 +273,7 @@ SECONDS=90; bl_session_pressure
|
||||
|
||||
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; bl_session_pressure
|
||||
@@ -263,6 +289,24 @@ SECONDS=360; bl_session_pressure
|
||||
self.memory(swap_free=1536, swap_total=2048)
|
||||
self.assertEqual([], self.run_policy('bl_session_pressure'))
|
||||
|
||||
def test_file_backed_resident_memory_does_not_consume_the_swap_budget(self):
|
||||
self.memory(swap_free=3088, swap_total=6144)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((1024 * 1024))
|
||||
bl_session_pressure
|
||||
'''))
|
||||
|
||||
def test_anonymous_memory_and_pending_client_still_need_the_full_swap_reserve(self):
|
||||
self.memory(swap_free=3088, swap_total=6144)
|
||||
self.assertEqual([], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((2048 * 1024))
|
||||
bl_session_pressure
|
||||
'''))
|
||||
self.assertEqual([], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((1536 * 1024)) _bl_client_reserve=$((512 * 1024))
|
||||
bl_session_pressure
|
||||
'''))
|
||||
|
||||
def test_small_session_is_left_alone(self):
|
||||
self.assertEqual([], self.run_policy('rss=$((128 * 1024)); bl_session_pressure'))
|
||||
|
||||
@@ -275,10 +319,10 @@ SECONDS=360; bl_session_pressure
|
||||
self.assertEqual(['nap:5'], self.run_policy('bl_watch_nap'))
|
||||
self.assertEqual(['nap:5'], self.run_policy('_bl_game=0; bl_watch_nap'))
|
||||
|
||||
def test_one_push_compresses_the_game_and_the_launcher_and_restarts_the_launcher_wait(self):
|
||||
self.assertEqual(['send:1:game', 'pids:321 654 999', 'client:0:0'], self.run_policy('''
|
||||
def test_session_push_preserves_client_timestamps(self):
|
||||
self.assertEqual(['send:1:session', 'pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
bl_zram_pick game; echo "pids:${_pids[*]}"
|
||||
bl_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_bl_pressure_at:$_bl_packed"
|
||||
'''))
|
||||
|
||||
@@ -286,19 +330,19 @@ echo "client:$_bl_pressure_at:$_bl_packed"
|
||||
self.assertEqual(['pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
BL_ZRAM_CLIENT=0
|
||||
SECONDS=0; bl_session_pressure
|
||||
bl_zram_pick game; echo "pids:${_pids[*]}"
|
||||
bl_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_bl_pressure_at:$_bl_packed"
|
||||
''')[1:])
|
||||
|
||||
def test_low_ram_devices_compress_with_a_quarter_of_memory_left(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
|
||||
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
|
||||
self.memory(available=1900)
|
||||
self.assertEqual([], self.run_policy('bl_session_pressure'))
|
||||
|
||||
|
||||
def test_a_compressed_process_that_exits_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
alive=""; swap=0
|
||||
SECONDS=30; bl_session_pressure
|
||||
@@ -306,7 +350,7 @@ echo "backoff:$_bl_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_a_process_that_starts_after_a_pageout_is_not_in_its_read_back(self):
|
||||
self.assertEqual(['send:1:game', 'targets:999', 'send:1:game', 'backoff:30'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'targets:321 654', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
echo "targets:${_bl_tier_targets[*]}"
|
||||
alive="999 1234"
|
||||
@@ -315,7 +359,7 @@ echo "backoff:$_bl_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_an_incomplete_pageout_does_not_restart_the_launcher_wait(self):
|
||||
self.assertEqual(['send:1:game', 'client:-1:-1'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'client:-1:-1'], self.run_policy('''
|
||||
complete=0
|
||||
SECONDS=0; bl_session_pressure
|
||||
echo "client:$_bl_pressure_at:$_bl_packed"
|
||||
@@ -323,7 +367,7 @@ echo "client:$_bl_pressure_at:$_bl_packed"
|
||||
|
||||
|
||||
def test_a_reused_process_id_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; bl_session_pressure
|
||||
started=200; swap=0
|
||||
SECONDS=30; bl_session_pressure
|
||||
@@ -344,5 +388,112 @@ echo "backoff:$_bl_tier_backoff"
|
||||
self.assertEqual(['gone'], result.stdout.split())
|
||||
|
||||
|
||||
class ReclaimDispatchTest(unittest.TestCase):
|
||||
def run_cycle(self, client=1, game=1, anonymous=384, complete=1, reclaimed=128, body=None, available=1024, fall=0, tick=0):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
(root / 'meminfo').write_text(
|
||||
f'MemTotal: 7340032 kB\nMemAvailable: {available * 1024} kB\n'
|
||||
'SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
|
||||
(root / 'pressure').write_text('some avg10=0.00 avg60=0.00 avg300=0.00 total=0\n')
|
||||
names = ('bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
|
||||
'bl_zram_has_room', 'bl_client_can_pageout', 'bl_client_pressure',
|
||||
'bl_client_pressure_result', 'bl_client_pressure_finish',
|
||||
'bl_session_pressure', 'bl_zram_send', 'bl_zram_finish', 'bl_zram_pick')
|
||||
source = '\n'.join(function_source(name) for name in names)
|
||||
source = source.replace('/proc/meminfo', str(root / 'meminfo'))
|
||||
source = source.replace('/proc/pressure/memory', str(root / 'pressure'))
|
||||
source = source.replace('/tmp/.bl-zram', str(root / 'ctl'))
|
||||
monitor = SCRIPT.read_text()
|
||||
start = monitor.index(' _bl_preserved_growth=$_bl_growth', monitor.index('while kill -0 $$'))
|
||||
stop = monitor.index(' if [ "$_bl_game" = 1 ] && bl_game_focused', start)
|
||||
cycle = monitor[start:stop] if body is None else body
|
||||
script = f'''
|
||||
set -u
|
||||
BL_ZRAM_CLIENT={client} _bl_game={game} _bl_pids=(123) _bl_others=(321)
|
||||
_bl_pressure_at=-1 _bl_pressure_backoff=30 _bl_packed=-1
|
||||
_bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0
|
||||
_bl_client_reserve=0 client_rss=393216 client_anon={anonymous * 1024}
|
||||
step() {{ :; }}
|
||||
bl_session_others() {{ _bl_session=(321); }}
|
||||
bl_zram_scan() {{ _bl_pids=(456); }}
|
||||
nap() {{ echo "nap:$*:at:$NOW"; }}
|
||||
bl_zram_usage() {{
|
||||
if [ "$1" = 123 ]; then
|
||||
_bl_rss=$client_rss _bl_anon=$client_anon _bl_swap=0
|
||||
else
|
||||
_bl_rss=3145728 _bl_anon=1572864 _bl_swap=0
|
||||
fi
|
||||
}}
|
||||
kill() {{ echo "signal:$*:at:$NOW"; NOW=$((NOW + {tick})); }}
|
||||
bl_zram_wait() {{
|
||||
echo "wait:$*:at:$NOW"
|
||||
NOW=$((NOW + 12))
|
||||
_bl_pageout_complete={complete}
|
||||
[ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024}))
|
||||
}}
|
||||
bl_tier_note() {{ :; }}
|
||||
''' + source + f'''
|
||||
bl_memory_read
|
||||
_bl_fall={fall * 1024}
|
||||
''' + cycle + '''
|
||||
echo "client:$_bl_pressure_backoff:${_bl_client_reserve:-0}:${_bl_client_pending:-0}"
|
||||
'''
|
||||
result = run_bash('NOW=0\n' + script.replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_both_requests_are_sent_before_either_wait(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
|
||||
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'], self.run_cycle())
|
||||
|
||||
def test_disabled_client_is_never_signalled_or_waited_for(self):
|
||||
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(client=0))
|
||||
|
||||
def test_no_game_requests_nothing(self):
|
||||
self.assertEqual(['client:30:0:0'], self.run_cycle(game=0))
|
||||
|
||||
def test_a_client_with_no_anonymous_pages_still_finishes_its_request(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
|
||||
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'],
|
||||
self.run_cycle(anonymous=0))
|
||||
|
||||
def test_falling_headroom_survives_a_tick_between_requests(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:1',
|
||||
'wait:321:at:2', 'wait:123:at:14', 'client:30:0:0'],
|
||||
self.run_cycle(available=2304, fall=512, tick=1))
|
||||
|
||||
def test_deferred_ineffective_reclaim_still_doubles_the_backoff(self):
|
||||
self.assertEqual('client:60:0:0', self.run_cycle(reclaimed=0)[-1])
|
||||
|
||||
def test_deferred_incomplete_reclaim_does_not_double_the_backoff(self):
|
||||
self.assertEqual('client:30:0:0', self.run_cycle(reclaimed=0, complete=0)[-1])
|
||||
|
||||
def test_explicit_combined_send_keeps_its_synchronous_wait(self):
|
||||
self.assertEqual(['signal:-URG 321 123:at:0', 'wait:321 123:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(body='bl_zram_send 1 cap game\n'))
|
||||
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(client=0, body='bl_zram_send 1 cap game\n'))
|
||||
|
||||
def test_readback_keeps_its_synchronous_delay(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'nap:5:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(body='bl_zram_send 0 readback client\n'))
|
||||
|
||||
def test_usage_sums_anonymous_rss_and_falls_back_per_process(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
for pid, contents in ((123, 'VmRSS: 2000 kB\nRssAnon: 300 kB\nVmSwap: 100 kB\n'),
|
||||
(321, 'VmRSS: 4000 kB\nVmSwap: 200 kB\n'),
|
||||
(654, 'VmRSS: 1000 kB\nRssAnon: 0 kB\n')):
|
||||
(root / str(pid)).mkdir()
|
||||
(root / str(pid) / 'status').write_text(contents)
|
||||
source = function_source('bl_zram_usage').replace('/proc/', str(root) + '/')
|
||||
result = run_bash(source + '\nbl_zram_usage 123 321 654 > /dev/null; echo "$_bl_rss:$_bl_anon:$_bl_swap"')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('7000:4300:300', result.stdout.strip())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,224 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_usr2_preload import runner
|
||||
|
||||
HOOK_BUILD = Path(__file__).resolve().parents[1] / "nativeguest/build.sh"
|
||||
|
||||
PROBE = r"""
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char cwd[4096];
|
||||
for (int i = 1; i < argc; i++) {
|
||||
struct stat st;
|
||||
if (strncmp(argv[i], "cd:", 3) == 0) {
|
||||
int ok = chdir(argv[i] + 3) == 0 && getcwd(cwd, sizeof(cwd)) != NULL;
|
||||
printf("%s\t%s\n", argv[i], ok ? cwd : "-");
|
||||
continue;
|
||||
}
|
||||
if (strncmp(argv[i], "at:", 3) == 0) {
|
||||
int dfd = open(argv[i] + 3, O_RDONLY | O_DIRECTORY);
|
||||
printf("%s\t%d\t%d\n", argv[i], fstatat(AT_FDCWD, argv[i] + 3, &st, 0) == 0, dfd >= 0);
|
||||
if (dfd >= 0) close(dfd);
|
||||
continue;
|
||||
}
|
||||
if (strncmp(argv[i], "ls:", 3) == 0) {
|
||||
DIR *dir = opendir(argv[i] + 3);
|
||||
char names[1024] = "";
|
||||
struct dirent *de;
|
||||
while (dir && (de = readdir(dir)) != NULL) {
|
||||
if (de->d_name[0] == '.') continue;
|
||||
if (names[0]) strncat(names, ",", sizeof(names) - strlen(names) - 1);
|
||||
strncat(names, de->d_name, sizeof(names) - strlen(names) - 1);
|
||||
}
|
||||
if (dir) closedir(dir);
|
||||
printf("%s\t%s\n", argv[i], dir ? names : "-");
|
||||
continue;
|
||||
}
|
||||
int fd = open(argv[i], O_RDONLY);
|
||||
char data[64] = "-";
|
||||
if (fd >= 0) {
|
||||
ssize_t n = read(fd, data, sizeof(data) - 1);
|
||||
data[n > 0 ? n : 0] = 0;
|
||||
close(fd);
|
||||
}
|
||||
printf("%s\t%d\t%s\n", argv[i], stat(argv[i], &st) == 0, data);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
GAME = "/mnt/library/Some Game"
|
||||
|
||||
|
||||
class NativeHookMountTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.cc, cls.prefix = runner()
|
||||
if cls.cc is None:
|
||||
raise unittest.SkipTest("no aarch64 compiler and runner")
|
||||
cls.tmp = tempfile.TemporaryDirectory()
|
||||
tmp = Path(cls.tmp.name)
|
||||
cls.hook = tmp / "hook.so"
|
||||
subprocess.run(["bash", str(HOOK_BUILD), str(cls.hook), cls.cc], check=True, capture_output=True)
|
||||
(tmp / "probe.c").write_text(PROBE)
|
||||
subprocess.run([cls.cc, "-O1", "-o", str(tmp / "probe"), str(tmp / "probe.c")], check=True)
|
||||
cls.probe = tmp / "probe"
|
||||
cls.root = tmp / "root"
|
||||
cls.library = tmp / "storage/PC GAMES"
|
||||
(cls.root / "etc").mkdir(parents=True)
|
||||
(cls.root / "etc/hostname").write_text("rootfs")
|
||||
(cls.root / "mnt/library/Some Game").mkdir(parents=True)
|
||||
(cls.root / "mnt/library/Some Game/game.txt").write_text("mount point")
|
||||
(cls.library / "Some Game").mkdir(parents=True)
|
||||
(cls.library / "Some Game/game.txt").write_text("library")
|
||||
for name, target in (("native", str(cls.root)), ("guest", "/")):
|
||||
devices = cls.root / "pfx" / name / "dosdevices"
|
||||
devices.mkdir(parents=True)
|
||||
os.symlink(target, devices / "z:")
|
||||
relinked = cls.root / "pfx/relinked"
|
||||
(relinked / "dosdevices").mkdir(parents=True)
|
||||
(relinked / "drive_c").mkdir()
|
||||
(relinked / "drive_c/c.txt").write_text("drive c")
|
||||
os.symlink(os.path.relpath(cls.root, relinked / "dosdevices"), relinked / "dosdevices/z:")
|
||||
os.symlink("../drive_c", relinked / "dosdevices/c:")
|
||||
copied = cls.root / "pfx/copied/dosdevices"
|
||||
copied.mkdir(parents=True)
|
||||
os.symlink("../" * 12 + "..", copied / "z:")
|
||||
elsewhere = tmp / "elsewhere"
|
||||
(elsewhere / "outside/pfx/dosdevices").mkdir(parents=True)
|
||||
(elsewhere / "mnt/library/Some Game").mkdir(parents=True)
|
||||
(elsewhere / "mnt/library/Some Game/game.txt").write_text("elsewhere")
|
||||
os.symlink("../../..", elsewhere / "outside/pfx/dosdevices/z:")
|
||||
os.symlink(str(elsewhere / "outside/pfx"), cls.root / "pfx/outside")
|
||||
cls.private = tmp / "private"
|
||||
private_pfx = cls.private / "123/pfx/dosdevices"
|
||||
private_pfx.mkdir(parents=True)
|
||||
os.symlink(os.path.relpath("/", "/mnt/private/123/pfx/dosdevices"), private_pfx / "z:")
|
||||
private_copy = cls.private / "456/pfx/dosdevices"
|
||||
private_copy.mkdir(parents=True)
|
||||
os.symlink("../" * 12 + "..", private_copy / "z:")
|
||||
cls.eqlen_src = tmp / "eqsrcdir"
|
||||
cls.eqlen_dst = "/" + "d" * (len(str(cls.eqlen_src)) - 1)
|
||||
eqlen_pfx = cls.eqlen_src / "123/pfx/dosdevices"
|
||||
eqlen_pfx.mkdir(parents=True)
|
||||
os.symlink(os.path.relpath("/", f"{cls.eqlen_dst}/123/pfx/dosdevices"), eqlen_pfx / "z:")
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.tmp.cleanup()
|
||||
|
||||
def run_probe(self, *args):
|
||||
binds = f"{self.library}:/mnt/library|{self.private}:/mnt/private|{self.eqlen_src}:{self.eqlen_dst}"
|
||||
hook_env = {"DDNATV_ROOT": str(self.root), "DDNATV_BINDS": binds, "LD_PRELOAD": str(self.hook)}
|
||||
env = {k: v for k, v in os.environ.items() if k != "LD_PRELOAD"}
|
||||
if self.prefix:
|
||||
cmd = list(self.prefix) + [arg for key, value in hook_env.items() for arg in ("-E", f"{key}={value}")]
|
||||
else:
|
||||
cmd = []
|
||||
env.update(hook_env)
|
||||
out = subprocess.run(cmd + [str(self.probe), *args], env=env, capture_output=True, text=True, timeout=120,
|
||||
cwd=self.tmp.name)
|
||||
self.assertEqual(out.returncode, 0, out.stderr)
|
||||
return {line.split("\t")[0]: line.split("\t")[1:] for line in out.stdout.splitlines()}
|
||||
|
||||
def test_drive_link_stored_as_rootfs_path_reaches_the_mount(self):
|
||||
path = f"/pfx/native/dosdevices/z:{GAME}/game.txt"
|
||||
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
|
||||
|
||||
def test_working_directory_through_a_drive_link_is_the_mount(self):
|
||||
arg = f"cd:/pfx/native/dosdevices/z:{GAME}/"
|
||||
self.assertEqual(self.run_probe(arg)[arg], [GAME])
|
||||
|
||||
def test_rootfs_path_under_a_mount_point_reaches_the_mount(self):
|
||||
path = f"{self.root}{GAME}/game.txt"
|
||||
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
|
||||
|
||||
def test_guest_drive_link_is_unchanged(self):
|
||||
path = f"/pfx/guest/dosdevices/z:{GAME}/game.txt"
|
||||
self.assertEqual(self.run_probe(path)[path], ["1", "library"])
|
||||
|
||||
def test_rootfs_paths_outside_mounts_are_unchanged(self):
|
||||
paths = ["/pfx/native/dosdevices/z:/etc/hostname", f"{self.root}/etc/hostname", "/etc/hostname"]
|
||||
result = self.run_probe(*paths)
|
||||
for path in paths:
|
||||
self.assertEqual(result[path], ["1", "rootfs"], path)
|
||||
|
||||
def test_wine_lookup_steps_reach_the_mount(self):
|
||||
for pfx in ("/pfx/native", "/pfx/guest", "/pfx/relinked", f"{self.root}/pfx/native", f"{self.root}/pfx/guest",
|
||||
f"{self.root}/pfx/relinked"):
|
||||
drive = f"{pfx}/dosdevices/z:"
|
||||
args = [f"at:{drive}{GAME}/", f"at:{drive}{GAME}", f"ls:{drive}/mnt/library", f"ls:{drive}{GAME}"]
|
||||
result = self.run_probe(*args)
|
||||
self.assertEqual(result[args[0]], ["1", "1"], pfx)
|
||||
self.assertEqual(result[args[1]], ["1", "1"], pfx)
|
||||
self.assertEqual(result[args[2]], ["Some Game"], pfx)
|
||||
self.assertEqual(result[args[3]], ["game.txt"], pfx)
|
||||
|
||||
def test_relative_drive_link_reaches_the_mount(self):
|
||||
path = f"/pfx/relinked/dosdevices/z:{GAME}/game.txt"
|
||||
cd = f"cd:/pfx/relinked/dosdevices/z:{GAME}/"
|
||||
result = self.run_probe(path, cd)
|
||||
self.assertEqual(result[path], ["1", "library"])
|
||||
self.assertEqual(result[cd], [GAME])
|
||||
|
||||
def test_relative_links_outside_mounts_are_unchanged(self):
|
||||
paths = ["/pfx/relinked/dosdevices/z:/etc/hostname", "/pfx/relinked/dosdevices/c:/c.txt",
|
||||
f"{self.root}/pfx/relinked/dosdevices/c:/c.txt"]
|
||||
result = self.run_probe(*paths)
|
||||
self.assertEqual(result[paths[0]], ["1", "rootfs"])
|
||||
self.assertEqual(result[paths[1]], ["1", "drive c"])
|
||||
self.assertEqual(result[paths[2]], ["1", "drive c"])
|
||||
|
||||
def test_suffix_after_a_relative_link_is_not_collapsed(self):
|
||||
path = "/pfx/relinked/dosdevices/z:/mnt/library/missing/../Some Game/game.txt"
|
||||
self.assertEqual(self.run_probe(path)[path], ["0", "-"])
|
||||
|
||||
def test_relative_drive_link_climbing_past_the_root_reaches_the_mount(self):
|
||||
path = f"/pfx/copied/dosdevices/z:{GAME}/game.txt"
|
||||
cd = f"cd:/pfx/copied/dosdevices/z:{GAME}/"
|
||||
result = self.run_probe(path, cd)
|
||||
self.assertEqual(result[path], ["1", "library"])
|
||||
self.assertEqual(result[cd], [GAME])
|
||||
|
||||
def test_relative_link_climbing_past_the_root_stays_in_the_rootfs(self):
|
||||
path = "/pfx/copied/dosdevices/z:/etc/hostname"
|
||||
self.assertEqual(self.run_probe(path)[path], ["1", "rootfs"])
|
||||
|
||||
def test_relative_link_is_resolved_from_its_real_directory(self):
|
||||
path = f"/pfx/outside/dosdevices/z:{GAME}/game.txt"
|
||||
self.assertEqual(self.run_probe(path)[path], ["1", "elsewhere"])
|
||||
|
||||
def test_drive_link_in_a_bound_prefix_reaches_the_mount(self):
|
||||
path = f"/mnt/private/123/pfx/dosdevices/z:{GAME}/game.txt"
|
||||
cd = f"cd:/mnt/private/123/pfx/dosdevices/z:{GAME}/"
|
||||
result = self.run_probe(path, cd)
|
||||
self.assertEqual(result[path], ["1", "library"])
|
||||
self.assertEqual(result[cd], [GAME])
|
||||
|
||||
def test_drive_link_copied_into_a_bound_prefix_reaches_the_mount(self):
|
||||
path = f"/mnt/private/456/pfx/dosdevices/z:{GAME}/game.txt"
|
||||
cd = f"cd:/mnt/private/456/pfx/dosdevices/z:{GAME}/"
|
||||
result = self.run_probe(path, cd)
|
||||
self.assertEqual(result[path], ["1", "library"])
|
||||
self.assertEqual(result[cd], [GAME])
|
||||
|
||||
def test_drive_link_in_equal_length_bound_prefix_reaches_the_mount(self):
|
||||
path = f"{self.eqlen_dst}/123/pfx/dosdevices/z:{GAME}/game.txt"
|
||||
cd = f"cd:{self.eqlen_dst}/123/pfx/dosdevices/z:{GAME}/"
|
||||
result = self.run_probe(path, cd)
|
||||
self.assertEqual(result[path], ["1", "library"])
|
||||
self.assertEqual(result[cd], [GAME])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,241 @@
|
||||
from pathlib import Path
|
||||
import runpy
|
||||
import struct
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
||||
MODULE = runpy.run_path(str(BIN / 'droiddeck-pace-cores'))
|
||||
Frames = MODULE['Frames']
|
||||
Parker = MODULE['Parker']
|
||||
Governor = MODULE['Governor']
|
||||
efficient_cores = MODULE['efficient_cores']
|
||||
paced_interval = MODULE['paced_interval']
|
||||
|
||||
ALL = set(range(8))
|
||||
EFFICIENT = set(range(6))
|
||||
VBLANK = 1e9 / 60
|
||||
CAPACITY = 1024
|
||||
|
||||
|
||||
class FakeCores:
|
||||
|
||||
def __init__(self, tids):
|
||||
self.state = {tid: set(ALL) for tid in tids}
|
||||
|
||||
def get(self, tid):
|
||||
if tid not in self.state:
|
||||
raise ProcessLookupError(tid)
|
||||
return set(self.state[tid])
|
||||
|
||||
def set(self, tid, cpus):
|
||||
if tid not in self.state:
|
||||
raise ProcessLookupError(tid)
|
||||
self.state[tid] = set(cpus)
|
||||
|
||||
|
||||
class FeedWriter:
|
||||
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.count = 0
|
||||
self.data = bytearray(128 + CAPACITY * 16)
|
||||
struct.pack_into('<IIII', self.data, 0, 0x46484444, 1, CAPACITY, 0)
|
||||
|
||||
def focus(self, pid, steam=False):
|
||||
struct.pack_into('<I', self.data, 12, pid)
|
||||
struct.pack_into('<IIII', self.data, 28, 1920, 1080, 60000, 1 if steam else 0)
|
||||
self.flush()
|
||||
|
||||
def frames(self, *intervals):
|
||||
for value in intervals:
|
||||
struct.pack_into('<QQ', self.data, 128 + (self.count % CAPACITY) * 16, int(value), 0)
|
||||
self.count += 1
|
||||
struct.pack_into('<Q', self.data, 16, self.count)
|
||||
self.flush()
|
||||
|
||||
def flush(self):
|
||||
self.path.write_bytes(bytes(self.data))
|
||||
|
||||
|
||||
class PacedIntervalTest(unittest.TestCase):
|
||||
def test_a_steady_cap_at_30_fps_or_more_is_paced(self):
|
||||
self.assertAlmostEqual(paced_interval([VBLANK] * 60), VBLANK)
|
||||
self.assertAlmostEqual(paced_interval([1e9 / 30] * 30), 1e9 / 30)
|
||||
jitter = [1e9 / 60 * (1 + 0.03 * (-1) ** i) for i in range(60)]
|
||||
self.assertIsNotNone(paced_interval(jitter))
|
||||
|
||||
def test_under_30_fps_is_not(self):
|
||||
self.assertIsNone(paced_interval([1e9 / 24] * 24))
|
||||
self.assertIsNone(paced_interval([1e9 / 15] * 15))
|
||||
|
||||
def test_a_spread_or_missed_frames_are_not(self):
|
||||
self.assertIsNone(paced_interval([VBLANK] * 50 + [2 * VBLANK] * 10))
|
||||
self.assertIsNone(paced_interval([VBLANK * (0.8 + 0.4 * (i % 5) / 4) for i in range(60)]))
|
||||
self.assertIsNone(paced_interval([]))
|
||||
|
||||
|
||||
class EfficientCoresTest(unittest.TestCase):
|
||||
def test_everything_below_the_top_capacity(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
cpu = Path(temp)
|
||||
(cpu / 'online').write_text('0-7\n')
|
||||
for core in ALL:
|
||||
(cpu / f'cpu{core}').mkdir()
|
||||
(cpu / f'cpu{core}/cpu_capacity').write_text('1024\n' if core >= 6 else '792\n')
|
||||
self.assertEqual(efficient_cores(cpu, set(ALL)), EFFICIENT)
|
||||
self.assertEqual(efficient_cores(cpu, {6, 7}), set())
|
||||
|
||||
def test_one_tier_has_none(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
cpu = Path(temp)
|
||||
(cpu / 'online').write_text('0-3\n')
|
||||
for core in range(4):
|
||||
(cpu / f'cpu{core}').mkdir()
|
||||
(cpu / f'cpu{core}/cpu_capacity').write_text('1024\n')
|
||||
self.assertEqual(efficient_cores(cpu, set(range(4))), set())
|
||||
|
||||
|
||||
class GovernorTest(unittest.TestCase):
|
||||
PID = 400
|
||||
TIDS = (400, 401, 402)
|
||||
|
||||
def setUp(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temp.cleanup)
|
||||
root = Path(temp.name)
|
||||
for tid in self.TIDS:
|
||||
(root / f'proc/{self.PID}/task/{tid}').mkdir(parents=True)
|
||||
self.cores = FakeCores(self.TIDS)
|
||||
self.feed = FeedWriter(root / 'frames')
|
||||
self.feed.focus(self.PID)
|
||||
self.now = 0.0
|
||||
self.governor = Governor(Frames(root / 'frames'), Parker(EFFICIENT, root / 'proc', self.cores),
|
||||
clock=lambda: self.now)
|
||||
self.governor.tick()
|
||||
|
||||
def run_for(self, seconds, interval):
|
||||
for _ in range(int(seconds / 0.5)):
|
||||
self.now += 0.5
|
||||
self.feed.frames(*([interval] * int(0.5e9 / interval)))
|
||||
self.governor.tick()
|
||||
|
||||
def test_parks_a_game_that_holds_its_pace(self):
|
||||
self.run_for(4, VBLANK)
|
||||
self.assertEqual(self.governor.parker.pid, self.PID)
|
||||
self.assertTrue(all(cpus == EFFICIENT for cpus in self.cores.state.values()))
|
||||
|
||||
def test_releases_when_frames_fall_behind_and_backs_off(self):
|
||||
self.run_for(4, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
|
||||
self.run_for(10, VBLANK)
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
self.run_for(30, VBLANK)
|
||||
self.assertEqual(self.governor.parker.pid, self.PID)
|
||||
|
||||
def test_struggling_game_stays_on_every_core(self):
|
||||
for step in range(20):
|
||||
self.now += 0.5
|
||||
self.feed.frames(*([VBLANK, 2 * VBLANK] * 10))
|
||||
self.governor.tick()
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
|
||||
|
||||
def test_steam_in_front_releases_without_backoff(self):
|
||||
self.run_for(4, VBLANK)
|
||||
self.feed.focus(self.PID, steam=True)
|
||||
self.now += 0.5
|
||||
self.governor.tick()
|
||||
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
|
||||
self.feed.focus(self.PID)
|
||||
self.run_for(4, VBLANK)
|
||||
self.assertEqual(self.governor.parker.pid, self.PID)
|
||||
|
||||
def test_a_mask_the_game_set_itself_is_kept(self):
|
||||
self.run_for(4, VBLANK)
|
||||
self.cores.state[401] = {7}
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[401], {7})
|
||||
self.assertEqual(self.cores.state[400], ALL)
|
||||
|
||||
def idle_for(self, seconds):
|
||||
for _ in range(int(seconds / 0.5)):
|
||||
self.now += 0.5
|
||||
self.governor.tick()
|
||||
|
||||
def test_thread_born_parked_is_restored(self):
|
||||
self.run_for(4, VBLANK)
|
||||
(self.governor.parker.proc / f'{self.PID}/task/403').mkdir()
|
||||
self.cores.state[403] = set(EFFICIENT)
|
||||
self.run_for(1, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[403], ALL)
|
||||
|
||||
def test_a_thread_already_on_efficient_cores_keeps_its_mask(self):
|
||||
self.cores.state[402] = set(EFFICIENT)
|
||||
self.run_for(4, VBLANK)
|
||||
self.run_for(1, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[402], EFFICIENT)
|
||||
self.assertEqual(self.cores.state[400], ALL)
|
||||
|
||||
def test_a_child_of_a_game_pinned_thread_keeps_its_mask(self):
|
||||
self.cores.state[402] = set(EFFICIENT)
|
||||
self.run_for(4, VBLANK)
|
||||
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
|
||||
self.cores.state[404] = set(EFFICIENT)
|
||||
self.run_for(1, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[404], EFFICIENT)
|
||||
self.assertEqual(self.cores.state[400], ALL)
|
||||
|
||||
def test_a_child_of_a_game_pinned_thread_that_exited_keeps_its_mask(self):
|
||||
self.cores.state[402] = set(EFFICIENT)
|
||||
self.run_for(4, VBLANK)
|
||||
(self.governor.parker.proc / f'{self.PID}/task/402').rmdir()
|
||||
del self.cores.state[402]
|
||||
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
|
||||
self.cores.state[404] = set(EFFICIENT)
|
||||
self.run_for(1, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[404], EFFICIENT)
|
||||
self.assertEqual(self.cores.state[400], ALL)
|
||||
|
||||
def test_born_parked_thread_gets_every_original_it_could_have_had(self):
|
||||
for tid in self.TIDS:
|
||||
self.cores.state[tid] = EFFICIENT | {6}
|
||||
self.cores.state[402] = EFFICIENT | {7}
|
||||
self.run_for(4, VBLANK)
|
||||
(self.governor.parker.proc / f'{self.PID}/task/404').mkdir()
|
||||
self.cores.state[404] = set(EFFICIENT)
|
||||
self.run_for(1, VBLANK)
|
||||
self.run_for(2, 2 * VBLANK)
|
||||
self.assertEqual(self.cores.state[404], ALL)
|
||||
self.assertEqual(self.cores.state[402], EFFICIENT | {7})
|
||||
|
||||
def test_a_stalled_game_is_not_parked_on_old_frames(self):
|
||||
self.run_for(0.5, VBLANK)
|
||||
self.idle_for(3)
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
self.run_for(2, VBLANK)
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
|
||||
def test_a_parked_game_that_stops_presenting_is_released(self):
|
||||
self.run_for(4, VBLANK)
|
||||
self.run_for(1, 1e9)
|
||||
self.idle_for(1)
|
||||
self.assertIsNone(self.governor.parker.pid)
|
||||
self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values()))
|
||||
|
||||
def test_threads_pinned_to_fast_cores_are_left_alone(self):
|
||||
self.cores.state[402] = {6, 7}
|
||||
self.run_for(4, VBLANK)
|
||||
self.assertEqual(self.cores.state[402], {6, 7})
|
||||
self.assertEqual(self.cores.state[400], EFFICIENT)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -150,6 +150,30 @@ class PreloadSnapshotTest(unittest.TestCase):
|
||||
with self.assertRaisesRegex(ValueError, 'successful main'):
|
||||
snapshots.artifact_bytes(self.data['origin'], self.root / 'cache')
|
||||
|
||||
def test_origin_apk_without_a_newer_output_reads_the_rest(self):
|
||||
from zipfile import ZipFile
|
||||
newest = 'libddnatv-hook.so'
|
||||
apk = io.BytesIO()
|
||||
with ZipFile(apk, 'w') as z:
|
||||
for name, value in self.binaries.items():
|
||||
if name != newest:
|
||||
z.writestr('assets/linuxfs/' + name, value)
|
||||
outer = io.BytesIO()
|
||||
with ZipFile(outer, 'w') as z:
|
||||
z.writestr('app-release.apk', apk.getvalue())
|
||||
digest = snapshots.sha(outer.getvalue())
|
||||
origin = dict(self.data['origin'], artifact_sha256=digest)
|
||||
build = dict(event='push', head_branch='main', conclusion='success', head_sha=origin['commit'],
|
||||
path='.github/workflows/build.yml', repository=dict(full_name=snapshots.REPO))
|
||||
artifact = dict(name='droiddeck-apk', workflow_run=dict(id=origin['run']), digest='sha256:' + digest)
|
||||
cache = self.root / 'cache'
|
||||
cache.mkdir()
|
||||
(cache / (digest + '.zip')).write_bytes(outer.getvalue())
|
||||
with patch.object(snapshots, 'api', side_effect=[build, artifact]):
|
||||
content = snapshots.artifact_bytes(origin, cache)
|
||||
self.assertNotIn(newest, content)
|
||||
self.assertEqual(set(content), snapshots.FILES - {newest})
|
||||
|
||||
def test_corrupt_archive_is_rejected(self):
|
||||
with self.assertRaisesRegex(ValueError, 'checksum'):
|
||||
snapshots.unpack(self.content + b'tampered', self.data)
|
||||
|
||||
@@ -33,6 +33,9 @@ class RuntimeInputsTest(unittest.TestCase):
|
||||
self.source = self.root / 'tools/linuxfs/preload/test.c'
|
||||
self.source.parent.mkdir(parents=True)
|
||||
self.source.write_text('current source')
|
||||
service = self.root / 'app/src/main/assets/linuxfs/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe'
|
||||
service.parent.mkdir(parents=True)
|
||||
service.write_bytes(b'MZ service')
|
||||
self.audio(['pactl', 'modules/arm64/module-aaudio-sink.so', 'modules/arm64/module-directaudio-native-sink.so'])
|
||||
self.packs()
|
||||
|
||||
@@ -179,6 +182,13 @@ class RuntimeInputsTest(unittest.TestCase):
|
||||
with self.assertRaisesRegex(ValueError, 'xbox pack provides'):
|
||||
runtime.check_apk(apk, self.root)
|
||||
|
||||
def test_an_apk_still_carrying_the_ubisoft_service_is_rejected(self):
|
||||
name = 'assets/linuxfs/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe'
|
||||
self.assertIn(name, runtime.outputs(self.root))
|
||||
apk = self.current_apk(self.root / 'bundled.apk', {name: b'MZ service'})
|
||||
with self.assertRaisesRegex(ValueError, 'ubisoft pack provides'):
|
||||
runtime.check_apk(apk, self.root)
|
||||
|
||||
def test_an_apk_still_carrying_the_powervr_runtime_is_rejected(self):
|
||||
apk = self.current_apk(self.root / 'bundled.apk', {'assets/hybris/runtime.tzst': b'runtime'})
|
||||
with self.assertRaisesRegex(ValueError, 'powervr pack provides'):
|
||||
|
||||
@@ -2,6 +2,7 @@ import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
@@ -128,6 +129,67 @@ class SeedRedistsTest(unittest.TestCase):
|
||||
self.run_seed(str(sd))
|
||||
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
|
||||
|
||||
def manifest(self, name, build):
|
||||
path = self.steam / "steamapps/appmanifest_77.acf"
|
||||
path.write_text('"AppState"\n{\n\t"installdir"\t\t"%s"\n\t"buildid"\t\t"%s"\n}\n' % (name, build))
|
||||
return path
|
||||
|
||||
def test_a_game_is_searched_again_only_when_its_build_changes(self):
|
||||
late = self.steam / "steamapps/common/Late Game/installscript.vdf"
|
||||
late.parent.mkdir(parents=True)
|
||||
manifest = self.manifest("Late Game", "1")
|
||||
self.run_seed()
|
||||
late.write_text(GAME_SCRIPT)
|
||||
manifest.write_text(manifest.read_text() + "\n")
|
||||
self.run_seed()
|
||||
self.assertNotIn("VCRedist2022", self.reg.read_text())
|
||||
self.manifest("Late Game", "2")
|
||||
self.run_seed()
|
||||
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
|
||||
|
||||
def test_one_changed_game_leaves_the_other_games_unsearched(self):
|
||||
other = self.game("Other Game").parent / "installscript_extra.vdf"
|
||||
self.manifest("Late Game", "1")
|
||||
self.run_seed()
|
||||
other.write_text(GAME_SCRIPT.replace("VCRedist2022", "Unsearched"))
|
||||
self.manifest("Late Game", "2")
|
||||
self.run_seed()
|
||||
self.assertNotIn("Unsearched", self.reg.read_text())
|
||||
|
||||
def test_a_call_that_names_its_scripts_does_not_search_the_libraries(self):
|
||||
script = self.game()
|
||||
named = self.tmp / "legacycompat/evaluatorscript_1.vdf"
|
||||
named.parent.mkdir(parents=True)
|
||||
named.write_text(GAME_SCRIPT.replace("VCRedist2022", "Named"))
|
||||
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_SCRIPTS=str(named))
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, text=True, check=True)
|
||||
reg = self.reg.read_text()
|
||||
self.assertIn('"Named"=dword:00000001', reg)
|
||||
self.assertNotIn("VCRedist2022", reg)
|
||||
self.run_seed()
|
||||
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
|
||||
self.assertIn(str(script), (self.steam / ".droiddeck-game-scripts").read_text())
|
||||
|
||||
def test_a_removed_game_leaves_the_list(self):
|
||||
script = self.game()
|
||||
self.run_seed()
|
||||
cache = self.steam / ".droiddeck-game-scripts"
|
||||
self.assertIn(str(script), cache.read_text())
|
||||
for manifest in (self.steam / "steamapps").glob("appmanifest_*.acf"):
|
||||
manifest.unlink()
|
||||
self.run_seed()
|
||||
self.assertEqual("", cache.read_text())
|
||||
|
||||
def test_a_list_from_an_earlier_version_is_taken_over_without_a_search(self):
|
||||
script = self.steam / "steamapps/common/Old Game/a/b/c/d/e/installscript.vdf"
|
||||
script.parent.mkdir(parents=True)
|
||||
script.write_text(GAME_SCRIPT)
|
||||
self.manifest("Old Game", "1")
|
||||
(self.steam / ".droiddeck-game-scripts").write_text("123 456\n%s\n" % script)
|
||||
self.run_seed()
|
||||
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
|
||||
self.assertIn("\t%s\n" % script, (self.steam / ".droiddeck-game-scripts").read_text())
|
||||
|
||||
def test_current_user_and_machine_markers_go_to_their_own_registries(self):
|
||||
self.game(script=GAME_SCRIPT + GAME_SCRIPT.replace("HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER").replace("VCRedist2022", "UserRedist"))
|
||||
with self.reg.open("a") as out:
|
||||
@@ -398,6 +460,62 @@ class SeedRedistsTest(unittest.TestCase):
|
||||
self.assertEqual(self.reg.read_text().count('"Vulkan111080"'), 2)
|
||||
|
||||
|
||||
def test_a_session_start_leaves_the_library_search_to_a_later_run(self):
|
||||
self.game(script=GAME_SCRIPT.replace("Software\\\\Valve\\\\Steam\\\\Apps\\\\CommonRedist\\\\vcredist\\\\2022", "SOFTWARE\\\\AGEIA Technologies").replace("VCRedist2022", "PhysX Version"))
|
||||
shim = self.tmp / "bin"
|
||||
shim.mkdir()
|
||||
go = self.tmp / "go"
|
||||
(shim / "find").write_text('#!/bin/sh\ncase "$*" in *"installscript*"*) n=0; while [ ! -e "%s" ] && [ $n -lt 600 ]; do sleep 0.1; n=$((n + 1)); done;; esac\nexec %s "$@"\n' % (go, shutil.which("find")))
|
||||
(shim / "find").chmod(0o755)
|
||||
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_LATER="1", PATH="%s:%s" % (shim, os.environ["PATH"]))
|
||||
marker = '"PhysX Version"=dword:00000001'
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
|
||||
self.assertNotIn(marker, self.reg.read_text())
|
||||
go.touch()
|
||||
deadline = time.monotonic() + 30
|
||||
while marker not in self.reg.read_text() and time.monotonic() < deadline:
|
||||
time.sleep(0.2)
|
||||
self.assertIn(marker, self.reg.read_text())
|
||||
before = self.reg.read_text()
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
|
||||
time.sleep(0.5)
|
||||
self.assertEqual(before, self.reg.read_text())
|
||||
|
||||
def test_a_game_whose_search_failed_is_searched_again(self):
|
||||
self.game()
|
||||
broken = self.tmp / "broken"
|
||||
broken.touch()
|
||||
shim = self.tmp / "bin"
|
||||
shim.mkdir()
|
||||
(shim / "find").write_text('#!/bin/sh\n%s "$@"\n[ ! -e "%s" ]\n' % (shutil.which("find"), broken))
|
||||
(shim / "find").chmod(0o755)
|
||||
env = dict(os.environ, DROIDDECK_LIBRARIES="", PATH="%s:%s" % (shim, os.environ["PATH"]))
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, check=True)
|
||||
self.assertNotIn("VCRedist2022", self.reg.read_text())
|
||||
broken.unlink()
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, capture_output=True, check=True)
|
||||
self.assertIn('"VCRedist2022"=dword:00000001', self.reg.read_text())
|
||||
|
||||
def test_a_later_run_leaves_the_registry_alone_while_a_wine_server_runs(self):
|
||||
self.game(script=GAME_SCRIPT.replace("Software\\\\Valve\\\\Steam\\\\Apps\\\\CommonRedist\\\\vcredist\\\\2022", "SOFTWARE\\\\AGEIA Technologies").replace("VCRedist2022", "PhysX Version"))
|
||||
shim = self.tmp / "bin"
|
||||
shim.mkdir()
|
||||
(shim / "pgrep").write_text("#!/bin/sh\nexit 0\n")
|
||||
(shim / "pgrep").chmod(0o755)
|
||||
env = dict(os.environ, DROIDDECK_LIBRARIES="", DROIDDECK_SEED_LATER="1", PATH="%s:%s" % (shim, os.environ["PATH"]))
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
|
||||
cache = self.steam / ".droiddeck-game-scripts"
|
||||
deadline = time.monotonic() + 30
|
||||
while not (cache.exists() and "installscript" in cache.read_text().lower()) and time.monotonic() < deadline:
|
||||
time.sleep(0.2)
|
||||
self.assertIn("installscript", cache.read_text().lower())
|
||||
time.sleep(1)
|
||||
self.assertNotIn("PhysX Version", self.reg.read_text())
|
||||
env.pop("DROIDDECK_SEED_LATER")
|
||||
env["PATH"] = os.environ["PATH"]
|
||||
subprocess.run(["bash", str(SCRIPT), str(self.steam)], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
|
||||
self.assertIn('"PhysX Version"=dword:00000001', self.reg.read_text())
|
||||
|
||||
def evaluator(self, appid, install_script):
|
||||
script = self.tmp / ("legacycompat/evaluatorscript_%s.vdf" % appid)
|
||||
script.parent.mkdir(parents=True)
|
||||
|
||||
@@ -43,6 +43,34 @@ class WebhelperLayoutTest(unittest.TestCase):
|
||||
def test_the_steam_block_uses_it(self):
|
||||
self.assertIn("BL_WEBHELPER_ARGS=$(bl_webhelper_layout)", SESSION.read_text())
|
||||
|
||||
def test_the_gpu_ui_on_the_bridge_defaults_to_angle_on_vulkan_without_vulkan_compositing(self):
|
||||
text = SESSION.read_text()
|
||||
gpu = text.index('elif [ "${_bl_cef[0]}" = -cef-force-gpu ]; then')
|
||||
software = text.rindex('_bl_cef=(-cef-disable-gpu -cef-disable-gpu-compositing)', 0, gpu)
|
||||
defaults = text.index(': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"', gpu)
|
||||
self.assertLess(software, gpu)
|
||||
self.assertLess(defaults, text.index("BL_WEBHELPER_ARGS=$(bl_webhelper_layout)", gpu))
|
||||
self.assertLess(defaults, text.index("\n fi\n", gpu))
|
||||
|
||||
def test_the_defaults_give_way_to_settings(self):
|
||||
script = ': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"\n' + layout_function() + "bl_webhelper_layout\n"
|
||||
env = {k: v for k, v in os.environ.items() if k not in KEYS}
|
||||
run = lambda **s: subprocess.run(["bash", "-c", "set -u\n" + script], env={**env, **s},
|
||||
capture_output=True, text=True, check=True).stdout.strip()
|
||||
self.assertEqual(run(), "--use-gl=angle --use-angle=vulkan")
|
||||
self.assertEqual(run(BL_VKBRIDGE_CEF_VULKAN="1"),
|
||||
"--use-gl=angle --use-angle=vulkan +Vulkan +VulkanFromANGLE +DefaultANGLEVulkan")
|
||||
self.assertEqual(run(BL_VKBRIDGE_CEF_ANGLE="gl"), "--use-gl=angle --use-angle=gl")
|
||||
|
||||
def test_empty_settings_are_kept_as_set(self):
|
||||
script = ': "${BL_VKBRIDGE_CEF_ANGLE=vulkan}" "${BL_VKBRIDGE_CEF_VULKAN=0}"\n' + layout_function() + "bl_webhelper_layout\n"
|
||||
env = {k: v for k, v in os.environ.items() if k not in KEYS}
|
||||
run = lambda **s: subprocess.run(["bash", "-c", "set -u\n" + script], env={**env, **s},
|
||||
capture_output=True, text=True, check=True).stdout.strip()
|
||||
self.assertEqual(run(BL_VKBRIDGE_CEF_ANGLE=""), "stock")
|
||||
self.assertEqual(run(BL_VKBRIDGE_CEF_VULKAN=""),
|
||||
"--use-gl=angle --use-angle=vulkan +Vulkan +VulkanFromANGLE +DefaultANGLEVulkan")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -99,6 +99,31 @@ class X64RepointTest(unittest.TestCase):
|
||||
self.assertEqual(COMPAT["x64_repoint"](str(self.root), None), [])
|
||||
self.assertEqual((self.root / "config" / "config.vdf").read_text(), before)
|
||||
|
||||
def test_new_owned_shortcut_gets_the_x64_default_and_explicit_choice_stays(self):
|
||||
app = "2350879490"
|
||||
chosen = "proton-cachyos-a64"
|
||||
config = self.root / "config" / "config.vdf"
|
||||
state = self.root / "droiddeck-compat"
|
||||
self.assertEqual(COMPAT["register_default"](
|
||||
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
|
||||
default="GE-Proton11-7-a64", directory=str(state),
|
||||
linux_tool="droiddeck-direct", owned=[app]), "GE-Proton11-7-a64")
|
||||
self.assertEqual(self.mapping()[app], "GE-Proton11-7-a64")
|
||||
self.assertEqual(COMPAT["register_default"](
|
||||
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
|
||||
default="GE-Proton11-7-a64", directory=str(state),
|
||||
linux_tool="droiddeck-direct", owned=[app]), "GE-Proton11-7-a64")
|
||||
self.assertEqual(self.mapping()[app], "GE-Proton11-7-a64")
|
||||
tokens = COMPAT["tokenize"](config.read_text())
|
||||
mapping = COMPAT["mapping_block"](tokens)
|
||||
COMPAT["set_mapping"](tokens, mapping, app, chosen)
|
||||
config.write_text(COMPAT["serialize"](tokens))
|
||||
COMPAT["register_default"](
|
||||
str(config), apps=[app], protect={chosen: "proton-cachyos-a64"},
|
||||
default="GE-Proton11-7-a64", directory=str(state),
|
||||
linux_tool="droiddeck-direct", owned=[app])
|
||||
self.assertEqual(self.mapping()[app], chosen)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -3,6 +3,7 @@ import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
@@ -56,6 +57,171 @@ class ImportsTest(unittest.TestCase):
|
||||
self.assertEqual(self.folder, (self.steam / 'steamapps/common/DroidDeck-42').resolve())
|
||||
self.assertEqual(b'game', self.exe.read_bytes())
|
||||
|
||||
def steam_install(self, appid=42):
|
||||
library = self.root / 'Library'
|
||||
folder = library / 'steamapps/common/Example'
|
||||
folder.mkdir(parents=True)
|
||||
(folder / 'Example.exe').write_bytes(b'game')
|
||||
(library / f'steamapps/appmanifest_{appid}.acf').write_text(f'"AppState"\n{{\n"appid" "{appid}"\n"installdir" "Example"\n}}\n')
|
||||
saves = library / f'steamapps/compatdata/{appid}/pfx/drive_c/users/steamuser'
|
||||
saves.mkdir(parents=True)
|
||||
(saves / 'save.dat').write_bytes(b'cloud')
|
||||
return dict(self.game, folder=str(folder), exe=str(folder / 'Example.exe'), dir=str(folder)), library
|
||||
|
||||
def shortcut_prefix(self):
|
||||
return self.steam / 'steamapps/compatdata' / str(self.game['appid'] & 0xFFFFFFFF)
|
||||
|
||||
def link_shortcut_prefix(self, target, owned=True):
|
||||
(self.steam / 'steamapps/compatdata').mkdir(parents=True, exist_ok=True)
|
||||
self.shortcut_prefix().symlink_to(target)
|
||||
if owned:
|
||||
imports.save_json(self.steam / 'steamapps' / imports.PREFIX_LINKS,
|
||||
{str(self.shortcut_prefix()): str(target)})
|
||||
|
||||
def test_shortcut_of_a_steam_install_shares_the_steam_apps_prefix(self):
|
||||
game, library = self.steam_install()
|
||||
(self.steam / 'steamapps').mkdir(parents=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
games, routes = imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(([game], {}), (games, routes))
|
||||
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
|
||||
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
|
||||
|
||||
def test_matching_install_prefix_precedes_an_older_prefix_in_another_library(self):
|
||||
game, library = self.steam_install()
|
||||
(self.steam / 'steamapps').mkdir(parents=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
older = self.steam / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser'
|
||||
older.mkdir(parents=True)
|
||||
(older / 'save.dat').write_bytes(b'old')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
|
||||
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
|
||||
self.assertEqual(b'old', (older / 'save.dat').read_bytes())
|
||||
|
||||
def test_an_existing_shortcut_prefix_is_never_replaced(self):
|
||||
game, library = self.steam_install()
|
||||
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
local = self.shortcut_prefix() / 'pfx/drive_c'
|
||||
local.mkdir(parents=True)
|
||||
(local / 'local.dat').write_bytes(b'local')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(self.shortcut_prefix().is_symlink())
|
||||
self.assertEqual(b'local', (local / 'local.dat').read_bytes())
|
||||
self.assertEqual(b'cloud', (library / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser/save.dat').read_bytes())
|
||||
|
||||
def test_shortcuts_without_a_manifest_identity_keep_their_own_prefix(self):
|
||||
game, library = self.steam_install()
|
||||
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
imports.route(self.steam, self.acct, [self.game, dict(game, folder=str(self.folder.parent / 'Other'))])
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
|
||||
def test_a_manifest_without_a_steam_prefix_links_nothing(self):
|
||||
game, library = self.steam_install()
|
||||
shutil.rmtree(library / 'steamapps/compatdata/42')
|
||||
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
|
||||
def test_an_older_prefix_in_another_library_is_not_linked_for_a_steam_install(self):
|
||||
game, library = self.steam_install()
|
||||
shutil.rmtree(library / 'steamapps/compatdata/42')
|
||||
(self.steam / 'steamapps').mkdir(parents=True, exist_ok=True)
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').write_text(f'"libraryfolders"\n{{\n"1" {{ "path" "{library}" }}\n}}\n')
|
||||
(self.steam / 'steamapps/compatdata/42/pfx/drive_c').mkdir(parents=True)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
|
||||
def test_a_dangling_shortcut_prefix_link_is_replaced(self):
|
||||
game, library = self.steam_install()
|
||||
self.link_shortcut_prefix(self.root / 'moved')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
|
||||
|
||||
def test_a_dangling_shortcut_prefix_link_is_removed_without_a_replacement(self):
|
||||
game, library = self.steam_install()
|
||||
shutil.rmtree(library / 'steamapps/compatdata/42')
|
||||
self.link_shortcut_prefix(self.root / 'moved')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
|
||||
def test_a_link_the_user_made_is_never_changed(self):
|
||||
game, library = self.steam_install()
|
||||
for target in (self.root / 'moved', library / 'steamapps/compatdata/42', self.folder):
|
||||
if os.path.lexists(self.shortcut_prefix()):
|
||||
self.shortcut_prefix().unlink()
|
||||
self.link_shortcut_prefix(target, owned=False)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
|
||||
|
||||
def test_a_user_link_to_the_matching_prefix_is_never_recorded_or_removed(self):
|
||||
game, library = self.steam_install()
|
||||
target = library / 'steamapps/compatdata/42'
|
||||
self.link_shortcut_prefix(target, owned=False)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
|
||||
self.assertNotIn(str(self.shortcut_prefix()), imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, {}))
|
||||
shutil.rmtree(target)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertTrue(os.path.islink(self.shortcut_prefix()))
|
||||
self.assertEqual(str(target), os.readlink(self.shortcut_prefix()))
|
||||
|
||||
def test_our_link_survives_a_library_that_is_temporarily_missing(self):
|
||||
game, library = self.steam_install()
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
hidden = self.root / 'Hidden'
|
||||
library.rename(hidden)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertTrue(os.path.islink(self.shortcut_prefix()))
|
||||
hidden.rename(library)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertEqual(library / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
|
||||
self.assertEqual(b'cloud', (self.shortcut_prefix() / 'pfx/drive_c/users/steamuser/save.dat').read_bytes())
|
||||
|
||||
def test_our_link_is_dropped_once_its_prefix_is_deleted(self):
|
||||
game, library = self.steam_install()
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
shutil.rmtree(library / 'steamapps/compatdata/42')
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
self.assertEqual({}, imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, None))
|
||||
|
||||
def test_a_replaced_link_record_is_forgotten_when_the_user_makes_a_real_prefix(self):
|
||||
game, library = self.steam_install()
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.shortcut_prefix().unlink()
|
||||
(self.shortcut_prefix() / 'pfx/drive_c').mkdir(parents=True)
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertFalse(self.shortcut_prefix().is_symlink())
|
||||
self.assertEqual({}, imports.read_json(self.steam / 'steamapps' / imports.PREFIX_LINKS, None))
|
||||
|
||||
def test_a_shortcut_prefix_with_its_own_saves_is_reported_and_kept(self):
|
||||
game, library = self.steam_install()
|
||||
local = self.shortcut_prefix() / 'pfx/drive_c'
|
||||
local.mkdir(parents=True)
|
||||
with patch('builtins.print') as printed:
|
||||
imports.route(self.steam, self.acct, [game])
|
||||
self.assertTrue(local.is_dir())
|
||||
self.assertIn('keeps its own prefix', printed.call_args_list[-1][0][0])
|
||||
|
||||
def test_a_winnative_game_shares_the_prefix_the_steam_client_uses(self):
|
||||
self.winnative_manifest()
|
||||
(self.steam / 'steamapps/libraryfolders.vdf').parent.mkdir(parents=True, exist_ok=True)
|
||||
saves = self.steam / 'steamapps/compatdata/42/pfx/drive_c/users/steamuser'
|
||||
saves.mkdir(parents=True)
|
||||
(saves / 'save.dat').write_bytes(b'cloud')
|
||||
imports.share_prefix(self.steam, self.game)
|
||||
self.assertEqual(self.steam / 'steamapps/compatdata/42', self.shortcut_prefix().resolve())
|
||||
|
||||
def test_an_unreadable_library_does_not_stop_the_routing(self):
|
||||
with patch.object(Path, 'glob', side_effect=PermissionError):
|
||||
games, routes = imports.route(self.steam, self.acct, [self.game])
|
||||
self.assertEqual([self.game], games)
|
||||
self.assertFalse(os.path.lexists(self.shortcut_prefix()))
|
||||
|
||||
def test_store_installs_stay_shortcuts_even_when_owned_on_steam(self):
|
||||
self.snapshot()
|
||||
game = dict(self.game, store='amazon')
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steam-x64'
|
||||
SOURCE = SCRIPT.read_text()
|
||||
LIBRARY_LOOP = re.search(r'^for d in "\$STEAM_X64"/steamrt64/.*?^done\nFEX_ROOTFS=', SOURCE, re.M | re.S).group()
|
||||
LIBRARY_LOOP = LIBRARY_LOOP[:LIBRARY_LOOP.rfind('\nFEX_ROOTFS=')]
|
||||
|
||||
|
||||
class SteamX64RuntimeLibsTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name)
|
||||
self.steam = self.root / 'Steam'
|
||||
self.runtime = self.steam / 'steamrt64/pv-runtime/steam-runtime-steamrt'
|
||||
self.lib = self.runtime / 'steamrt3c_platform_a/files/lib/x86_64-linux-gnu'
|
||||
self.usr_lib = self.runtime / 'steamrt3c_platform_a/files/usr/lib/x86_64-linux-gnu'
|
||||
self.lib.mkdir(parents=True)
|
||||
self.usr_lib.mkdir(parents=True)
|
||||
self.dest = self.root / 'steamrt-libs'
|
||||
self.dest.mkdir()
|
||||
|
||||
def run_loop(self):
|
||||
shell = 'srt_libs="$DEST"\n' + LIBRARY_LOOP
|
||||
env = dict(os.environ, STEAM_X64=str(self.steam), DEST=str(self.dest))
|
||||
return subprocess.run(['bash', '-eu', '-c', shell], env=env, capture_output=True, text=True, timeout=10)
|
||||
|
||||
def test_empty_library_directory_is_skipped(self):
|
||||
(self.usr_lib / 'libexample.so.1').touch()
|
||||
result = self.run_loop()
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertTrue((self.dest / 'libexample.so.1').is_symlink())
|
||||
|
||||
def test_two_platform_versions_with_empty_lib_dirs_use_usr_lib(self):
|
||||
platform_b = self.runtime / 'steamrt3c_platform_b'
|
||||
(platform_b / 'files/lib/x86_64-linux-gnu').mkdir(parents=True)
|
||||
usr_lib_b = platform_b / 'files/usr/lib/x86_64-linux-gnu'
|
||||
usr_lib_b.mkdir(parents=True)
|
||||
(self.usr_lib / 'libexample.so.1').touch()
|
||||
(usr_lib_b / 'libother.so.1').touch()
|
||||
result = self.run_loop()
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertTrue((self.dest / 'libexample.so.1').is_symlink())
|
||||
self.assertTrue((self.dest / 'libother.so.1').is_symlink())
|
||||
|
||||
def test_stale_literal_glob_link_does_not_abort(self):
|
||||
(self.dest / '*.so*').symlink_to('/missing/*.so*')
|
||||
result = self.run_loop()
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertTrue((self.dest / '*.so*').is_symlink())
|
||||
|
||||
def test_existing_dangling_library_link_is_not_recreated(self):
|
||||
(self.lib / 'libexample.so.1').touch()
|
||||
(self.dest / 'libexample.so.1').symlink_to('/missing/libexample.so.1')
|
||||
result = self.run_loop()
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('/missing/libexample.so.1', os.readlink(self.dest / 'libexample.so.1'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -797,3 +797,102 @@ class GogRegistry(unittest.TestCase):
|
||||
store.main([str(folder / store.LAUNCHER)])
|
||||
apply.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
|
||||
support.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
|
||||
|
||||
|
||||
class Ubisoft(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.root = Path(self.tmp.name)
|
||||
self.compat_data = self.root / 'compatdata/2929927072'
|
||||
(self.compat_data / 'pfx').mkdir(parents=True)
|
||||
(self.compat_data / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n')
|
||||
(self.compat_data / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
|
||||
self.folder = self.root / 'Games/Stores/Ubisoft/Splinter Cell'
|
||||
(self.folder / 'system').mkdir(parents=True)
|
||||
self.sidecar = {'store': 'ubisoft', 'id': 'space-1', 'exe': 'system/SplinterCell.exe', 'extra': {'productId': '109'}}
|
||||
service = self.root / 'droiddeck-upc.exe'
|
||||
service.write_bytes(b'MZ')
|
||||
for patcher in (patch.object(store, 'UBISOFT_SERVICE', service), patch.object(store, 'UBISOFT_CACHE', self.root / 'cache'),
|
||||
patch.object(store, 'wait_for_server', return_value=True)):
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def tearDown(self):
|
||||
self.tmp.cleanup()
|
||||
|
||||
def runtime(self):
|
||||
folder = store.ubisoft_runtime_dir(self.compat_data)
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
for name in store.UBISOFT_RUNTIME:
|
||||
(folder / name).write_bytes(b'MZ')
|
||||
|
||||
def answer(self, *_args, **_kwargs):
|
||||
return {'ok': True, 'ticket': 'PC', 'owned': [82, 109], 'appId': 'app',
|
||||
'account': {'userId': 'u1', 'username': 'name', 'nameOnPlatform': 'name', 'email': 'e@x', 'country': 'US'}}
|
||||
|
||||
def prepare(self, ask_app):
|
||||
return store.prepare_ubisoft(self.folder, self.sidecar, str(self.compat_data), str(self.root / 'launch'), '/proton', ask_app=ask_app)
|
||||
|
||||
def test_an_extracted_runtime_is_not_extracted_again(self):
|
||||
self.runtime()
|
||||
with patch.object(store.subprocess, 'run') as run:
|
||||
self.assertEqual('present', store.install_runtime(str(self.compat_data)))
|
||||
run.assert_not_called()
|
||||
|
||||
def test_the_runtime_comes_from_the_installer_through_7z(self):
|
||||
installer = self.root / 'UbisoftConnectInstaller.exe'
|
||||
|
||||
def run(command, **_kwargs):
|
||||
self.assertEqual(['7z', 'e', '-y'], command[:3])
|
||||
self.assertEqual(str(installer), command[4])
|
||||
out = Path(command[3][2:])
|
||||
for name in command[5:]:
|
||||
(out / name).write_bytes(b'MZ')
|
||||
|
||||
(self.root / 'cache').mkdir()
|
||||
with patch.object(store, 'fetch_installer', return_value=installer), patch.object(store.subprocess, 'run', side_effect=run):
|
||||
self.assertEqual('installed', store.install_runtime(str(self.compat_data)))
|
||||
self.assertTrue(store.ubisoft_runtime_ready(str(self.compat_data)))
|
||||
|
||||
def test_a_launch_registers_the_game_and_writes_the_session_for_the_service(self):
|
||||
self.runtime()
|
||||
result = self.prepare(self.answer)
|
||||
self.assertEqual('runtime present, registered 109, 0 manifest value(s), session ready', result)
|
||||
reg = (self.compat_data / 'pfx/system.reg').read_text()
|
||||
for view in ('[Software\\\\Ubisoft\\\\Launcher]', '[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher]'):
|
||||
self.assertIn(view, reg)
|
||||
self.assertIn('[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher\\\\Installs\\\\109]', reg)
|
||||
self.assertIn('"InstallDir"="C:\\\\Program Files (x86)\\\\Ubisoft\\\\Ubisoft Game Launcher\\\\"', reg)
|
||||
launch = json.loads((self.folder / store.UBISOFT_LAUNCH).read_text())
|
||||
self.assertEqual(109, launch['productId'])
|
||||
self.assertEqual('PC', launch['ticket'])
|
||||
self.assertEqual([82, 109], launch['owned'])
|
||||
self.assertEqual(store.windows_path(str(self.folder / 'system/SplinterCell.exe')), launch['exe'])
|
||||
self.assertEqual('C:/users/steamuser/Saved Games/Ubisoft/u1/109/', launch['saves'])
|
||||
self.assertTrue((self.compat_data / 'pfx/drive_c/users/steamuser/Saved Games/Ubisoft/u1/109').is_dir())
|
||||
|
||||
def test_without_a_session_the_launch_file_is_removed_and_the_game_starts_as_is(self):
|
||||
self.runtime()
|
||||
(self.folder / store.UBISOFT_LAUNCH).write_text('{}')
|
||||
result = self.prepare(lambda *_a, **_k: {'ok': False, 'reason': 'signed-out'})
|
||||
self.assertEqual('runtime present, registered 109, session signed-out', result)
|
||||
self.assertFalse((self.folder / store.UBISOFT_LAUNCH).exists())
|
||||
|
||||
def test_a_game_without_a_product_is_left_alone(self):
|
||||
self.sidecar['extra'] = {}
|
||||
self.assertEqual('no-product', self.prepare(self.answer))
|
||||
|
||||
def test_the_manifest_registry_lands_in_both_views_with_the_install_folder_and_language(self):
|
||||
self.runtime()
|
||||
registry = [{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Launcher\Installs\109\Language',
|
||||
'values': [{'name': 'French', 'value': 'fr-FR'}, {'name': 'English', 'value': 'en-US'}]},
|
||||
{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Splinter Cell\GamePath', 'values': [{'name': '$INSTALL_DIR', 'value': ''}]}]
|
||||
answer = dict(self.answer(), registry=registry, language='en-US')
|
||||
result = self.prepare(lambda *_a, **_k: answer)
|
||||
self.assertEqual('runtime present, registered 109, 4 manifest value(s), session ready', result)
|
||||
reg = (self.compat_data / 'pfx/system.reg').read_text()
|
||||
self.assertIn(r'[SOFTWARE\\Wow6432Node\\Ubisoft\\Launcher\\Installs\\109]', reg)
|
||||
self.assertIn(r'[SOFTWARE\\Ubisoft\\Launcher\\Installs\\109]', reg)
|
||||
self.assertIn('"Language"="en-US"', reg)
|
||||
folder = store.windows_path(str(self.folder)).replace('\\', '\\\\')
|
||||
self.assertIn('"GamePath"="%s\\\\"' % folder, reg)
|
||||
@@ -0,0 +1,175 @@
|
||||
import base64
|
||||
import importlib.machinery
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
||||
loader = importlib.machinery.SourceFileLoader('droiddeck_store_launch_ea', str(BIN / 'droiddeck-store-launch'))
|
||||
spec = importlib.util.spec_from_loader(loader.name, loader)
|
||||
store = importlib.util.module_from_spec(spec)
|
||||
loader.exec_module(store)
|
||||
|
||||
|
||||
class EaHook(unittest.TestCase):
|
||||
def test_wmi_output_reads_the_value_under_the_header(self):
|
||||
text = 'Manufacturer \r\r\nThe Wine Project \r\r\n\r\r\n'
|
||||
self.assertEqual(store.wmi_value(text), 'The Wine Project')
|
||||
self.assertEqual(store.wmi_value(store.decode_output('Name\r\nFEX CPU\r\n'.encode('utf-16'))), 'FEX CPU')
|
||||
self.assertEqual(store.wmi_value(''), '')
|
||||
|
||||
def test_registry_points_the_game_keys_at_the_install_folder(self):
|
||||
sidecar = {'id': 'Origin.OFR.50.0001', 'title': 'Mass Effect 3', 'extra': {'registry': json.dumps([
|
||||
[r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', 'Install Dir'],
|
||||
[r'HKLM\SOFTWARE\Respawn\Titanfall2', 'Install Dir'],
|
||||
[r'HKEY_CLASSES_ROOT\x', 'y'],
|
||||
])}}
|
||||
entries = store.ea_registry_entries(Path('/root/Games/Stores/EA/Game'), sidecar)
|
||||
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\Origin', 'ClientPath', store.EA_CLIENT), entries)
|
||||
game = [e for e in entries if e[1] == 'Install Dir']
|
||||
self.assertEqual([e[0] for e in game], [r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', r'HKEY_LOCAL_MACHINE\SOFTWARE\Respawn\Titanfall2'])
|
||||
self.assertEqual(game[0][2], 'Z:' + '\\'.join(['', 'root', 'Games', 'Stores', 'EA', 'Game', '']))
|
||||
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\EA Games\Game', 'DisplayName', 'Mass Effect 3'), entries)
|
||||
self.assertIn((r'HKEY_LOCAL_MACHINE\SOFTWARE\Respawn\Titanfall2', 'DisplayName', 'Mass Effect 3'), entries)
|
||||
|
||||
def test_the_games_exe_maps_to_its_launcher_only(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
folder = Path(tmp) / 'Game'
|
||||
(folder / 'bin').mkdir(parents=True)
|
||||
for name in ('bin/Game.exe', 'bin/Other.exe', store.LAUNCHER):
|
||||
(folder / name).write_text('x')
|
||||
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'bin/Game.exe', 'launcher': store.LAUNCHER}
|
||||
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
||||
self.assertEqual(store.store_launcher(str(folder / 'bin/Game.exe')), str(folder / store.LAUNCHER))
|
||||
self.assertEqual(store.store_launcher(str(folder / 'bin/game.exe')), str(folder / store.LAUNCHER))
|
||||
self.assertIsNone(store.store_launcher(str(folder / 'bin/Other.exe')))
|
||||
self.assertIsNone(store.store_launcher(str(Path(tmp) / 'Elsewhere.exe')))
|
||||
(folder / store.SIDECAR).write_text(json.dumps(dict(sidecar, launcher='')))
|
||||
self.assertIsNone(store.store_launcher(str(folder / 'bin/Game.exe')))
|
||||
|
||||
def test_a_symlinked_or_deep_exe_still_finds_its_launcher(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
folder = Path(tmp) / 'Game'
|
||||
deep = folder / 'a/b/c/d/e/f'
|
||||
deep.mkdir(parents=True)
|
||||
(deep / 'Game.exe').write_text('x')
|
||||
(folder / store.LAUNCHER).write_text('x')
|
||||
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'a/b/c/d/e/f/Game.exe', 'launcher': store.LAUNCHER}
|
||||
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
||||
link = Path(tmp) / 'x/y/z/Link.exe'
|
||||
link.parent.mkdir(parents=True)
|
||||
link.symlink_to(deep / 'Game.exe')
|
||||
expected = str(folder.resolve() / store.LAUNCHER)
|
||||
self.assertEqual(store.store_launcher(str(deep / 'Game.exe')), expected)
|
||||
self.assertEqual(store.store_launcher(str(link)), expected)
|
||||
self.assertIsNone(store.find_store_game([str(deep / 'Game.exe')]))
|
||||
|
||||
def test_a_symlinked_exe_finds_the_sidecar_beside_the_link(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
outside = Path(tmp) / 'Real/Game.exe'
|
||||
outside.parent.mkdir()
|
||||
outside.write_text('x')
|
||||
folder = Path(tmp) / 'Game'
|
||||
folder.mkdir()
|
||||
(folder / store.LAUNCHER).write_text('x')
|
||||
(folder / 'Game.exe').symlink_to(outside)
|
||||
sidecar = {'store': 'ea', 'id': 'Origin.OFR.50.1', 'exe': 'Game.exe', 'launcher': store.LAUNCHER}
|
||||
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
||||
self.assertEqual(store.store_launcher(str(folder / 'Game.exe')), str(folder / store.LAUNCHER))
|
||||
self.assertIsNone(store.store_launcher(str(outside)))
|
||||
|
||||
def test_legacy_games_are_registered_by_content_id(self):
|
||||
sidecar = {'id': 'Origin.OFR.50.0005237', 'title': 'Mass Effect 3 (2012)',
|
||||
'extra': {'contentIds': '71073,71183, bad id', 'displayName': 'Mass Effect 3', 'locale': 'fr_FR'}}
|
||||
entries = store.ea_registry_entries(Path('/root/Games/ME3'), sidecar)
|
||||
key = r'HKEY_LOCAL_MACHINE\SOFTWARE\Origin Games' + '\\'
|
||||
self.assertIn((key + '71073', 'DisplayName', 'Mass Effect 3'), entries)
|
||||
self.assertIn((key + '71183', 'Locale', 'fr_FR'), entries)
|
||||
self.assertFalse(any('bad id' in e[0] for e in entries))
|
||||
|
||||
def test_cpuid_probe_is_a_32_bit_console_program(self):
|
||||
import struct
|
||||
exe = store.cpuid_exe()
|
||||
self.assertEqual(exe[:2], b'MZ')
|
||||
self.assertEqual(exe[0x40:0x44], b'PE\0\0')
|
||||
self.assertEqual(struct.unpack_from('<H', exe, 0x44)[0], 0x14C)
|
||||
self.assertEqual(struct.unpack_from('<H', exe, 0x58)[0], 0x10B)
|
||||
self.assertEqual(struct.unpack_from('<H', exe, 0x58 + 68)[0], 3)
|
||||
self.assertIn(b'KERNEL32.dll', exe)
|
||||
self.assertEqual(len(exe), 0x400)
|
||||
|
||||
def test_origin_stub_is_a_windowless_program_installed_once(self):
|
||||
import struct
|
||||
exe = store.origin_stub_exe()
|
||||
self.assertEqual(exe[:2], b'MZ')
|
||||
self.assertEqual(struct.unpack_from('<H', exe, 0x58 + 68)[0], 2)
|
||||
self.assertIn(b'Sleep', exe)
|
||||
self.assertEqual(exe[0x208:0x20A], b'\xeb\xf6')
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
self.assertEqual(store.install_origin_stub(tmp), 'written')
|
||||
self.assertEqual(store.install_origin_stub(tmp), 'ready')
|
||||
self.assertTrue((Path(tmp) / 'pfx/drive_c/Program Files (x86)/Origin/Origin.exe').is_file())
|
||||
self.assertTrue(store.EA_CLIENT.endswith('Origin.exe'))
|
||||
|
||||
def test_cpuid_output_is_decoded_as_the_game_sees_it(self):
|
||||
raw = bytes.fromhex('1600000047656e756e74656c696e654961060a00000805000f23d882fffb8b27436f727465782d4135323000000000000000000000000000000000000000000000000000000000000000000000000000')
|
||||
self.assertEqual(store.cpuid_values(raw), {'cpuVendor': 'GenuineIntel', 'cpuEax': '000A0661', 'cpuEdx': '278BFBFF',
|
||||
'cpuEcx': '82d8230f', 'cpuBrand': 'Cortex-A520'})
|
||||
self.assertEqual(store.cpuid_values(b''), {})
|
||||
|
||||
def test_touchup_arguments_fill_locale_and_folder(self):
|
||||
install = r'Z:\root\My Game'
|
||||
args = store.touchup_args('-locale {locale} -installPath "{installLocation}" /silent', 'fr_FR', install)
|
||||
self.assertEqual(args, ['-locale', 'fr_FR', '-installPath', install, '/silent'])
|
||||
|
||||
def test_licences_stay_inside_the_prefix(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
data = base64.b64encode(b'licence').decode()
|
||||
written = store.write_licenses(tmp, [
|
||||
{'path': 'ProgramData/Electronic Arts/EA Services/License/X.dlf', 'data': data},
|
||||
{'path': '../escape.dlf', 'data': data},
|
||||
{'path': '/abs.dlf', 'data': data},
|
||||
])
|
||||
self.assertEqual(written, 1)
|
||||
self.assertEqual((Path(tmp) / 'pfx/drive_c/ProgramData/Electronic Arts/EA Services/License/X.dlf').read_bytes(), b'licence')
|
||||
|
||||
def test_prepare_asks_the_app_and_writes_the_licence(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
compat = Path(tmp) / 'compat'
|
||||
(compat / 'pfx').mkdir(parents=True)
|
||||
(compat / 'pfx/user.reg').write_text('')
|
||||
probe = {key: 'x' for key in store.EA_PROBE_FIELDS}
|
||||
(compat / 'pfx' / store.EA_HARDWARE).write_text(json.dumps(probe))
|
||||
folder = Path(tmp) / 'game'
|
||||
folder.mkdir()
|
||||
asked = {}
|
||||
|
||||
def fake_ask(channel, request, timeout=5.0):
|
||||
asked.update(request)
|
||||
return {'ok': True, 'lsx': True, 'license': 'ok v4', 'licenses': [{'path': 'ProgramData/L/x.dlf', 'data': base64.b64encode(b'z').decode()}]}
|
||||
|
||||
with patch.object(store, 'ask', fake_ask), patch.object(store, 'ea_registry', lambda *a, **k: 'ready'), \
|
||||
patch.object(store, 'ea_touchup', lambda *a, **k: 'none'), patch.dict('os.environ', {'BL_STORE_PROTON': ''}):
|
||||
store.prepare_ea(folder, {'id': 'Origin.OFR.1'}, str(compat), str(Path(tmp) / 'launch'))
|
||||
self.assertEqual(asked['op'], 'ea-prepare')
|
||||
self.assertEqual(asked['hardware'], probe)
|
||||
self.assertEqual((compat / 'pfx/drive_c/ProgramData/L/x.dlf').read_bytes(), b'z')
|
||||
|
||||
def test_an_incomplete_cached_probe_is_probed_again(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
pfx = Path(tmp) / 'pfx'
|
||||
pfx.mkdir()
|
||||
partial = {key: 'x' for key in store.EA_PROBE_FIELDS if key != 'osInstallDate'}
|
||||
(pfx / store.EA_HARDWARE).write_text(json.dumps(partial))
|
||||
self.assertFalse(store.probe_complete(partial))
|
||||
self.assertEqual(store.ea_hardware(tmp, ''), ({}, 'no-proton'))
|
||||
whole = dict(partial, osInstallDate='20261108')
|
||||
(pfx / store.EA_HARDWARE).write_text(json.dumps(whole))
|
||||
self.assertEqual(store.ea_hardware(tmp, ''), (whole, 'cached'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,197 @@
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from test_store_launch import store
|
||||
|
||||
|
||||
class RockstarLaunch(unittest.TestCase):
|
||||
def test_service_directory_cannot_export_sessions_outside_the_prefix(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder, sidecar, prefix, _, _ = self.setup_game(root)
|
||||
outside = Path(root) / 'outside'
|
||||
outside.mkdir()
|
||||
target = prefix / 'pfx' / store.ROCKSTAR_FOLDER
|
||||
target.parent.mkdir(parents=True)
|
||||
target.symlink_to(outside, target_is_directory=True)
|
||||
sentinel = outside / 'launch.json'
|
||||
sentinel.write_text('keep')
|
||||
with patch.object(store, 'ask') as ask:
|
||||
self.assertEqual('invalid-service-path', store.prepare_rockstar(folder, sidecar, prefix, 'channel'))
|
||||
ask.assert_not_called()
|
||||
self.assertEqual('keep', sentinel.read_text())
|
||||
|
||||
def test_sdk_registration_does_not_use_an_untrusted_display_name_as_a_key(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder, _, prefix, _, _ = self.setup_game(root)
|
||||
with patch.object(store, 'wait_for_server', return_value=True):
|
||||
self.assertTrue(store.rockstar_registry(folder, None, prefix, '', sdk_arch='x64'))
|
||||
text = (prefix / 'pfx/system.reg').read_text()
|
||||
self.assertIn(r'[Software\\Rockstar Games\\Rockstar Games Social Club]', text)
|
||||
self.assertNotIn('Grand Theft Auto', text)
|
||||
|
||||
def test_root_metadata_is_found_after_many_assets(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder = Path(root)
|
||||
for index in range(300):
|
||||
(folder / ('asset-%s.dat' % index)).write_bytes(b'asset')
|
||||
(folder / 'title.rgl').write_bytes(b'RGLM' + bytes(108))
|
||||
self.assertTrue(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
|
||||
(folder / 'title.rgl').unlink()
|
||||
(folder / 'Title.RGL').write_bytes(b'RGLM' + bytes(108))
|
||||
self.assertTrue(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
|
||||
|
||||
def test_sdk_titles_receive_only_their_short_lived_game_session(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
def change(values):
|
||||
folder, sidecar, _, _, answer = values
|
||||
sidecar['id'] = 'future_title'
|
||||
(folder / 'socialclub.dll').write_bytes(b'game-runtime')
|
||||
answer['session'] = {'accountId': '123', 'identity': 'player@example.invalid', 'ticket': 'game-session',
|
||||
'ScAuthToken': 'never-export-refresh-token'}
|
||||
result, path, _ = self.prepare(root, change)
|
||||
self.assertEqual('ready', result)
|
||||
data = json.loads(path.read_text())
|
||||
self.assertEqual({'accountId', 'identity', 'ticket'}, set(data['session']))
|
||||
self.assertNotIn('pipe', data)
|
||||
self.assertNotIn('material', data)
|
||||
self.assertNotIn('never-export-refresh-token', path.read_text())
|
||||
self.assertEqual(0o600, path.stat().st_mode & 0o777)
|
||||
|
||||
def test_invalid_sdk_sessions_cannot_reuse_an_old_handoff(self):
|
||||
for session in (None, {'accountId': '0', 'identity': 'player', 'ticket': 'session'},
|
||||
{'accountId': '123', 'identity': 'player', 'ticket': 'bad\0session'}):
|
||||
with self.subTest(session=session), tempfile.TemporaryDirectory() as root:
|
||||
def change(values):
|
||||
folder, sidecar, _, _, answer = values
|
||||
sidecar['id'] = 'future_title'
|
||||
(folder / 'socialclub.dll').write_bytes(b'game-runtime')
|
||||
answer['session'] = session
|
||||
result, path, _ = self.prepare(root, change)
|
||||
self.assertEqual('invalid-sdk-session', result)
|
||||
self.assertFalse(path.exists())
|
||||
|
||||
def test_sdk_detection_does_not_follow_external_metadata(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder = Path(root) / 'game'
|
||||
folder.mkdir()
|
||||
metadata = Path(root) / 'outside.rgl'
|
||||
metadata.write_bytes(b'RGLM' + bytes(108))
|
||||
(folder / 'title.rgl').symlink_to(metadata)
|
||||
self.assertFalse(store.rockstar_sdk(folder, {'id': 'future_title', 'exe': 'Game.exe'}))
|
||||
|
||||
def test_sdk_installer_cannot_escape_its_architecture_folder(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder = Path(root) / 'game'
|
||||
installer = folder / 'Installers/Social-Club-Setup.exe'
|
||||
installer.parent.mkdir(parents=True)
|
||||
installer.write_bytes(b'installer')
|
||||
listing = type('Listing', (), {'returncode': 0, 'stdout': b'Path = x64/../../outside.dll\nSize = 1\n'})()
|
||||
with patch.object(store.shutil, 'which', return_value='/bin/7z'), patch.object(store.subprocess, 'run', return_value=listing):
|
||||
with self.assertRaises(ValueError):
|
||||
store.rockstar_runtime(folder, folder / 'Game.exe', str(Path(root) / 'prefix'), 'x64')
|
||||
self.assertFalse((Path(root) / 'outside.dll').exists())
|
||||
|
||||
def test_other_titles_can_launch_without_the_classic_pipe_service(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder = Path(root)
|
||||
sidecar = {'store': 'rockstar', 'id': 'rdr2', 'exe': 'RDR2.exe'}
|
||||
with patch.object(store, 'find_store_game', return_value=(folder, sidecar)), \
|
||||
patch.object(store, 'prepare_rockstar') as prepare, \
|
||||
patch.object(store, 'ask') as ask, patch.dict(os.environ, {}, clear=True):
|
||||
self.assertEqual(store.STORE_GAME, store.main([str(folder / 'RDR2.exe')]))
|
||||
prepare.assert_not_called()
|
||||
ask.assert_not_called()
|
||||
|
||||
def test_classic_authentication_failure_still_stops_launch(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder = Path(root)
|
||||
sidecar = {'store': 'rockstar', 'id': 'gtavc', 'exe': 'gta-vc.exe'}
|
||||
with patch.object(store, 'find_store_game', return_value=(folder, sidecar)), \
|
||||
patch.object(store, 'prepare_rockstar', return_value='session-not-owned'), \
|
||||
patch.dict(os.environ, {}, clear=True):
|
||||
self.assertEqual(store.RAN_FAILED, store.main([str(folder / 'gta-vc.exe')]))
|
||||
|
||||
def setup_game(self, root):
|
||||
folder = Path(root) / 'game'
|
||||
folder.mkdir()
|
||||
exe = bytearray(128)
|
||||
exe[:2] = b'MZ'
|
||||
exe[0x3c:0x40] = (64).to_bytes(4, 'little')
|
||||
exe[64:70] = b'PE\0\0\x4c\x01'
|
||||
(folder / 'gta-vc.exe').write_bytes(exe)
|
||||
(folder / 'MTLX.dll').write_bytes(b'vendor')
|
||||
prefix = Path(root) / 'prefix'
|
||||
(prefix / 'pfx').mkdir(parents=True)
|
||||
(prefix / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
|
||||
(prefix / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n')
|
||||
service = Path(root) / 'service'
|
||||
service.mkdir()
|
||||
(service / 'Launcher32.exe').write_bytes(b'compiled-helper')
|
||||
sidecar = {'store': 'rockstar', 'id': 'gtavc', 'exe': 'gta-vc.exe', 'args': ['one argument', '&literal']}
|
||||
answer = {'ok': True, 'pipe': 'GTA-VC_Pipe', 'material': 'A' * 640,
|
||||
'expiresAt': int(time.time() * 1000) + 90000, 'ticket': 'must-not-be-exported'}
|
||||
return folder, sidecar, prefix, service, answer
|
||||
|
||||
def prepare(self, root, modify=lambda values: None):
|
||||
values = self.setup_game(root)
|
||||
modify(values)
|
||||
folder, sidecar, prefix, service, answer = values
|
||||
config = prefix / 'pfx' / store.ROCKSTAR_FOLDER / 'launch.json'
|
||||
config.parent.mkdir(parents=True)
|
||||
config.write_text('stale')
|
||||
requests = []
|
||||
|
||||
def ask(channel, request, timeout):
|
||||
requests.append(request)
|
||||
return answer
|
||||
|
||||
with patch.object(store, 'ROCKSTAR_SERVICE', service), patch.object(store, 'rockstar_registry', return_value=True):
|
||||
result = store.prepare_rockstar(folder, sidecar, str(prefix), str(Path(root) / 'channel'), ask_app=ask)
|
||||
return result, config, requests
|
||||
|
||||
def test_handoff_contains_only_launch_fields_and_preserves_argument_boundaries(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
result, path, requests = self.prepare(root)
|
||||
self.assertEqual('ready', result)
|
||||
data = json.loads(path.read_text())
|
||||
self.assertEqual({'folder', 'exe', 'workdir', 'args', 'pipe', 'material', 'expiresAt'}, set(data))
|
||||
self.assertEqual(['one argument', '&literal'], data['args'])
|
||||
self.assertNotIn('must-not-be-exported', path.read_text())
|
||||
self.assertEqual('rockstar-launch', requests[0]['op'])
|
||||
self.assertEqual(b'compiled-helper', path.with_name('Launcher.exe').read_bytes())
|
||||
|
||||
def test_rejected_or_expired_sessions_cannot_reuse_stale_material(self):
|
||||
for update in ({'ok': False, 'reason': 'not-owned'}, {'material': 'A' * 641}, {'expiresAt': 1}):
|
||||
with self.subTest(update=update), tempfile.TemporaryDirectory() as root:
|
||||
result, config, _ = self.prepare(root, lambda values: values[4].update(update))
|
||||
self.assertNotEqual('ready', result)
|
||||
self.assertFalse(config.exists())
|
||||
|
||||
def test_path_escape_does_not_request_account_data(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
def change(values):
|
||||
(Path(root) / 'outside.exe').write_bytes(b'MZ')
|
||||
values[1]['exe'] = '../outside.exe'
|
||||
result, config, requests = self.prepare(root, change)
|
||||
self.assertEqual('invalid-game-path', result)
|
||||
self.assertEqual([], requests)
|
||||
self.assertFalse(config.exists())
|
||||
|
||||
def test_writes_both_registry_views_and_escapes_values(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
folder, _, prefix, _, _ = self.setup_game(root)
|
||||
with patch.object(store, 'wait_for_server', return_value=True):
|
||||
self.assertTrue(store.rockstar_registry(folder, 'Grand Theft Auto: Vice City', prefix, ''))
|
||||
text = (prefix / 'pfx/system.reg').read_text()
|
||||
self.assertIn(r'[Software\\Rockstar Games\\Launcher]', text)
|
||||
self.assertIn(r'[Software\\Wow6432Node\\Rockstar Games\\Launcher]', text)
|
||||
self.assertIn('Grand Theft Auto: Vice City', text)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -1,7 +1,9 @@
|
||||
import unittest
|
||||
|
||||
from tools.release.update_catalog import (
|
||||
Cache,
|
||||
asset_for_suffix,
|
||||
merged_pr,
|
||||
ci_description,
|
||||
parse_gradle,
|
||||
parse_variants,
|
||||
@@ -10,6 +12,7 @@ from tools.release.update_catalog import (
|
||||
recent_previews,
|
||||
release_body_value,
|
||||
stable_app_release,
|
||||
unique_previews,
|
||||
)
|
||||
|
||||
|
||||
@@ -149,6 +152,25 @@ pubg com.tencent.ig -pubg
|
||||
self.assertEqual("0.2.0", stable_app_release(releases)["tag_name"])
|
||||
self.assertIsNone(stable_app_release(releases[:1]))
|
||||
|
||||
def test_merged_pr_comes_from_the_first_paragraph(self):
|
||||
body = "**Merged to main** - [PR #2602](https://github.com/Droid-Deck/DroidDeck/pull/2602): fix: x\n\nSee [PR #9](u)."
|
||||
self.assertEqual(2602, merged_pr({"body": body}))
|
||||
self.assertEqual(0, merged_pr({"body": "**Pushed to main** without a PR - fix: x"}))
|
||||
|
||||
def test_previews_follow_commit_order_not_publish_order(self):
|
||||
older = {"commit": "a" * 40, "committedAt": 100, "publishedAt": 900}
|
||||
newer = {"commit": "b" * 40, "committedAt": 200, "publishedAt": 300}
|
||||
again = {**newer, "publishedAt": 50}
|
||||
self.assertEqual([newer, older], unique_previews([older, again, newer]))
|
||||
|
||||
def test_cache_reuses_commit_facts_from_the_last_catalog(self):
|
||||
class NoNetwork:
|
||||
def get(self, path):
|
||||
raise AssertionError(path)
|
||||
|
||||
cache = Cache({"previews": [{"commit": "A" * 40, "author": "dev", "committedAt": 5}]})
|
||||
self.assertEqual({"author": "dev", "committedAt": 5}, cache.commit(NoNetwork(), "o/r", "a" * 40))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,66 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
||||
|
||||
PROGRAM = r"""
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
int unsetenv(const char *name) { return -1; }
|
||||
int setenv(const char *name, const char *value, int overwrite) { return -1; }
|
||||
int putenv(char *string) { return -1; }
|
||||
int main(void) {
|
||||
const char *names[] = {"LIBGL_KOPPER_DISABLE", "LIBGL_KOPPER_DISABLE_X", "ZINK_DEBUG", "VN_DEBUG"};
|
||||
for (int i = 0; i < 4; i++) {
|
||||
const char *value = getenv(names[i]);
|
||||
printf("%s=%s\n", names[i], value ? value : "(unset)");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("cc"), "needs cc")
|
||||
class VenusPreloadTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.tmp = Path(tempfile.mkdtemp())
|
||||
source = cls.tmp / "program.c"
|
||||
source.write_text(PROGRAM)
|
||||
cls.program = cls.tmp / "program"
|
||||
cls.library = cls.tmp / "libvenus.so"
|
||||
subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-o", str(cls.program), str(source)], check=True)
|
||||
subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-shared", "-fPIC", "-o", str(cls.library),
|
||||
str(PRELOAD / "venus.c")], check=True)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
shutil.rmtree(cls.tmp, ignore_errors=True)
|
||||
|
||||
def values(self, **extra):
|
||||
env = {"PATH": os.environ.get("PATH", ""), "LD_PRELOAD": str(self.library), **extra}
|
||||
result = subprocess.run([str(self.program)], env=env, capture_output=True, text=True, check=True)
|
||||
return dict(line.split("=", 1) for line in result.stdout.splitlines())
|
||||
|
||||
def test_kopper_is_kept_when_environment_changes_are_refused(self):
|
||||
values = self.values(VN_DEBUG="vtest", LIBGL_KOPPER_DISABLE="true", LIBGL_KOPPER_DISABLE_X="1",
|
||||
ZINK_DEBUG="mem")
|
||||
self.assertEqual(values["LIBGL_KOPPER_DISABLE"], "(unset)")
|
||||
self.assertEqual(values["LIBGL_KOPPER_DISABLE_X"], "1")
|
||||
self.assertEqual(values["ZINK_DEBUG"], "mem")
|
||||
self.assertEqual(values["VN_DEBUG"], "vtest")
|
||||
|
||||
def test_other_sessions_keep_kopper_disabled(self):
|
||||
self.assertEqual(self.values(LIBGL_KOPPER_DISABLE="true")["LIBGL_KOPPER_DISABLE"], "true")
|
||||
self.assertEqual(self.values(VN_DEBUG="init", LIBGL_KOPPER_DISABLE="true")["LIBGL_KOPPER_DISABLE"], "true")
|
||||
|
||||
def test_absent_variable_is_harmless(self):
|
||||
self.assertEqual(self.values(VN_DEBUG="vtest")["LIBGL_KOPPER_DISABLE"], "(unset)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,267 @@
|
||||
import ctypes
|
||||
import mmap
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_clock_pause_preload import clock_reset_command
|
||||
from tools.tests.test_output_refresh import extract_function as extract_void_function
|
||||
from tools.tests.test_scene_limit_hold import extract_function
|
||||
|
||||
SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/waylandcomp/src/clock_domain.c"
|
||||
HEADER = SOURCE.with_suffix(".h")
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
|
||||
class WaylandClockDomainTest(unittest.TestCase):
|
||||
def test_host_timestamp_uses_the_guest_domain(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld %u %lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL), '
|
||||
' droiddeck_clock_domain_now_ms(), (long long)droiddeck_clock_domain_adjust_ns(5LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control)], capture_output=True, text=True, check=True)
|
||||
adjusted, now_ms, clamped = map(int, result.stdout.split())
|
||||
self.assertEqual(adjusted, 20_000_000_000)
|
||||
self.assertGreaterEqual(now_ms, 0)
|
||||
self.assertLessEqual(now_ms, 0xFFFFFFFF)
|
||||
self.assertEqual(clamped, 0)
|
||||
|
||||
def test_paced_release_uses_kernel_time_across_pause_offsets(self):
|
||||
compositor = SOURCE.with_name("compositor.c").read_text()
|
||||
functions = extract_function(compositor, "now_ns") + "\n" + extract_void_function(compositor, "arm_release_timer")
|
||||
harness = r'''
|
||||
#define _GNU_SOURCE
|
||||
#include <assert.h>
|
||||
#include <fcntl.h>
|
||||
#include <poll.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/timerfd.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "clock_domain.h"
|
||||
|
||||
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; };
|
||||
static struct pending_release *g_pending_releases;
|
||||
static int g_release_timer_fd;
|
||||
#define wl_list_for_each(pr, list, link) for (pr = *(list); pr; pr = pr->next)
|
||||
static int buffer_release_blocked(void *buffer) { return buffer != NULL; }
|
||||
|
||||
@FUNCTIONS@
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
(void)argc;
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
int control = open(argv[1], O_WRONLY);
|
||||
assert(control >= 0);
|
||||
g_release_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
|
||||
assert(g_release_timer_fd >= 0);
|
||||
const int64_t offsets[] = {0, 10000000000LL, 300000000000LL};
|
||||
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
|
||||
assert(pwrite(control, &offsets[i], sizeof(offsets[i]), 0) == sizeof(offsets[i]));
|
||||
struct timespec started, ended;
|
||||
clock_gettime(CLOCK_MONOTONIC, &started);
|
||||
int64_t start = now_ns();
|
||||
struct pending_release blocked = {(void *)1, start + 1000000LL, NULL};
|
||||
struct pending_release release = {NULL, start + 60000000LL, &blocked};
|
||||
g_pending_releases = &release;
|
||||
arm_release_timer();
|
||||
int64_t next_offset = offsets[i] + 10000000000LL;
|
||||
assert(pwrite(control, &next_offset, sizeof(next_offset), 0) == sizeof(next_offset));
|
||||
struct pollfd pollfd = {g_release_timer_fd, POLLIN, 0};
|
||||
assert(poll(&pollfd, 1, 1000) == 1);
|
||||
clock_gettime(CLOCK_MONOTONIC, &ended);
|
||||
int64_t elapsed = (ended.tv_sec - started.tv_sec) * 1000000000LL + ended.tv_nsec - started.tv_nsec;
|
||||
assert(elapsed >= 50000000LL && elapsed < 1000000000LL);
|
||||
uint64_t expirations;
|
||||
assert(read(g_release_timer_fd, &expirations, sizeof(expirations)) == sizeof(expirations));
|
||||
assert(expirations == 1);
|
||||
g_pending_releases = &blocked;
|
||||
arm_release_timer();
|
||||
struct itimerspec remaining;
|
||||
assert(timerfd_gettime(g_release_timer_fd, &remaining) == 0);
|
||||
assert(remaining.it_value.tv_sec == 0 && remaining.it_value.tv_nsec == 0);
|
||||
}
|
||||
close(g_release_timer_fd);
|
||||
close(control);
|
||||
return 0;
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 0))
|
||||
program = root / "program.c"
|
||||
program.write_text(harness.replace("@FUNCTIONS@", functions))
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
subprocess.run([str(binary), str(control)], check=True, timeout=5)
|
||||
|
||||
def test_zero_and_missing_offsets_are_unchanged(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 0))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' droiddeck_clock_domain_set_control(argv[2]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(root / "missing")], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["30000000000", "30000000000"])
|
||||
|
||||
def test_replaced_control_file_updates_offset_without_invalidating_readers(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
replacement = root / "replacement"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["20000000000", "10000000000"])
|
||||
|
||||
def test_session_transition_clears_stale_offset_but_live_failures_preserve_it(self):
|
||||
harness = r'''
|
||||
#include <assert.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include "clock_domain.h"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
(void)argc;
|
||||
int64_t shift = 10000000000LL;
|
||||
int fd = open(argv[1], O_CREAT | O_RDWR, 0600);
|
||||
assert(fd >= 0);
|
||||
assert(write(fd, &shift, sizeof(shift)) == sizeof(shift));
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
assert(unlink(argv[1]) == 0);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
int replacement = open(argv[1], O_CREAT | O_RDWR, 0600);
|
||||
assert(replacement >= 0);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
droiddeck_clock_domain_set_control(NULL);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 30000000000LL);
|
||||
shift = 20000000000LL;
|
||||
assert(write(replacement, &shift, sizeof(shift)) == sizeof(shift));
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 10000000000LL);
|
||||
close(replacement);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
program = root / "program.c"
|
||||
program.write_text(harness)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
subprocess.run([str(binary), str(root / "clock")], check=True, timeout=5)
|
||||
host = SOURCE.parents[3] / "java/com/droiddeck/launcher/wayland/CompositorHost.kt"
|
||||
self.assertIn("nativeSetClockControl(null)", host.read_text().split("fun newSession() {", 1)[1].split("}", 1)[0])
|
||||
|
||||
def test_startup_reset_keeps_host_and_guest_on_the_same_inode(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
library = root / "clock.so"
|
||||
subprocess.run(["cc", "-shared", "-fPIC", "-pthread", "-Wall", "-Wextra", "-Werror",
|
||||
"-o", str(library), str(SOURCE)], check=True)
|
||||
host = ctypes.CDLL(str(library))
|
||||
host.droiddeck_clock_domain_set_control.argtypes = [ctypes.c_char_p]
|
||||
host.droiddeck_clock_domain_adjust_ns.argtypes = [ctypes.c_int64]
|
||||
host.droiddeck_clock_domain_adjust_ns.restype = ctypes.c_int64
|
||||
host.droiddeck_clock_domain_set_control(str(control).encode())
|
||||
with control.open("r+b") as file, mmap.mmap(file.fileno(), 8) as guest:
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)],
|
||||
check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(struct.unpack("<q", guest[:])[0], 0)
|
||||
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 30_000_000_000)
|
||||
file.seek(0)
|
||||
file.write(struct.pack("<q", 20_000_000_000))
|
||||
file.flush()
|
||||
self.assertEqual(struct.unpack("<q", guest[:])[0], 20_000_000_000)
|
||||
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 10_000_000_000)
|
||||
host.droiddeck_clock_domain_set_control(None)
|
||||
|
||||
def test_initially_missing_control_is_mapped_after_creation(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
replacement = root / "replacement"
|
||||
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["30000000000", "10000000000"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -9,9 +9,16 @@ PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
||||
|
||||
PROGRAM = r"""
|
||||
#include <stdio.h>
|
||||
char *const *bl_webhelper_argv(const char *path, char *const argv[]);
|
||||
#include <stdlib.h>
|
||||
char *const *bl_webhelper_argv(const char *path, char *const argv[], char *const envp[]);
|
||||
int main(int argc, char **argv) {
|
||||
char *const *out = bl_webhelper_argv(argv[1], argv + 1);
|
||||
const char *mode = getenv("TEST_NODE_MODE_CHILD");
|
||||
static char node[64];
|
||||
snprintf(node, sizeof node, "ELECTRON_RUN_AS_NODE=%s", mode ? mode : "");
|
||||
char *node_env[] = {node, NULL};
|
||||
char *plain_env[] = {"PATH=/usr/bin", NULL};
|
||||
char *const *envp = mode ? node_env : plain_env;
|
||||
char *const *out = bl_webhelper_argv(argv[1], argv + 1, (char *const *)envp);
|
||||
for (int i = 0; out[i]; i++) printf("%s\n", out[i]);
|
||||
return 0;
|
||||
}
|
||||
@@ -35,13 +42,28 @@ class WebhelperPreloadTest(unittest.TestCase):
|
||||
def tearDownClass(cls):
|
||||
shutil.rmtree(cls.tmp, ignore_errors=True)
|
||||
|
||||
def argv(self, *args, spec=None):
|
||||
def argv(self, *args, spec=None, node_child=False, parent_node=False):
|
||||
env = {k: v for k, v in os.environ.items() if k != "BL_WEBHELPER_ARGS"}
|
||||
env.pop("ELECTRON_RUN_AS_NODE", None)
|
||||
if spec is not None:
|
||||
env["BL_WEBHELPER_ARGS"] = spec
|
||||
if node_child is not False:
|
||||
env["TEST_NODE_MODE_CHILD"] = "1" if node_child is True else node_child
|
||||
else:
|
||||
env.pop("TEST_NODE_MODE_CHILD", None)
|
||||
if parent_node:
|
||||
env["ELECTRON_RUN_AS_NODE"] = "1"
|
||||
result = subprocess.run([str(self.program), *args], env=env, capture_output=True, text=True, check=True)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def chromium(self, directory, name):
|
||||
root = self.tmp / directory
|
||||
root.mkdir(exist_ok=True)
|
||||
executable = root / name
|
||||
executable.touch()
|
||||
(root / "chrome-sandbox").touch()
|
||||
return str(executable)
|
||||
|
||||
def test_the_browser_process_keeps_its_helpers_in_process(self):
|
||||
out = self.argv(WEBHELPER, "-lang=en_US", "--enable-features=A", "--no-sandbox", "--disable-features=B,C")
|
||||
self.assertEqual(out, [WEBHELPER, "-lang=en_US", "--no-sandbox", "--no-zygote", "--in-process-gpu",
|
||||
@@ -57,6 +79,31 @@ class WebhelperPreloadTest(unittest.TestCase):
|
||||
other = ["/usr/bin/steam", "--enable-features=A"]
|
||||
self.assertEqual(self.argv(*other), other)
|
||||
|
||||
def test_node_mode_from_the_child_environment_skips_sandbox_injection(self):
|
||||
code = self.chromium("vscode", "code")
|
||||
self.assertEqual(self.argv(code, node_child=True), [code])
|
||||
|
||||
def test_any_nonempty_node_mode_value_skips_sandbox_injection(self):
|
||||
code = self.chromium("vscode-true", "code")
|
||||
for value in ("true", "0", "yes"):
|
||||
self.assertEqual(self.argv(code, node_child=value), [code])
|
||||
|
||||
def test_empty_node_mode_value_still_gets_sandbox_flag(self):
|
||||
chrome = self.chromium("chromium-empty-mode", "chrome")
|
||||
self.assertEqual(self.argv(chrome, node_child=""), [chrome, "--no-sandbox"])
|
||||
|
||||
def test_non_browser_helper_beside_chrome_sandbox_skips_injection_in_node_mode(self):
|
||||
helper = self.chromium("vscode-helper", "remote-cli")
|
||||
self.assertEqual(self.argv(helper, node_child=True), [helper])
|
||||
|
||||
def test_chromium_gui_launch_still_gets_sandbox_flag_from_explicit_environment(self):
|
||||
chrome = self.chromium("chromium", "chrome")
|
||||
self.assertEqual(self.argv(chrome), [chrome, "--no-sandbox"])
|
||||
|
||||
def test_parent_node_mode_does_not_override_the_explicit_child_environment(self):
|
||||
chrome = self.chromium("chromium-parent-mode", "chrome")
|
||||
self.assertEqual(self.argv(chrome, parent_node=True), [chrome, "--no-sandbox"])
|
||||
|
||||
def test_stock_turns_it_off(self):
|
||||
args = [WEBHELPER, "--enable-features=A"]
|
||||
self.assertEqual(self.argv(*args, spec="stock"), args)
|
||||
|
||||
@@ -92,6 +92,18 @@ class WinComponentsTest(unittest.TestCase):
|
||||
self.assertEqual(names, ["ucrtbase"])
|
||||
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/ucrtbase.dll"), 0x8664)
|
||||
|
||||
def test_x64_visual_cpp_runtime_is_placed_in_arm64_system32(self):
|
||||
proton = self.proton()
|
||||
self.component("vc", ["msvcp140", "vcruntime140_1"], {
|
||||
"system32/msvcp140.dll": self.pe_image(0x8664),
|
||||
"system32/vcruntime140_1.dll": self.pe_image(0x8664),
|
||||
})
|
||||
self.pick("vc")
|
||||
names, _ = self.apply(proton)
|
||||
self.assertEqual(names, ["msvcp140", "vcruntime140_1"])
|
||||
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/msvcp140.dll"), 0x8664)
|
||||
self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/vcruntime140_1.dll"), 0x8664)
|
||||
|
||||
def test_compatible_copy_keeps_override_when_other_architecture_copy_is_skipped(self):
|
||||
proton = self.proton()
|
||||
self.component("vc", ["ucrtbase"], {
|
||||
|
||||
Reference in new issue
Block a user