665 lines
30 KiB
Python
665 lines
30 KiB
Python
"""Runtime tests for the reconstructed win32_rrThreads2 translation unit.
|
|
|
|
RED STATE: win32_rrThreads2.c / win32_rrThreads2.h do not exist yet, so
|
|
setUpClass raises "missing win32_rrThreads2 runtime inputs". Every assertion
|
|
below is grounded in iggy-decompiled/raw/durango/win32_rrThreads2.c (cited
|
|
inline) so a faithful DURANGO reconstruction turns these green.
|
|
|
|
Durango-only Win32 threading module (mutex / semaphore / thread / priority).
|
|
The dylib is built for the 64-bit host with
|
|
IGGY_RECONSTRUCT_WIN32_RRTHREADS2_DURANGO selected; Win32 APIs and the three
|
|
Iggy imports are supplied by tests/support/win32_rrThreads2_test_support.c.
|
|
|
|
Struct layout (64-bit DURANGO, from raw decompile):
|
|
Mutex outer: aligned self @ +0x78; flags @ aligned+0x30; handle @ +0x28.
|
|
Semaphore outer: aligned self @ +0x78; handle at *aligned (offset 0).
|
|
Thread outer: aligned desc @ +0xf8; entry@0 name@0x10 handle@0x18
|
|
ret@0x20 tid@0x24 core@0x28.
|
|
"""
|
|
|
|
import ctypes
|
|
from pathlib import Path
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
|
SOURCE = RECONSTRUCTED / "win32_rrThreads2.c"
|
|
HEADER = RECONSTRUCTED / "win32_rrThreads2.h"
|
|
SUPPORT = ROOT / "tests/support/win32_rrThreads2_test_support.c"
|
|
|
|
# Mutex / semaphore outer blob size (room for aligned body + self ptr @ 0x78).
|
|
MUTEX_BLOB = 0x100
|
|
# Thread outer blob (self ptr @ 0xf8).
|
|
THREAD_BLOB = 0x120
|
|
|
|
MUTEX_SELF = 0x78
|
|
MUTEX_HANDLE = 0x28 # relative to aligned body
|
|
MUTEX_FLAGS = 0x30 # relative to aligned body
|
|
SEM_SELF = 0x78
|
|
THREAD_SELF = 0xF8
|
|
THREAD_ENTRY = 0x00
|
|
THREAD_PARAM = 0x08
|
|
THREAD_NAME = 0x10
|
|
THREAD_HANDLE = 0x18
|
|
THREAD_RET = 0x20
|
|
THREAD_TID = 0x24
|
|
THREAD_CORE = 0x28
|
|
|
|
|
|
def align16(addr):
|
|
return (addr + 0xF) & ~0xF
|
|
|
|
|
|
class ReconstructedWin32RrThreads2Tests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
missing = [str(path) for path in (SOURCE, HEADER, SUPPORT)
|
|
if not path.exists()]
|
|
if missing:
|
|
raise AssertionError(
|
|
"missing win32_rrThreads2 runtime inputs: "
|
|
+ ", ".join(missing))
|
|
cls.temp = tempfile.TemporaryDirectory()
|
|
output = Path(cls.temp.name) / "win32_rrThreads2.dylib"
|
|
build = subprocess.run([
|
|
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
|
|
"-Werror", "-Wl,-undefined,dynamic_lookup",
|
|
"-DIGGY_RECONSTRUCT_WIN32_RRTHREADS2_DURANGO=1",
|
|
"-I", str(RECONSTRUCTED),
|
|
str(SOURCE), str(SUPPORT), "-o", str(output),
|
|
], capture_output=True, text=True)
|
|
if build.returncode:
|
|
raise AssertionError(build.stdout + build.stderr)
|
|
cls.lib = ctypes.CDLL(str(output))
|
|
lib = cls.lib
|
|
|
|
# Harness observability.
|
|
lib.win32_rrThreads2_test_reset.argtypes = []
|
|
lib.win32_rrThreads2_test_set_wait_result.argtypes = [ctypes.c_ulong]
|
|
lib.win32_rrThreads2_test_set_create_sem_result.argtypes = [
|
|
ctypes.c_void_p]
|
|
lib.win32_rrThreads2_test_set_try_enter_cs_result.argtypes = [
|
|
ctypes.c_int]
|
|
lib.win32_rrThreads2_test_set_get_thread_priority_result.argtypes = [
|
|
ctypes.c_int]
|
|
lib.win32_rrThreads2_test_set_open_thread_fail_first.argtypes = [
|
|
ctypes.c_int]
|
|
lib.win32_rrThreads2_test_set_create_thread_id.argtypes = [
|
|
ctypes.c_uint]
|
|
lib.win32_rrThreads2_test_set_get_current_thread_id.argtypes = [
|
|
ctypes.c_uint]
|
|
lib.win32_rrThreads2_test_set_get_cpu_core_result.argtypes = [
|
|
ctypes.c_uint]
|
|
lib.win32_rrThreads2_test_set_atomic_add_return.argtypes = [
|
|
ctypes.c_int]
|
|
|
|
for name in (
|
|
"create_mutex_count", "wait_count", "release_mutex_count",
|
|
"create_sem_count", "release_sem_count", "close_handle_count",
|
|
"create_thread_count", "resume_thread_count", "sleep_count",
|
|
"get_current_thread_id_count", "get_current_thread_count",
|
|
"set_thread_priority_count", "get_thread_priority_count",
|
|
"open_thread_count", "set_ideal_processor_count", "init_cs_count",
|
|
"enter_cs_count", "leave_cs_count", "try_enter_cs_count",
|
|
"delete_cs_count", "raise_exception_count", "atomic_add_count",
|
|
"barrier_count", "get_cpu_core_count",
|
|
):
|
|
getattr(lib, f"win32_rrThreads2_test_{name}").restype = (
|
|
ctypes.c_size_t)
|
|
|
|
lib.win32_rrThreads2_test_last_create_mutex_attrs.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_mutex_owner.restype = (
|
|
ctypes.c_int)
|
|
lib.win32_rrThreads2_test_last_create_mutex_name.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_wait_handle.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_wait_millis.restype = ctypes.c_ulong
|
|
lib.win32_rrThreads2_test_last_release_mutex_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_sem_attrs.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_sem_initial.restype = (
|
|
ctypes.c_long)
|
|
lib.win32_rrThreads2_test_last_create_sem_max.restype = ctypes.c_long
|
|
lib.win32_rrThreads2_test_last_create_sem_name.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_sem_flags.restype = (
|
|
ctypes.c_ulong)
|
|
lib.win32_rrThreads2_test_last_create_sem_access.restype = (
|
|
ctypes.c_ulong)
|
|
lib.win32_rrThreads2_test_last_release_sem_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_release_sem_count.restype = (
|
|
ctypes.c_long)
|
|
lib.win32_rrThreads2_test_last_release_sem_prev.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_close_handle.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_create_thread_attrs.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_thread_stack.restype = (
|
|
ctypes.c_ulong)
|
|
lib.win32_rrThreads2_test_last_create_thread_start.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_thread_param.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_create_thread_flags.restype = (
|
|
ctypes.c_ulong)
|
|
lib.win32_rrThreads2_test_last_resume_thread_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_sleep_millis.restype = ctypes.c_ulong
|
|
lib.win32_rrThreads2_test_last_set_thread_priority_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_set_thread_priority_value.restype = (
|
|
ctypes.c_int)
|
|
lib.win32_rrThreads2_test_last_get_thread_priority_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_open_thread_access.restype = (
|
|
ctypes.c_ulong)
|
|
lib.win32_rrThreads2_test_last_open_thread_inherit.restype = (
|
|
ctypes.c_int)
|
|
lib.win32_rrThreads2_test_last_open_thread_id.restype = ctypes.c_uint
|
|
lib.win32_rrThreads2_test_last_set_ideal_handle.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_set_ideal_number_word.restype = (
|
|
ctypes.c_uint)
|
|
lib.win32_rrThreads2_test_last_init_cs_ptr.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_init_cs_spin.restype = ctypes.c_ulong
|
|
lib.win32_rrThreads2_test_last_enter_cs_ptr.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_leave_cs_ptr.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_try_enter_cs_ptr.restype = (
|
|
ctypes.c_void_p)
|
|
lib.win32_rrThreads2_test_last_delete_cs_ptr.restype = ctypes.c_void_p
|
|
lib.win32_rrThreads2_test_last_atomic_add_delta.restype = ctypes.c_int
|
|
lib.win32_rrThreads2_test_last_get_cpu_core_precedence.restype = (
|
|
ctypes.c_int)
|
|
|
|
# Public API.
|
|
lib.rrMutexCreate20.argtypes = [ctypes.c_void_p, ctypes.c_uint]
|
|
lib.rrMutexCreate20.restype = ctypes.c_uint
|
|
lib.rrMutexDestroy20.argtypes = [ctypes.c_void_p]
|
|
lib.rrMutexLock20.argtypes = [ctypes.c_void_p]
|
|
lib.rrMutexLockTimeout20.argtypes = [ctypes.c_void_p, ctypes.c_int]
|
|
lib.rrMutexLockTimeout20.restype = ctypes.c_bool
|
|
lib.rrMutexUnlock20.argtypes = [ctypes.c_void_p]
|
|
|
|
lib.rrSemaphoreCreate20.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_long, ctypes.c_long]
|
|
lib.rrSemaphoreCreate20.restype = ctypes.c_bool
|
|
lib.rrSemaphoreDecrementOrWait20.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_int]
|
|
lib.rrSemaphoreDecrementOrWait20.restype = ctypes.c_bool
|
|
lib.rrSemaphoreDestroy20.argtypes = [ctypes.c_void_p]
|
|
lib.rrSemaphoreIncrement20.argtypes = [ctypes.c_void_p, ctypes.c_long]
|
|
|
|
lib.rrThreadCreate20.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint,
|
|
ctypes.c_longlong, ctypes.c_uint, ctypes.c_void_p]
|
|
lib.rrThreadCreate20.restype = ctypes.c_uint
|
|
lib.rrThreadDestroy20.argtypes = [ctypes.c_void_p]
|
|
lib.rrThreadDestroy20.restype = ctypes.c_uint
|
|
lib.rrThreadGetCore20.argtypes = [ctypes.c_void_p]
|
|
lib.rrThreadGetCore20.restype = ctypes.c_uint
|
|
lib.rrThreadGetCurrentThreadID20.argtypes = [ctypes.c_void_p]
|
|
lib.rrThreadGetName20.argtypes = [ctypes.c_void_p]
|
|
lib.rrThreadGetName20.restype = ctypes.c_void_p
|
|
lib.rrThreadGetOSThreadID20.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_void_p]
|
|
lib.rrThreadNativePriorityHelper.argtypes = [ctypes.c_longlong]
|
|
# Priority values are semantically signed (Win32 THREAD_PRIORITY_* go
|
|
# negative; the passthrough case returns (p<<4)|0xf < 0), so read the
|
|
# ulonglong return register as a signed long long.
|
|
lib.rrThreadNativePriorityHelper.restype = ctypes.c_longlong
|
|
lib.rrThreadPriorityAdd.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_int]
|
|
lib.rrThreadPriorityAdd.restype = ctypes.c_longlong
|
|
lib.rrThreadSetPriorityThreadID.argtypes = [
|
|
ctypes.c_void_p, ctypes.c_longlong]
|
|
lib.rrPlatformHandleGetPriority20.argtypes = [ctypes.c_void_p]
|
|
lib.rrPlatformHandleGetPriority20.restype = ctypes.c_longlong
|
|
lib.rrThreadSleep20.argtypes = [ctypes.c_uint]
|
|
lib.rrThreadSpinHyperYield20.argtypes = []
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.temp.cleanup()
|
|
|
|
def setUp(self):
|
|
self.lib.win32_rrThreads2_test_reset()
|
|
|
|
def mutex_blob(self):
|
|
return (ctypes.c_uint8 * MUTEX_BLOB)()
|
|
|
|
def thread_blob(self):
|
|
return (ctypes.c_uint8 * THREAD_BLOB)()
|
|
|
|
def ptr(self, buf):
|
|
return ctypes.addressof(buf)
|
|
|
|
def read_u32(self, addr):
|
|
return ctypes.c_uint32.from_address(addr).value
|
|
|
|
def write_u32(self, addr, value):
|
|
ctypes.c_uint32.from_address(addr).value = value
|
|
|
|
def read_ptr(self, addr):
|
|
return ctypes.c_void_p.from_address(addr).value or 0
|
|
|
|
def write_ptr(self, addr, value):
|
|
ctypes.c_void_p.from_address(addr).value = value
|
|
|
|
def aligned_body(self, buf, self_off):
|
|
base = self.ptr(buf)
|
|
return self.read_ptr(base + self_off) or align16(base)
|
|
|
|
# ---- Mutex -----------------------------------------------------------
|
|
|
|
def test_mutex_create_kind2_uses_create_mutex_and_flags_0x22(self):
|
|
# raw/durango:39-44 kind==2 → CreateMutexA(0,0,0), barrier, flags=0x22
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
rc = self.lib.rrMutexCreate20(base, 2)
|
|
self.assertEqual(rc, 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_create_mutex_count(), 1)
|
|
self.assertFalse(self.lib.win32_rrThreads2_test_last_create_mutex_attrs())
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_mutex_owner(), 0)
|
|
self.assertFalse(self.lib.win32_rrThreads2_test_last_create_mutex_name())
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_barrier_count(), 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_init_cs_count(), 0)
|
|
body = self.aligned_body(buf, MUTEX_SELF)
|
|
self.assertEqual(body & 0xF, 0)
|
|
self.assertEqual(self.read_u32(body + MUTEX_FLAGS), 0x22)
|
|
handle = self.read_ptr(body + MUTEX_HANDLE)
|
|
self.assertTrue(handle)
|
|
|
|
def test_mutex_create_non_kind2_uses_critical_section_and_or_0x40(self):
|
|
# raw/durango:46-50 InitCS(body, 300), flags |= kind | 0x40
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
rc = self.lib.rrMutexCreate20(base, 1)
|
|
self.assertEqual(rc, 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_create_mutex_count(), 0)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_init_cs_count(), 1)
|
|
body = self.aligned_body(buf, MUTEX_SELF)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_init_cs_ptr(), body)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_init_cs_spin(), 300)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_barrier_count(), 1)
|
|
flags = self.read_u32(body + MUTEX_FLAGS)
|
|
self.assertEqual(flags & 0x40, 0x40)
|
|
self.assertEqual(flags & 1, 1)
|
|
|
|
def test_mutex_destroy_lock_unlock_handle_path(self):
|
|
# raw/durango:68-72, 95-99, 155-159 flags&0x20 → Close/Wait/Release
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrMutexCreate20(base, 2)
|
|
body = self.aligned_body(buf, MUTEX_SELF)
|
|
handle = self.read_ptr(body + MUTEX_HANDLE)
|
|
|
|
self.lib.rrMutexLock20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_wait_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_handle(), handle)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_millis(), 0xFFFFFFFF)
|
|
|
|
self.lib.rrMutexUnlock20(base)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_release_mutex_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_release_mutex_handle(), handle)
|
|
|
|
self.lib.rrMutexDestroy20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_close_handle_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_close_handle(), handle)
|
|
self.assertEqual(self.read_u32(body + MUTEX_FLAGS), 0)
|
|
|
|
def test_mutex_destroy_lock_unlock_critical_section_path(self):
|
|
# raw/durango:74-78, 101-105, 161-165 flags&0x40 → Delete/Enter/Leave
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrMutexCreate20(base, 0)
|
|
body = self.aligned_body(buf, MUTEX_SELF)
|
|
|
|
self.lib.rrMutexLock20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_enter_cs_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_enter_cs_ptr(), body)
|
|
|
|
self.lib.rrMutexUnlock20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_leave_cs_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_leave_cs_ptr(), body)
|
|
|
|
self.lib.rrMutexDestroy20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_delete_cs_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_delete_cs_ptr(), body)
|
|
|
|
def test_mutex_lock_timeout_handle_masks_wait_abandoned(self):
|
|
# raw/durango:128-130 return (result & 0xffffff7f) == 0
|
|
# WAIT_OBJECT_0=0 and WAIT_ABANDONED=0x80 both count as acquired.
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrMutexCreate20(base, 2)
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0)
|
|
self.assertTrue(self.lib.rrMutexLockTimeout20(base, 50))
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_millis(), 50)
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0x80)
|
|
self.assertTrue(self.lib.rrMutexLockTimeout20(base, 10))
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0x102) # WAIT_TIMEOUT
|
|
self.assertFalse(self.lib.rrMutexLockTimeout20(base, 10))
|
|
|
|
def test_mutex_lock_timeout_cs_infinite_vs_try(self):
|
|
# raw/durango:132-138 millis==-1 → EnterCS; else TryEnterCS
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrMutexCreate20(base, 0)
|
|
body = self.aligned_body(buf, MUTEX_SELF)
|
|
|
|
self.assertTrue(self.lib.rrMutexLockTimeout20(base, -1))
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_enter_cs_count(), 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_try_enter_cs_count(), 0)
|
|
|
|
self.lib.win32_rrThreads2_test_set_try_enter_cs_result(1)
|
|
self.assertTrue(self.lib.rrMutexLockTimeout20(base, 0))
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_try_enter_cs_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_try_enter_cs_ptr(), body)
|
|
|
|
self.lib.win32_rrThreads2_test_set_try_enter_cs_result(0)
|
|
self.assertFalse(self.lib.rrMutexLockTimeout20(base, 5))
|
|
|
|
# ---- Semaphore -------------------------------------------------------
|
|
|
|
def test_semaphore_create_args_and_minus_one_sentinel(self):
|
|
# raw/durango:221-224 CreateSemaphoreExW(0,init,max,0,0,0x1F0003)
|
|
# success when handle != -1 (not != NULL).
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.assertTrue(self.lib.rrSemaphoreCreate20(base, 3, 10))
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_create_sem_count(), 1)
|
|
self.assertFalse(
|
|
self.lib.win32_rrThreads2_test_last_create_sem_attrs())
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_sem_initial(), 3)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_sem_max(), 10)
|
|
self.assertFalse(self.lib.win32_rrThreads2_test_last_create_sem_name())
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_sem_flags(), 0)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_sem_access(), 0x1F0003)
|
|
body = self.aligned_body(buf, SEM_SELF)
|
|
self.assertTrue(self.read_ptr(body))
|
|
|
|
# Failure sentinel is -1, not NULL.
|
|
self.lib.win32_rrThreads2_test_reset()
|
|
self.lib.win32_rrThreads2_test_set_create_sem_result(
|
|
ctypes.c_void_p(-1).value)
|
|
buf2 = self.mutex_blob()
|
|
self.assertFalse(self.lib.rrSemaphoreCreate20(self.ptr(buf2), 1, 1))
|
|
|
|
def test_semaphore_decrement_destroy_increment(self):
|
|
# raw/durango:241-242, 256-260, 275 Wait==0; Close if !=-1; Release
|
|
buf = self.mutex_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrSemaphoreCreate20(base, 1, 5)
|
|
body = self.aligned_body(buf, SEM_SELF)
|
|
handle = self.read_ptr(body)
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0)
|
|
self.assertTrue(self.lib.rrSemaphoreDecrementOrWait20(base, 100))
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_handle(), handle)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_millis(), 100)
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0x102)
|
|
self.assertFalse(self.lib.rrSemaphoreDecrementOrWait20(base, 0))
|
|
|
|
self.lib.rrSemaphoreIncrement20(base, 2)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_release_sem_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_release_sem_handle(), handle)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_release_sem_count(), 2)
|
|
self.assertFalse(
|
|
self.lib.win32_rrThreads2_test_last_release_sem_prev())
|
|
|
|
self.lib.rrSemaphoreDestroy20(base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_close_handle_count(), 1)
|
|
self.assertEqual(self.read_ptr(body), ctypes.c_void_p(-1).value)
|
|
|
|
# ---- Priority pure functions -----------------------------------------
|
|
|
|
def test_native_priority_helper_five_cases_and_passthrough(self):
|
|
# raw/durango:384-399 -2→1,-1→2,0→3,1→4,2→5 else (p<<4)|0xf
|
|
h = self.lib.rrThreadNativePriorityHelper
|
|
self.assertEqual(h(-2), 1)
|
|
self.assertEqual(h(-1), 2)
|
|
self.assertEqual(h(0), 3)
|
|
self.assertEqual(h(1), 4)
|
|
self.assertEqual(h(2), 5)
|
|
self.assertEqual(h(-15), ((-15) << 4) | 0xF)
|
|
|
|
def test_thread_priority_add_clamps_and_maps_result(self):
|
|
# raw/durango:404-438 convert RAD to Win32, add, clamp, encode.
|
|
for start, delta, expected in (
|
|
(3, 0, 3), (3, 1, 4), (3, -1, 2),
|
|
(5, 5, 5), (1, -5, 1), (1, 1, 2)):
|
|
self.assertEqual(
|
|
self.lib.rrThreadPriorityAdd(ctypes.c_void_p(start), delta),
|
|
expected, (start, delta))
|
|
|
|
def test_platform_handle_get_priority_maps_same_outputs(self):
|
|
# raw/durango:185-207 OpenThread 0x1000 then 0x400 fallback; encode
|
|
tid = ctypes.c_uint32(0x1234)
|
|
self.lib.win32_rrThreads2_test_set_get_thread_priority_result(-2)
|
|
self.assertEqual(
|
|
self.lib.rrPlatformHandleGetPriority20(ctypes.byref(tid)), 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_open_thread_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_open_thread_access(), 0x1000)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_open_thread_id(), 0x1234)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_close_handle_count(), 1)
|
|
|
|
for win_pri, expected in (
|
|
(-1, 2), (0, 3), (1, 4), (2, 5), (-15, ((-15) << 4) | 0xF)):
|
|
self.lib.win32_rrThreads2_test_reset()
|
|
self.lib.win32_rrThreads2_test_set_get_thread_priority_result(
|
|
win_pri)
|
|
self.assertEqual(
|
|
self.lib.rrPlatformHandleGetPriority20(ctypes.byref(tid)),
|
|
expected, win_pri)
|
|
|
|
# Fallback OpenThread access 0x400 when first returns NULL.
|
|
self.lib.win32_rrThreads2_test_reset()
|
|
self.lib.win32_rrThreads2_test_set_open_thread_fail_first(1)
|
|
self.lib.win32_rrThreads2_test_set_get_thread_priority_result(0)
|
|
self.assertEqual(
|
|
self.lib.rrPlatformHandleGetPriority20(ctypes.byref(tid)), 3)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_open_thread_count(), 2)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_open_thread_access(), 0x400)
|
|
|
|
def test_set_priority_thread_id_noop_on_zero_and_inverse_map(self):
|
|
# raw/durango:452-461 priorityEnum==0 is no-op; else OpenThread+Set
|
|
# Confident inverse pins for RAD 1..5 and 0xf passthrough (e.g. 0x2f→2).
|
|
# RAD 6/7/8 are jump-table relative cases — ambiguous, not pinned.
|
|
tid = ctypes.c_uint32(0x99)
|
|
self.lib.rrThreadSetPriorityThreadID(ctypes.byref(tid), 0)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_open_thread_count(), 0)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_set_thread_priority_count(), 0)
|
|
|
|
for rad, win in ((1, -2), (2, -1), (3, 0), (4, 1), (5, 2), (0x2F, 2)):
|
|
self.lib.win32_rrThreads2_test_reset()
|
|
self.lib.rrThreadSetPriorityThreadID(ctypes.byref(tid), rad)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_open_thread_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_open_thread_access(), 0x400)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_set_thread_priority_value(),
|
|
win, rad)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_close_handle_count(), 1)
|
|
|
|
# ---- Thread lifecycle ------------------------------------------------
|
|
|
|
def test_thread_create_stores_fields_and_always_returns_one(self):
|
|
# raw/durango:294-305 CreateThread CREATE_SUSPENDED(4); set pri;
|
|
# atomic add; set_cpu_core; ResumeThread; always return 1.
|
|
buf = self.thread_blob()
|
|
base = self.ptr(buf)
|
|
entry = ctypes.c_void_p(0x1111)
|
|
param = ctypes.c_void_p(0x2222)
|
|
name = ctypes.c_void_p(0x3333)
|
|
self.lib.win32_rrThreads2_test_set_create_thread_id(0xABCD)
|
|
self.lib.win32_rrThreads2_test_set_atomic_add_return(7)
|
|
|
|
rc = self.lib.rrThreadCreate20(
|
|
base, entry, param, 0x10000, 0, 0, name)
|
|
self.assertEqual(rc, 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_create_thread_count(), 1)
|
|
self.assertFalse(
|
|
self.lib.win32_rrThreads2_test_last_create_thread_attrs())
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_thread_stack(), 0x10000)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_thread_flags(), 4)
|
|
# param is the unaligned outer struct (raw: CreateThread(..., param_1, 4, ...))
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_create_thread_param(), base)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_resume_thread_count(), 1)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_atomic_add_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_atomic_add_delta(), 1)
|
|
|
|
desc = self.aligned_body(buf, THREAD_SELF)
|
|
self.assertEqual(self.read_ptr(desc + THREAD_ENTRY), 0x1111)
|
|
self.assertEqual(self.read_ptr(desc + THREAD_PARAM), 0x2222)
|
|
self.assertEqual(self.read_ptr(desc + THREAD_NAME), 0x3333)
|
|
handle = self.read_ptr(desc + THREAD_HANDLE)
|
|
self.assertTrue(handle)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_resume_thread_handle(), handle)
|
|
self.assertEqual(self.read_u32(desc + THREAD_TID), 0xABCD)
|
|
# coreAffinity==0 → *outCore = 0xffffffff, no SetThreadIdealProcessorEx
|
|
self.assertEqual(self.read_u32(desc + THREAD_CORE), 0xFFFFFFFF)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_set_ideal_processor_count(), 0)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_get_cpu_core_count(), 0)
|
|
|
|
def test_thread_create_core_affinity_bit0_calls_get_cpu_core(self):
|
|
# raw/durango:536-547 bit0 set → rrGetCPUCoreByPrecedence(precedence);
|
|
# if core != -1 → SetThreadIdealProcessorEx with (core&0xff)<<16
|
|
buf = self.thread_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.win32_rrThreads2_test_set_atomic_add_return(2)
|
|
self.lib.win32_rrThreads2_test_set_get_cpu_core_result(5)
|
|
self.lib.rrThreadCreate20(
|
|
base, None, None, 0x1000, 0, 1, None)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_get_cpu_core_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_get_cpu_core_precedence(), 2)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_set_ideal_processor_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_set_ideal_number_word(),
|
|
(5 & 0xFF) << 16)
|
|
desc = self.aligned_body(buf, THREAD_SELF)
|
|
self.assertEqual(self.lib.rrThreadGetCore20(base), 5)
|
|
self.assertEqual(self.read_u32(desc + THREAD_CORE), 5)
|
|
|
|
def test_thread_destroy_wait_close_decrement_returns_seeded_ret(self):
|
|
# raw/durango:320-327 Wait INFINITE; on 0 Close + atomic -1;
|
|
# always return *(desc+0x20) which is never written in this TU.
|
|
buf = self.thread_blob()
|
|
base = self.ptr(buf)
|
|
self.lib.rrThreadCreate20(
|
|
base, None, None, 0x1000, 0, 0, None)
|
|
desc = self.aligned_body(buf, THREAD_SELF)
|
|
handle = self.read_ptr(desc + THREAD_HANDLE)
|
|
self.write_u32(desc + THREAD_RET, 0xC0FFEE)
|
|
|
|
self.lib.win32_rrThreads2_test_set_wait_result(0)
|
|
ret = self.lib.rrThreadDestroy20(base)
|
|
self.assertEqual(ret, 0xC0FFEE)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_handle(), handle)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_wait_millis(), 0xFFFFFFFF)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_close_handle_count(), 1)
|
|
self.assertEqual(self.read_ptr(desc + THREAD_HANDLE),
|
|
ctypes.c_void_p(-1).value)
|
|
# Second atomic call is the -1 decrement (create already did +1).
|
|
self.assertGreaterEqual(
|
|
self.lib.win32_rrThreads2_test_atomic_add_count(), 2)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_atomic_add_delta(), -1)
|
|
|
|
def test_thread_get_name_os_tid_current_id(self):
|
|
# raw/durango:351-352, 363, 373 output-pointer style for IDs
|
|
buf = self.thread_blob()
|
|
base = self.ptr(buf)
|
|
name = ctypes.c_void_p(0xCAFE)
|
|
self.lib.win32_rrThreads2_test_set_create_thread_id(0x4242)
|
|
self.lib.rrThreadCreate20(
|
|
base, None, None, 0x1000, 0, 0, name)
|
|
self.assertEqual(self.lib.rrThreadGetName20(base), 0xCAFE)
|
|
|
|
out_tid = ctypes.c_uint32(0)
|
|
self.lib.rrThreadGetOSThreadID20(base, ctypes.byref(out_tid))
|
|
self.assertEqual(out_tid.value, 0x4242)
|
|
|
|
self.lib.win32_rrThreads2_test_set_get_current_thread_id(0xDEAD)
|
|
cur = ctypes.c_uint32(0)
|
|
self.lib.rrThreadGetCurrentThreadID20(ctypes.byref(cur))
|
|
self.assertEqual(cur.value, 0xDEAD)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_get_current_thread_id_count(), 1)
|
|
|
|
def test_thread_sleep_forwards_millis(self):
|
|
# raw/durango:471-477 tail-call Sleep(millis)
|
|
self.lib.rrThreadSleep20(1234)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_sleep_count(), 1)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_last_sleep_millis(), 1234)
|
|
|
|
def test_thread_spin_hyper_yield_is_true_noop(self):
|
|
# raw/durango:484-487 empty body — surprising but evidenced.
|
|
self.lib.rrThreadSpinHyperYield20()
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_sleep_count(), 0)
|
|
self.assertEqual(self.lib.win32_rrThreads2_test_wait_count(), 0)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_get_current_thread_count(), 0)
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_raise_exception_count(), 0)
|
|
|
|
def test_rr_set_thread_name_not_reachable_from_exports(self):
|
|
# raw/durango:496-509 RaiseException(0x406D1388, ...) — file-static.
|
|
# No caller among the 21 exported functions in this TU, so it is
|
|
# dead-from-the-exported-surface in isolation; skip direct runtime
|
|
# pinning. Documented for the IMPLEMENTATION phase.
|
|
self.lib.rrThreadSpinHyperYield20()
|
|
self.assertEqual(
|
|
self.lib.win32_rrThreads2_test_raise_exception_count(), 0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|