Files
neoLegacy-mac/tests/test_reconstructed_rrstring.py
2026-07-13 04:57:32 -05:00

281 lines
11 KiB
Python

import ctypes
from pathlib import Path
import subprocess
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
SOURCE = ROOT / "iggy-decompiled/src/reconstructed/rrstring.c"
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
class ReconstructedRrStringTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temporary_directory = tempfile.TemporaryDirectory()
library_path = Path(cls.temporary_directory.name) / "librrstring.dylib"
result = subprocess.run(
[
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
"-Werror", "-I", str(RECONSTRUCTED), str(SOURCE),
"-o", str(library_path),
],
capture_output=True,
text=True,
)
if result.returncode != 0:
raise AssertionError(result.stdout + result.stderr)
cls.library = ctypes.CDLL(str(library_path))
cls.configure_library()
@classmethod
def tearDownClass(cls):
cls.temporary_directory.cleanup()
@classmethod
def configure_library(cls):
cls.library.rrstpcpy.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
cls.library.rrstpcpy.restype = ctypes.c_void_p
cls.library.rrmemset16.argtypes = [
ctypes.c_void_p, ctypes.c_uint16, ctypes.c_uint32,
]
cls.library.rrmemset16.restype = None
cls.library.rrmemset32.argtypes = [
ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32,
]
cls.library.rrmemset32.restype = None
cls.library.rrwcscpy.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
cls.library.rrwcscpy.restype = ctypes.c_void_p
cls.library.rrwcslen.argtypes = [ctypes.c_void_p]
cls.library.rrwcslen.restype = ctypes.c_uint32
for name in ("rrwcscmp", "rrwcsncmp"):
function = getattr(cls.library, name)
function.restype = ctypes.c_int32
cls.library.rrwcscmp.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
cls.library.rrwcsncmp.argtypes = [
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint32,
]
for name in ("rrwcschr", "rrwcsrchr"):
function = getattr(cls.library, name)
function.argtypes = [ctypes.c_void_p, ctypes.c_uint16]
function.restype = ctypes.c_void_p
cls.library.rrwcstol.argtypes = [
ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p), ctypes.c_int32,
]
cls.library.rrwcstol.restype = ctypes.c_int32
@staticmethod
def u16(values, extra=0):
return (ctypes.c_uint16 * (len(values) + 1 + extra))(*values, 0)
def parse(self, text, base):
source = self.u16([ord(character) for character in text])
end = ctypes.c_void_p()
value = self.library.rrwcstol(source, ctypes.byref(end), base)
offset = (end.value - ctypes.addressof(source)) // 2
return value, offset
def test_copy_functions_return_the_written_terminator(self):
source = ctypes.create_string_buffer(b"native")
destination = (ctypes.c_uint8 * 16)(*([0xA5] * 16))
returned = self.library.rrstpcpy(destination, source)
self.assertEqual(returned, ctypes.addressof(destination) + 6)
self.assertEqual(bytes(destination[:8]), b"native\0\xA5")
empty = ctypes.create_string_buffer(b"")
destination = (ctypes.c_uint8 * 4)(*([0xA5] * 4))
returned = self.library.rrstpcpy(destination, empty)
self.assertEqual(returned, ctypes.addressof(destination))
self.assertEqual(list(destination), [0, 0xA5, 0xA5, 0xA5])
wide_source = self.u16([0x0041, 0xD83D, 0xDE00])
wide_destination = (ctypes.c_uint16 * 8)(*([0xA55A] * 8))
returned = self.library.rrwcscpy(wide_destination, wide_source)
self.assertEqual(returned, ctypes.addressof(wide_destination) + 6)
self.assertEqual(
list(wide_destination[:5]),
[0x0041, 0xD83D, 0xDE00, 0, 0xA55A],
)
def test_fixed_width_memsets_cover_alignment_and_zero_counts(self):
words = (ctypes.c_uint32 * 8)(*([0xA5A5A5A5] * 8))
base = ctypes.addressof(words)
self.library.rrmemset16(base, 0x1234, 5)
values16 = (ctypes.c_uint16 * 16).from_address(base)
self.assertEqual(list(values16[:7]), [0x1234] * 5 + [0xA5A5] * 2)
words = (ctypes.c_uint32 * 8)(*([0xA5A5A5A5] * 8))
base = ctypes.addressof(words)
self.assertEqual(base & 3, 0)
self.library.rrmemset16(base + 2, 0xBEEF, 4)
values16 = (ctypes.c_uint16 * 16).from_address(base)
self.assertEqual(
list(values16[:7]),
[0xA5A5, 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF, 0xA5A5, 0xA5A5],
)
original = list(words)
self.library.rrmemset16(base, 0xFFFF, 0)
self.assertEqual(list(words), original)
self.library.rrmemset32(base, 0x89ABCDEF, 3)
self.assertEqual(list(words[:5]), [0x89ABCDEF] * 3 + original[3:5])
original = list(words)
self.library.rrmemset32(base, 0, 0)
self.assertEqual(list(words), original)
def test_length_and_comparisons_use_unsigned_16_bit_code_units(self):
empty = self.u16([])
embedded_null = self.u16([0x0041, 0, 0x0042])
high = self.u16([0xFFFF])
low = self.u16([0x0001])
equal = self.u16([0x0041, 0xFFFF, 0x0042])
self.assertEqual(self.library.rrwcslen(empty), 0)
self.assertEqual(self.library.rrwcslen(embedded_null), 1)
self.assertEqual(self.library.rrwcslen(equal), 3)
self.assertEqual(self.library.rrwcscmp(high, low), 1)
self.assertEqual(self.library.rrwcscmp(low, high), -1)
self.assertEqual(self.library.rrwcscmp(equal, equal), 0)
longer = self.u16([0x0041, 0xFFFF, 0x0043])
self.assertEqual(self.library.rrwcsncmp(equal, longer, 0), 0)
self.assertEqual(self.library.rrwcsncmp(equal, longer, 2), 0)
self.assertEqual(self.library.rrwcsncmp(equal, longer, 3), -1)
self.assertEqual(self.library.rrwcsncmp(None, None, 0), 0)
def test_searches_never_match_the_terminating_zero(self):
text = self.u16([ord("a"), ord("b"), ord("a"), ord("c")])
base = ctypes.addressof(text)
self.assertEqual(self.library.rrwcschr(text, ord("a")), base)
self.assertEqual(self.library.rrwcschr(text, ord("c")), base + 6)
self.assertEqual(self.library.rrwcsrchr(text, ord("a")), base + 4)
self.assertIsNone(self.library.rrwcschr(text, 0))
self.assertIsNone(self.library.rrwcsrchr(text, 0))
empty = self.u16([])
self.assertIsNone(self.library.rrwcschr(empty, ord("a")))
self.assertIsNone(self.library.rrwcsrchr(empty, ord("a")))
def test_integer_parser_clamps_base_and_has_no_prefix_or_whitespace_mode(self):
cases = [
("1012", 2, 5, 3),
("1012", 1, 5, 3),
("Z!", 37, 35, 1),
("0x10", 16, 0, 1),
(" 12", 10, 0, 0),
("+123x", 10, 123, 4),
("-", 10, 0, 1),
("aBc!", 16, 0xABC, 3),
]
for text, base, expected_value, expected_end in cases:
self.assertEqual(
self.parse(text, base),
(expected_value, expected_end),
(text, base),
)
def test_integer_parser_saturates_and_keeps_consuming_digits(self):
cases = [
("2147483647x", 2147483647, 10),
("2147483648x", 2147483647, 10),
("999999999999z", 2147483647, 12),
("-2147483647!", -2147483647, 11),
("-2147483648!", -2147483648, 11),
("-2147483649!", -2147483648, 11),
]
for text, expected_value, expected_end in cases:
self.assertEqual(
self.parse(text, 10),
(expected_value, expected_end),
text,
)
text = self.u16([ord(character) for character in "123"])
self.assertEqual(self.library.rrwcstol(text, None, 10), 123)
def test_object_exports_dependencies_cross_targets_and_cpp_header(self):
temporary_path = Path(self.temporary_directory.name)
object_path = temporary_path / "rrstring.o"
result = subprocess.run(
[
"clang", "-c", "-std=c11", "-O2", "-Wall", "-Wextra",
"-Werror", "-I", str(RECONSTRUCTED), str(SOURCE),
"-o", str(object_path),
],
capture_output=True,
text=True,
)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
nm_result = subprocess.run(
["nm", "-g", str(object_path)], capture_output=True, text=True
)
self.assertEqual(nm_result.returncode, 0, nm_result.stderr)
defined = {
line.split()[-1].removeprefix("_")
for line in nm_result.stdout.splitlines()
if " T " in line
}
undefined = {
line.split()[-1].removeprefix("_")
for line in nm_result.stdout.splitlines()
if " U " in line
}
self.assertEqual(
defined,
{
"rrstpcpy", "rrmemset16", "rrmemset32", "rrwcscpy",
"rrwcslen", "rrwcscmp", "rrwcsncmp", "rrwcschr",
"rrwcsrchr", "rrwcstol",
},
)
self.assertEqual(undefined, set())
cpp_path = temporary_path / "rrstring_cpp_linkage.cpp"
cpp_path.write_text(
'#include "rrstring.h"\n'
"void use_rrstring(uint16_t *wide, char *narrow) {\n"
" (void)rrstpcpy(narrow, narrow);\n"
" (void)rrwcscpy(wide, wide);\n"
" (void)rrwcstol(wide, nullptr, 10);\n"
"}\n",
encoding="utf-8",
)
cpp_result = subprocess.run(
[
"clang++", "-fsyntax-only", "-std=c++17", "-Wall", "-Wextra",
"-Werror", "-I", str(RECONSTRUCTED), str(cpp_path),
],
capture_output=True,
text=True,
)
self.assertEqual(cpp_result.returncode, 0,
cpp_result.stdout + cpp_result.stderr)
cross_targets = {
"durango": ("clang", "x86_64-pc-windows-msvc"),
"orbis": ("clang", "x86_64-unknown-freebsd"),
"vita": ("clang", "armv7a-unknown-linux-gnueabihf"),
}
for candidate in (
Path("/opt/homebrew/opt/llvm/bin/clang"),
Path("/usr/local/opt/llvm/bin/clang"),
):
if candidate.exists():
cross_targets["ps3"] = (
str(candidate), "powerpc-unknown-linux-gnu",
)
break
for platform, (compiler, target) in cross_targets.items():
cross_object = temporary_path / f"rrstring_{platform}.o"
cross_result = subprocess.run(
[
compiler, "-target", target, "-ffreestanding", "-c",
"-std=c11", "-O2", "-Wall", "-Wextra", "-Werror",
"-I", str(RECONSTRUCTED), str(SOURCE),
"-o", str(cross_object),
],
capture_output=True,
text=True,
)
self.assertEqual(cross_result.returncode, 0,
(platform, cross_result.stdout + cross_result.stderr))