From f38d24d347801ba66d6debf2dd869e748253eecc Mon Sep 17 00:00:00 2001 From: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:55:14 -0800 Subject: [PATCH 1/2] Launcher suite: the two uninstall checks of #219 follow the file-ownership rule Two checks of tests/run_launcher_tests.py expected what the launcher did before 0.6.1's file-ownership rule (README, record.h): a file at a recorded path whose bytes are not the ones WrongGPU recorded stays where it is. - test_rr: after the in-game switch edits WrongGPU\wronggpu.ini, the next repair backs that file up as changed since the install; the plugin rewrites it again, so the uninstall leaves it and keeps the backed-up generation in WrongGPU-originals. The check now expects that copy (one wronggpu.ini there and nothing else, holding the in-game switch's rr_mode). - test_re9: the test drops the mirror's _storage_\dxgi.dll from the record; the repair takes that unrecorded copy for the player's and backs it up, so the uninstall puts it back. The check now expects it. rr.h's header still said the RR settings files go at uninstall after the plugin rewrote them; it now says what the rule does. The file was 69 bytes below the 256 KB source limit, so test_edition_download moves unchanged to launcher_edition_cases.py (as launcher_ignore_cases.py did); a two-line test_edition_download keeps --only edition_download. Verified with main's own launcher (MinGW WRONGGPU_TESTING build, -DWRONGGPU_PRESET_K=OFF) under Wine (GE-Proton 11-11): --only rr goes from 10 to 9 failures and --only re9 from 5 to 4, the two checks now passing; the rest are the Wine run's own (empty UI dumps, rr-prepare without a helper). The moved section's body is byte-identical to main's; under the Wine adapter it stops at the same zipfile path step on main and here. reuse lint and check_source_size pass (run_launcher_tests.py 257355 bytes). Part of #219 (its MinGW and --only re9 parts are a separate PR). Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com> --- clean/installer/src/wg_core/rr.h | 3 +- .../installer/tests/launcher_edition_cases.py | 99 ++++++++++++++++ clean/installer/tests/run_launcher_tests.py | 109 +++--------------- 3 files changed, 115 insertions(+), 96 deletions(-) create mode 100644 clean/installer/tests/launcher_edition_cases.py diff --git a/clean/installer/src/wg_core/rr.h b/clean/installer/src/wg_core/rr.h index 30145970..5f0711fd 100644 --- a/clean/installer/src/wg_core/rr.h +++ b/clean/installer/src/wg_core/rr.h @@ -6,7 +6,8 @@ // own plugin), the RR runtime next to the game exe, wronggpu-rr.ini (rr_model: the RR data) and the plugin's settings // file WrongGPU\wronggpu.ini ([wronggpu] rr_enabled, rr_mode, rr_exact_allowed; the plugin saves rr_mode there when the // player switches it in OptiScaler's menu). Every one is an entry of the install record (staging, rollback, uninstall -// byte for byte); the two settings files go at uninstall even after the plugin rewrote them. +// byte for byte). A settings file the plugin rewrote no longer holds the bytes WrongGPU recorded, so an uninstall leaves it in +// place with a warning (the file-ownership rule, record.h; README). // The RR data (preset F) is converted once per PC from the player's own RR model file with WrongGPU's converter, as the // model data is (model.h), into %LOCALAPPDATA%\WrongGPU\model\F\model.wgcm: shared by every game (a game whose own file is // too old uses it too). The file is never copied or changed, and never downloaded or shipped. Written for this project. diff --git a/clean/installer/tests/launcher_edition_cases.py b/clean/installer/tests/launcher_edition_cases.py new file mode 100644 index 00000000..384b72e8 --- /dev/null +++ b/clean/installer/tests/launcher_edition_cases.py @@ -0,0 +1,99 @@ +# SPDX-License-Identifier: MIT +"""The download of WrongGPU's edition of OptiScaler, for run_launcher_tests.py (which calls run() in its place in the suite; +this file keeps that suite below the 256 KB source limit, as launcher_ignore_cases.py does). The section is moved unchanged: +run()'s arguments are the suite's own helpers it used as module names. Written for this project.""" +import os +import shutil + +from run_installer_tests import read, sha, snapshot, diff, write + + +def run(t, opti, game, edition_package, OPTI_INI): + """WrongGPU's edition of OptiScaler, downloaded by the launcher (optiedition.h): pinned size + SHA-256, a mismatch refused, + the cache reused, offline falls back to the player's own download. A local test server (127.0.0.1) stands in for the + release page; the test build never downloads without WRONGGPU_TEST_EDITION.""" + print("\n[edition] the launcher downloads WrongGPU's edition of OptiScaler: pinned hash, mismatch refused, cache, offline fallback") + import http.server + import threading + import zipfile + ed_pkg, dll = edition_package(t, "edition-src") + srv_dir = os.path.join(t.work, "edition-server") + shutil.rmtree(srv_dir, ignore_errors=True) + os.makedirs(srv_dir) + zpath = os.path.join(srv_dir, "edition.zip") + with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED) as z: + z.writestr("OptiScaler.dll", dll) + z.writestr("OptiScaler.ini", OPTI_INI) + z.writestr("LICENSE-OptiScaler.txt", "GPL-3.0 (test stand-in)") + zbytes = read(zpath) + hits = [] + + class H(http.server.SimpleHTTPRequestHandler): + def __init__(self, *a, **k): + super().__init__(*a, directory=srv_dir, **k) + + def do_GET(self): + hits.append(self.path) + return super().do_GET() + + def log_message(self, *a): + pass + + httpd = http.server.ThreadingHTTPServer(("127.0.0.1", 0), H) + port = httpd.server_address[1] + threading.Thread(target=httpd.serve_forever, daemon=True).start() + cache = os.path.join(t.data, "optiscaler", "edition-test.zip") + try: + pin = lambda url, s=None: "%s|%d|%s|%s" % (url, len(zbytes), s or sha(zbytes), sha(dll)) + t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port) + if os.path.exists(cache): + os.remove(cache) + root, b, exe = game(t, "Edition Game", validated=True) + before = snapshot(root) + rc = t.run("install", exe, "--noscan", "--force") + log = read(t.log).decode("utf-8", "replace") + proxy = [n for n in ("dxgi.dll", "winmm.dll", "version.dll") if os.path.isfile(os.path.join(b, n))] + t.check("no OptiScaler chosen: the launcher downloads its edition (one GET), checks it (sha256), caches it in its data folder and installs it", + rc == 0 and len(hits) == 1 and read(cache) == zbytes and "downloaded and checked" in log and proxy and read(os.path.join(b, proxy[0])) == dll and + "(WrongGPU edition, plugin interface 5)" in log, (rc, t.j.get("message"), hits, proxy, t.logtail())) + rc = t.run("repair", exe, "--noscan", "--force") + log = read(t.log).decode("utf-8", "replace") + t.check("the next install / repair reuses the cached, checked copy (no second download)", + rc == 0 and len(hits) == 1 and "from the launcher's cache" in log, (rc, hits, t.logtail())) + # the cached copy changed on disk: not used, downloaded again + write(cache, zbytes[:-1] + b"X") + rc = t.run("repair", exe, "--noscan", "--force") + t.check("a cached copy that doesn't match is never used: downloaded again and checked", rc == 0 and len(hits) == 2 and read(cache) == zbytes, (rc, hits)) + # a download that isn't the pinned file: refused, deleted, never used; the player's own download (Settings) instead + os.remove(cache) + t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port, "0" * 64) + rc = t.run("repair", exe, "--noscan", "--force") + log = read(t.log).decode("utf-8", "replace") + t.check("hash mismatch: refused with the plain words, nothing cached, no OptiScaler without the player's own download (exit 2)", + rc == 2 and "download refused" in log and not os.path.exists(cache) and not os.path.exists(cache + ".part"), (rc, t.j.get("message"), t.logtail())) + rc = t.run("set", "--global", "optiscaler=" + opti) + rc = t.run("repair", exe, "--noscan", "--force") + log = read(t.log).decode("utf-8", "replace") + t.check("hash mismatch with the player's own OptiScaler download set: that one is used", rc == 0 and "mock OptiScaler" in read(os.path.join(b, proxy[0])).decode("latin-1") if proxy else False, + (rc, t.j.get("message"), t.logtail())) + # offline (nothing answers): the player's own download + t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:9/edition.zip") + rc = t.run("repair", exe, "--noscan", "--force") + log = read(t.log).decode("utf-8", "replace") + t.check("offline: the player's own OptiScaler download is used (fallback), nothing cached", rc == 0 and "download failed" in log and not os.path.exists(cache), + (rc, t.j.get("message"), t.logtail())) + t.run("set", "--global", "optiscaler=") + rc = t.run("repair", exe, "--noscan", "--force") + t.check("offline without the player's own download: refused (exit 2), said in words", rc == 2 and "OptiScaler" in t.j.get("message", ""), (rc, t.j.get("message"))) + # only https:// outside 127.0.0.1 (a test build allows the local test server only) + t.env["WRONGGPU_TEST_EDITION"] = pin("http://example.invalid/edition.zip") + rc = t.run("repair", exe, "--noscan", "--force") + t.check("plain http:// to another host is never used", rc == 2 and "only https://" in read(t.log).decode("utf-8", "replace"), (rc, t.logtail())) + t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port) + rc = t.run("uninstall", exe) + t.check("uninstall: the game folder back byte for byte", + rc == 0 and snapshot(root) == before, (rc, diff(before, snapshot(root)))) + shutil.rmtree(root, ignore_errors=True) + finally: + httpd.shutdown() + t.env.pop("WRONGGPU_TEST_EDITION", None) diff --git a/clean/installer/tests/run_launcher_tests.py b/clean/installer/tests/run_launcher_tests.py index 122884a7..9c925819 100644 --- a/clean/installer/tests/run_launcher_tests.py +++ b/clean/installer/tests/run_launcher_tests.py @@ -1240,13 +1240,17 @@ def test_rr(t, opti, synth_f): write(files["ini"], read(files["ini"]) + b"rr_plugin_key=1\r\n") write(files["settings"], read(files["settings"]) + b"rr_last_seen=1\r\n") # the install created both settings files and the plugin rewrote them: their bytes are no longer the recorded ones, so the - # uninstall leaves them as they are (with the wronggpu-* logs that are not in the record) and says so + # uninstall leaves them as they are (with the wronggpu-* logs that are not in the record) and says so. The repair after the + # in-game switch backed up the settings file the plugin had rewritten then (README: the file-ownership rule): that + # generation cannot go back over the file the plugin rewrote since, so it is kept in WrongGPU-originals left = kept_runtime(before, root, *[os.path.relpath(files[k], root) for k in ("ini", "settings")], *unrecorded_wronggpu_files(root)) rc = t.run("uninstall", exe) after = snapshot(root) - t.check("uninstall: exit 0, the RR game's folder as before except the two RR settings files the plugin rewrote and the unrecorded logs, which stay as they are", - rc == 0 and after == left and any(w == "Left in place (changed since install): " + os.path.relpath(files["ini"], b) for w in t.j.get("warnings", [])), - (rc, t.j.get("message"), diff(left, after), t.j.get("warnings"))) + kept = [k for k in after if k.startswith("bin/x64/wronggpu-originals/") and k.endswith("/wronggpu/wronggpu.ini")] + t.check("uninstall: exit 0, the RR game's folder as before except the two RR settings files the plugin rewrote and the unrecorded logs, which stay as they are, " + "and the in-game switch's settings file the repair backed up, kept in WrongGPU-originals", + rc == 0 and suite.without_kept(after)[0] == left and any(w == "Left in place (changed since install): " + os.path.relpath(files["ini"], b) for w in t.j.get("warnings", [])) and + len(kept) == 1 and len(suite.without_kept(after)[1]) == 1 and b"rr_mode = fast" in read(os.path.join(root, *kept[0].split("/"))), (rc, t.j.get("message"), diff(left, suite.without_kept(after)[0]), kept, t.j.get("warnings"))) t.check("uninstall: the shared RR data stays for the other games", os.path.isfile(fdata) == data_on) leftN = kept_runtime(beforeN, rootN, *unrecorded_wronggpu_files(rootN)) rc = t.run("uninstall", exeN) @@ -1462,8 +1466,10 @@ def test_re9(t, opti, synth_f): rc = t.run("uninstall", exeO) afterO = snapshot(rootO) mirrored = afterO.pop("_storage_/steam_api64.dll", None) - t.check("uninstall after the update: everything of WrongGPU's gone from the folder and the mirror; the player's mirrored file stays", - rc == 0 and mirrored is not None and afterO == beforeO, (rc, t.j.get("message"), diff(beforeO, afterO))) + # the mirror's earlier copy was not in the record (dropped above): the repair took it for the player's and backed it up + # (README: the file-ownership rule; an unrecorded mirror copy is not WrongGPU's even with the root DLL's bytes), so it comes back + t.check("uninstall after the update: everything of WrongGPU's gone from the folder and the mirror; the player's mirrored file and the unrecorded earlier mirror copy stay", + rc == 0 and mirrored is not None and afterO == dict(beforeO, **{"_storage_/dxgi.dll": sha(old)}), (rc, t.j.get("message"), diff(beforeO, afterO))) # uninstall: the game folder byte for byte as before, the mirror's earlier copy put back, REFramework kept write(os.path.join(root, "_storage_", "wronggpu-rr.log"), "written again by the game") left = kept_runtime(before, root, *unrecorded_wronggpu_files(root)) @@ -2584,95 +2590,8 @@ def set_no_docs(*kv): shutil.rmtree(d, ignore_errors=True) -def test_edition_download(t, opti): - """WrongGPU's edition of OptiScaler, downloaded by the launcher (optiedition.h): pinned size + SHA-256, a mismatch refused, - the cache reused, offline falls back to the player's own download. A local test server (127.0.0.1) stands in for the - release page; the test build never downloads without WRONGGPU_TEST_EDITION.""" - print("\n[edition] the launcher downloads WrongGPU's edition of OptiScaler: pinned hash, mismatch refused, cache, offline fallback") - import http.server - import threading - import zipfile - ed_pkg, dll = edition_package(t, "edition-src") - srv_dir = os.path.join(t.work, "edition-server") - shutil.rmtree(srv_dir, ignore_errors=True) - os.makedirs(srv_dir) - zpath = os.path.join(srv_dir, "edition.zip") - with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED) as z: - z.writestr("OptiScaler.dll", dll) - z.writestr("OptiScaler.ini", OPTI_INI) - z.writestr("LICENSE-OptiScaler.txt", "GPL-3.0 (test stand-in)") - zbytes = read(zpath) - hits = [] - - class H(http.server.SimpleHTTPRequestHandler): - def __init__(self, *a, **k): - super().__init__(*a, directory=srv_dir, **k) - - def do_GET(self): - hits.append(self.path) - return super().do_GET() - - def log_message(self, *a): - pass - - httpd = http.server.ThreadingHTTPServer(("127.0.0.1", 0), H) - port = httpd.server_address[1] - threading.Thread(target=httpd.serve_forever, daemon=True).start() - cache = os.path.join(t.data, "optiscaler", "edition-test.zip") - try: - pin = lambda url, s=None: "%s|%d|%s|%s" % (url, len(zbytes), s or sha(zbytes), sha(dll)) - t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port) - if os.path.exists(cache): - os.remove(cache) - root, b, exe = game(t, "Edition Game", validated=True) - before = snapshot(root) - rc = t.run("install", exe, "--noscan", "--force") - log = read(t.log).decode("utf-8", "replace") - proxy = [n for n in ("dxgi.dll", "winmm.dll", "version.dll") if os.path.isfile(os.path.join(b, n))] - t.check("no OptiScaler chosen: the launcher downloads its edition (one GET), checks it (sha256), caches it in its data folder and installs it", - rc == 0 and len(hits) == 1 and read(cache) == zbytes and "downloaded and checked" in log and proxy and read(os.path.join(b, proxy[0])) == dll and - "(WrongGPU edition, plugin interface 5)" in log, (rc, t.j.get("message"), hits, proxy, t.logtail())) - rc = t.run("repair", exe, "--noscan", "--force") - log = read(t.log).decode("utf-8", "replace") - t.check("the next install / repair reuses the cached, checked copy (no second download)", - rc == 0 and len(hits) == 1 and "from the launcher's cache" in log, (rc, hits, t.logtail())) - # the cached copy changed on disk: not used, downloaded again - write(cache, zbytes[:-1] + b"X") - rc = t.run("repair", exe, "--noscan", "--force") - t.check("a cached copy that doesn't match is never used: downloaded again and checked", rc == 0 and len(hits) == 2 and read(cache) == zbytes, (rc, hits)) - # a download that isn't the pinned file: refused, deleted, never used; the player's own download (Settings) instead - os.remove(cache) - t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port, "0" * 64) - rc = t.run("repair", exe, "--noscan", "--force") - log = read(t.log).decode("utf-8", "replace") - t.check("hash mismatch: refused with the plain words, nothing cached, no OptiScaler without the player's own download (exit 2)", - rc == 2 and "download refused" in log and not os.path.exists(cache) and not os.path.exists(cache + ".part"), (rc, t.j.get("message"), t.logtail())) - rc = t.run("set", "--global", "optiscaler=" + opti) - rc = t.run("repair", exe, "--noscan", "--force") - log = read(t.log).decode("utf-8", "replace") - t.check("hash mismatch with the player's own OptiScaler download set: that one is used", rc == 0 and "mock OptiScaler" in read(os.path.join(b, proxy[0])).decode("latin-1") if proxy else False, - (rc, t.j.get("message"), t.logtail())) - # offline (nothing answers): the player's own download - t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:9/edition.zip") - rc = t.run("repair", exe, "--noscan", "--force") - log = read(t.log).decode("utf-8", "replace") - t.check("offline: the player's own OptiScaler download is used (fallback), nothing cached", rc == 0 and "download failed" in log and not os.path.exists(cache), - (rc, t.j.get("message"), t.logtail())) - t.run("set", "--global", "optiscaler=") - rc = t.run("repair", exe, "--noscan", "--force") - t.check("offline without the player's own download: refused (exit 2), said in words", rc == 2 and "OptiScaler" in t.j.get("message", ""), (rc, t.j.get("message"))) - # only https:// outside 127.0.0.1 (a test build allows the local test server only) - t.env["WRONGGPU_TEST_EDITION"] = pin("http://example.invalid/edition.zip") - rc = t.run("repair", exe, "--noscan", "--force") - t.check("plain http:// to another host is never used", rc == 2 and "only https://" in read(t.log).decode("utf-8", "replace"), (rc, t.logtail())) - t.env["WRONGGPU_TEST_EDITION"] = pin("http://127.0.0.1:%d/edition.zip" % port) - rc = t.run("uninstall", exe) - t.check("uninstall: the game folder back byte for byte", - rc == 0 and snapshot(root) == before, (rc, diff(before, snapshot(root)))) - shutil.rmtree(root, ignore_errors=True) - finally: - httpd.shutdown() - t.env.pop("WRONGGPU_TEST_EDITION", None) +def test_edition_download(t, opti): # in launcher_edition_cases.py (this file stays below the 256 KB source limit) + __import__("launcher_edition_cases").run(t, opti, game, edition_package, OPTI_INI) def test_ui_dump(t, opti): From 8b1f7f7a7d8d6729a51c95a7a3b853edeef65f80 Mon Sep 17 00:00:00 2001 From: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com> Date: Sat, 14 Nov 2026 19:04:18 -0800 Subject: [PATCH 2/2] Launcher suite: keep only the test_re9 change (review) Per the review of #222: the test_rr check and rr.h's header go back to main's text. WrongGPU's own settings file is to be removed at uninstall once settings move to WrongGPU\state\ (0.6.5), so the check will expect a clean uninstall and is updated with that change, not here. What stays: test_re9 expects the unrecorded mirror copy to come back, and test_edition_download lives in launcher_edition_cases.py (the suite file is at 262132 bytes on main; the test_re9 text alone would pass the 256 KB limit without it). Verified: the file parses; the moved section's body is byte-identical to main's; check_source_size.py reports 256799 bytes; reuse lint passes. The test_re9 check itself is unchanged since it was run under Wine against main's launcher (it passed there); not rerun after this merge. Co-Authored-By: Claude Fable 5.2 Signed-off-by: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com> --- clean/installer/src/wg_core/rr.h | 3 +-- clean/installer/tests/run_launcher_tests.py | 12 ++++-------- 2 files changed, 5 insertions(+), 10 deletions(-) diff --git a/clean/installer/src/wg_core/rr.h b/clean/installer/src/wg_core/rr.h index 5f0711fd..30145970 100644 --- a/clean/installer/src/wg_core/rr.h +++ b/clean/installer/src/wg_core/rr.h @@ -6,8 +6,7 @@ // own plugin), the RR runtime next to the game exe, wronggpu-rr.ini (rr_model: the RR data) and the plugin's settings // file WrongGPU\wronggpu.ini ([wronggpu] rr_enabled, rr_mode, rr_exact_allowed; the plugin saves rr_mode there when the // player switches it in OptiScaler's menu). Every one is an entry of the install record (staging, rollback, uninstall -// byte for byte). A settings file the plugin rewrote no longer holds the bytes WrongGPU recorded, so an uninstall leaves it in -// place with a warning (the file-ownership rule, record.h; README). +// byte for byte); the two settings files go at uninstall even after the plugin rewrote them. // The RR data (preset F) is converted once per PC from the player's own RR model file with WrongGPU's converter, as the // model data is (model.h), into %LOCALAPPDATA%\WrongGPU\model\F\model.wgcm: shared by every game (a game whose own file is // too old uses it too). The file is never copied or changed, and never downloaded or shipped. Written for this project. diff --git a/clean/installer/tests/run_launcher_tests.py b/clean/installer/tests/run_launcher_tests.py index 23fe4114..92c7a88c 100644 --- a/clean/installer/tests/run_launcher_tests.py +++ b/clean/installer/tests/run_launcher_tests.py @@ -1240,17 +1240,13 @@ def test_rr(t, opti, synth_f): write(files["ini"], read(files["ini"]) + b"rr_plugin_key=1\r\n") write(files["settings"], read(files["settings"]) + b"rr_last_seen=1\r\n") # the install created both settings files and the plugin rewrote them: their bytes are no longer the recorded ones, so the - # uninstall leaves them as they are (with the wronggpu-* logs that are not in the record) and says so. The repair after the - # in-game switch backed up the settings file the plugin had rewritten then (README: the file-ownership rule): that - # generation cannot go back over the file the plugin rewrote since, so it is kept in WrongGPU-originals + # uninstall leaves them as they are (with the wronggpu-* logs that are not in the record) and says so left = kept_runtime(before, root, *[os.path.relpath(files[k], root) for k in ("ini", "settings")], *unrecorded_wronggpu_files(root)) rc = t.run("uninstall", exe) after = snapshot(root) - kept = [k for k in after if k.startswith("bin/x64/wronggpu-originals/") and k.endswith("/wronggpu/wronggpu.ini")] - t.check("uninstall: exit 0, the RR game's folder as before except the two RR settings files the plugin rewrote and the unrecorded logs, which stay as they are, " - "and the in-game switch's settings file the repair backed up, kept in WrongGPU-originals", - rc == 0 and suite.without_kept(after)[0] == left and any(w == "Left in place (changed since install): " + os.path.relpath(files["ini"], b) for w in t.j.get("warnings", [])) and - len(kept) == 1 and len(suite.without_kept(after)[1]) == 1 and b"rr_mode = fast" in read(os.path.join(root, *kept[0].split("/"))), (rc, t.j.get("message"), diff(left, suite.without_kept(after)[0]), kept, t.j.get("warnings"))) + t.check("uninstall: exit 0, the RR game's folder as before except the two RR settings files the plugin rewrote and the unrecorded logs, which stay as they are", + rc == 0 and after == left and any(w == "Left in place (changed since install): " + os.path.relpath(files["ini"], b) for w in t.j.get("warnings", [])), + (rc, t.j.get("message"), diff(left, after), t.j.get("warnings"))) t.check("uninstall: the shared RR data stays for the other games", os.path.isfile(fdata) == data_on) leftN = kept_runtime(beforeN, rootN, *unrecorded_wronggpu_files(rootN)) rc = t.run("uninstall", exeN)