281 lines
11 KiB
Python
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))
|