mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-22 17:19:58 -04:00
The 0.6 crashes after warps and area changes fixed (no write-back into memory the capture leaves out), invisible objects fixed (occlusion gate), DLSS frame generation flicker fixed, achievements, the renderer built with a play profile, faster translated game code, helper threads judged on settled scenes, memory, shader preparation, audio effects, launcher, controls and Linux fixes.
294 lines
14 KiB
Python
294 lines
14 KiB
Python
"""Exercise actual production stage-all/copy/swap statements with authored temporary files.
|
|
|
|
python -I -B tests/test_finish_output.py
|
|
|
|
(The fixture's program is Triforce.exe, the name the build gives it: under its old name the finish's own cleanup of old
|
|
programs removed it, and five of these tests stopped on a missing file.)
|
|
"""
|
|
import ast
|
|
import contextlib
|
|
import ctypes
|
|
import errno
|
|
import importlib.util
|
|
import io
|
|
import os
|
|
from pathlib import Path
|
|
import stat
|
|
import tempfile
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
SOURCE = ROOT / "nx2" / "make_game.py"
|
|
spec = importlib.util.spec_from_file_location("make_game_finish", SOURCE)
|
|
make_game = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(make_game)
|
|
|
|
|
|
def finish_statements(source, filename):
|
|
main = next(node for node in ast.parse(source).body
|
|
if isinstance(node, ast.FunctionDef) and node.name == "main")
|
|
starts = [i for i, node in enumerate(main.body) if isinstance(node, ast.Assign)
|
|
and any(isinstance(target, ast.Name) and target.id == "staged" for target in node.targets)]
|
|
assert starts
|
|
start = starts[0]
|
|
end = next(i for i, node in enumerate(main.body[start + 1:], start + 1)
|
|
if isinstance(node, ast.If) and any(isinstance(call, ast.Call)
|
|
and isinstance(call.func, ast.Name) and call.func.id == "shader_census_cmd" for call in ast.walk(node)))
|
|
# Include real launcher/destination selection, list/append, stage-copy and swap; no rewritten installation algorithm.
|
|
return compile(ast.Module(body=main.body[start:end], type_ignores=[]), filename, "exec")
|
|
|
|
|
|
FINISH = finish_statements(SOURCE.read_text(encoding="utf-8"), str(SOURCE))
|
|
|
|
|
|
class FinishOutputTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.directory = tempfile.TemporaryDirectory(prefix="hookshot-finish-")
|
|
self.addCleanup(self.directory.cleanup)
|
|
self.root = Path(self.directory.name)
|
|
self.addCleanup(self.clear_fixture_readonly_modes)
|
|
self.work, self.out = self.root / "work", self.root / "game"
|
|
self.built = self.work / "sa" / "build"
|
|
self.built.mkdir(parents=True)
|
|
self.out.mkdir()
|
|
self.source, self.destination = self.built / "Triforce.exe", self.out / "Triforce.exe"
|
|
self.source.write_bytes(b"new synthetic executable")
|
|
self.destination.write_bytes(b"existing synthetic executable")
|
|
(self.work / "sa" / "image").mkdir()
|
|
self.image = self.work / "sa" / "image" / "image.bin"
|
|
self.image.write_bytes(b"new synthetic image")
|
|
(self.out / "image.bin").write_bytes(b"existing synthetic image")
|
|
|
|
def clear_fixture_readonly_modes(self):
|
|
# Test-owned temporary files only: production must never unlock destinations or pre-existing .new files.
|
|
for path in self.root.rglob("*"):
|
|
assert path.resolve().is_relative_to(self.root.resolve())
|
|
if path.is_file():
|
|
path.chmod(stat.S_IREAD | stat.S_IWRITE)
|
|
|
|
def finish(self, launcher=False):
|
|
if launcher:
|
|
(self.root / "HookshotBuilder-Setup.exe").write_bytes(b"new synthetic launcher")
|
|
with mock.patch.object(make_game, "BESIDE", ["Triforce.exe"]):
|
|
# Comprehensions use globals. Keep one namespace, as in production, and discover only authored setup files.
|
|
namespace = dict(make_game.__dict__, built=str(self.built), out=str(self.out), work=str(self.work),
|
|
ROOT=str(self.root / "tools"), LINUX=False if launcher else make_game.LINUX)
|
|
exec(FINISH, namespace)
|
|
|
|
def assert_installed_unchanged(self):
|
|
self.assertEqual(self.destination.read_bytes(), b"existing synthetic executable")
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), b"existing synthetic image")
|
|
|
|
def assert_no_staging_files(self):
|
|
# (the note of what was installed is the finish's own, not a staging file: the performance audit's IO-45,
|
|
# tests/test_finish_installed.py)
|
|
self.assertEqual(sorted(path.name for path in self.out.iterdir() if path.name != make_game.INSTALLED_NOTE),
|
|
["Triforce.exe", "image.bin"])
|
|
|
|
def stopped_output(self):
|
|
output = io.StringIO()
|
|
with contextlib.redirect_stdout(output):
|
|
with self.assertRaises(SystemExit) as stopped:
|
|
self.finish()
|
|
self.assertEqual(stopped.exception.code, 1)
|
|
self.assertIn("@@error", output.getvalue())
|
|
return output.getvalue()
|
|
|
|
def test_completed_copy_replaces_existing_files_with_source_mode(self):
|
|
self.source.chmod(0o755)
|
|
self.finish()
|
|
self.assertEqual(self.destination.read_bytes(), self.source.read_bytes())
|
|
self.assertEqual(stat.S_IMODE(self.destination.stat().st_mode), stat.S_IMODE(self.source.stat().st_mode))
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assert_no_staging_files()
|
|
|
|
def test_all_sources_staged_before_either_installed_file_changes(self):
|
|
copy = make_game.shutil.copy2
|
|
copied = []
|
|
|
|
def observe_copy(source, destination):
|
|
self.assert_installed_unchanged()
|
|
result = copy(source, destination)
|
|
self.assert_installed_unchanged()
|
|
copied.append(Path(source))
|
|
return result
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=observe_copy):
|
|
self.finish()
|
|
self.assertEqual(copied, [self.source, self.image])
|
|
self.assertEqual(self.destination.read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assert_no_staging_files()
|
|
|
|
def test_first_install_without_existing_files(self):
|
|
self.destination.unlink()
|
|
(self.out / "image.bin").unlink()
|
|
self.finish()
|
|
self.assertEqual(self.destination.read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assert_no_staging_files()
|
|
|
|
def test_launcher_stages_all_three_files_before_replacement(self):
|
|
binary = self.out / "bin" / "Triforce.exe"
|
|
binary.parent.mkdir()
|
|
binary.write_bytes(b"existing synthetic game in bin")
|
|
copy = make_game.shutil.copy2
|
|
copied = []
|
|
|
|
def observe_copy(source, destination):
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual(binary.read_bytes(), b"existing synthetic game in bin")
|
|
result = copy(source, destination)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual(binary.read_bytes(), b"existing synthetic game in bin")
|
|
copied.append(Path(source))
|
|
return result
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=observe_copy):
|
|
self.finish(launcher=True)
|
|
self.assertEqual(copied, [self.source, self.image, self.root / "HookshotBuilder-Setup.exe"])
|
|
self.assertEqual(binary.read_bytes(), self.source.read_bytes())
|
|
self.assertEqual(self.destination.read_bytes(), b"new synthetic launcher")
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assertEqual(list(self.out.rglob("*.new")), [])
|
|
|
|
def test_partial_launcher_copy_preserves_game_image_and_launcher(self):
|
|
binary = self.out / "bin" / "Triforce.exe"
|
|
binary.parent.mkdir()
|
|
binary.write_bytes(b"existing synthetic game in bin")
|
|
copy = make_game.shutil.copy2
|
|
|
|
def partial_launcher(source, destination):
|
|
if Path(source) == self.root / "HookshotBuilder-Setup.exe":
|
|
Path(destination).write_bytes(b"partial launcher")
|
|
raise OSError(errno.ENOSPC, "synthetic disk-full error")
|
|
return copy(source, destination)
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=partial_launcher):
|
|
with self.assertRaises(OSError):
|
|
self.finish(launcher=True)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual(binary.read_bytes(), b"existing synthetic game in bin")
|
|
self.assertEqual(binary.with_name("Triforce.exe.new").read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin.new").read_bytes(), self.image.read_bytes())
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), b"partial launcher")
|
|
|
|
def test_partial_executable_copy_preserves_both_installed_files(self):
|
|
def partial_copy(source, destination):
|
|
Path(destination).write_bytes(b"incomplete replacement")
|
|
raise OSError(errno.ENOSPC, "synthetic disk-full error")
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=partial_copy):
|
|
with self.assertRaises(OSError):
|
|
self.finish()
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), b"incomplete replacement")
|
|
self.assertFalse((self.out / "image.bin.new").exists())
|
|
|
|
def test_partial_image_copy_preserves_both_installed_files(self):
|
|
copy = make_game.shutil.copy2
|
|
|
|
def partial_image(source, destination):
|
|
if Path(source) == self.image:
|
|
self.assert_installed_unchanged()
|
|
Path(destination).write_bytes(b"incomplete image")
|
|
raise OSError(errno.ENOSPC, "synthetic disk-full error")
|
|
return copy(source, destination)
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=partial_image):
|
|
with self.assertRaises(OSError):
|
|
self.finish()
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin.new").read_bytes(), b"incomplete image")
|
|
|
|
def test_readonly_source_mode_is_preserved_on_success(self):
|
|
self.source.chmod(stat.S_IREAD)
|
|
self.finish()
|
|
self.assertEqual(self.destination.read_bytes(), self.source.read_bytes())
|
|
self.assertFalse(self.destination.stat().st_mode & stat.S_IWRITE)
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assert_no_staging_files()
|
|
|
|
def test_denied_swap_keeps_complete_readonly_staging_file(self):
|
|
self.source.chmod(stat.S_IREAD)
|
|
with mock.patch.object(make_game.os, "replace", side_effect=PermissionError("synthetic denied replacement")):
|
|
message = self.stopped_output()
|
|
self.assertIn("writable", message)
|
|
self.assertNotIn("the game is running", message)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), self.source.read_bytes())
|
|
self.assertFalse((self.out / "Triforce.exe.new").stat().st_mode & stat.S_IWRITE)
|
|
self.assertEqual((self.out / "image.bin.new").read_bytes(), self.image.read_bytes())
|
|
|
|
def test_stage_copy_permission_failure_has_actionable_paths(self):
|
|
def denied_copy(source, destination):
|
|
Path(destination).write_bytes(b"partial staged copy")
|
|
raise PermissionError("synthetic denied staging write")
|
|
|
|
with mock.patch.object(make_game.shutil, "copy2", side_effect=denied_copy):
|
|
message = self.stopped_output()
|
|
self.assertIn("stage", message)
|
|
self.assertIn(str(self.out / "Triforce.exe.new"), message)
|
|
self.assertIn(str(self.source), message)
|
|
self.assertIn("readable", message)
|
|
self.assertIn("writable", message)
|
|
self.assertIn("No installed files were replaced", message)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), b"partial staged copy")
|
|
|
|
@unittest.skipUnless(os.name == "nt", "Windows file-sharing contract")
|
|
def test_locked_destination_reports_action_and_retains_staged_build(self):
|
|
kernel = ctypes.WinDLL("kernel32", use_last_error=True)
|
|
kernel.CreateFileW.argtypes = [ctypes.c_wchar_p, ctypes.c_ulong, ctypes.c_ulong,
|
|
ctypes.c_void_p, ctypes.c_ulong, ctypes.c_ulong, ctypes.c_void_p]
|
|
kernel.CreateFileW.restype = ctypes.c_void_p
|
|
kernel.CloseHandle.argtypes = [ctypes.c_void_p]
|
|
kernel.CloseHandle.restype = ctypes.c_int
|
|
# Test-owned file: share reads/writes, not deletion/replacement, like a running executable.
|
|
handle = kernel.CreateFileW(str(self.destination), 0x80000000, 0x1 | 0x2, None, 3, 0x80, None)
|
|
self.assertNotEqual(handle, ctypes.c_void_p(-1).value, ctypes.get_last_error())
|
|
try:
|
|
message = self.stopped_output()
|
|
self.assertIn("Close any running copy", message)
|
|
self.assertIn("writable", message)
|
|
self.assertIn(str(self.destination), message)
|
|
self.assertIn(str(self.source), message)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual((self.out / "Triforce.exe.new").read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin.new").read_bytes(), self.image.read_bytes())
|
|
finally:
|
|
self.assertTrue(kernel.CloseHandle(handle))
|
|
self.finish()
|
|
self.assertEqual(self.destination.read_bytes(), self.source.read_bytes())
|
|
self.assertEqual((self.out / "image.bin").read_bytes(), self.image.read_bytes())
|
|
self.assert_no_staging_files()
|
|
|
|
@unittest.skipUnless(os.name == "nt", "Windows read-only destination contract")
|
|
def test_readonly_destination_is_not_removed_or_unlocked(self):
|
|
self.destination.chmod(stat.S_IREAD)
|
|
message = self.stopped_output()
|
|
self.assertIn("writable", message)
|
|
self.assertNotIn("the game is running", message)
|
|
self.assert_installed_unchanged()
|
|
self.assertFalse(self.destination.stat().st_mode & stat.S_IWRITE)
|
|
|
|
@unittest.skipUnless(os.name == "nt", "Windows read-only staging-file contract")
|
|
def test_readonly_existing_stage_is_not_removed_or_unlocked(self):
|
|
staged = self.out / "Triforce.exe.new"
|
|
staged.write_bytes(b"pre-existing staged content")
|
|
staged.chmod(stat.S_IREAD)
|
|
with mock.patch.object(make_game.os, "chmod", wraps=make_game.os.chmod) as chmod:
|
|
message = self.stopped_output()
|
|
chmod.assert_not_called()
|
|
self.assertIn(str(staged), message)
|
|
self.assertIn("writable", message)
|
|
self.assert_installed_unchanged()
|
|
self.assertEqual(staged.read_bytes(), b"pre-existing staged content")
|
|
self.assertFalse(staged.stat().st_mode & stat.S_IWRITE)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|