From d86fda0c700b2af30c5e843dcb47ed6b3bf4a476 Mon Sep 17 00:00:00 2001 From: Eric Pouech Date: Thu, 24 Mar 2022 08:35:24 +0100 Subject: [PATCH] ntdll/tests: Enable compilation with long types in threadpool.c. Signed-off-by: Eric Pouech Signed-off-by: Alexandre Julliard --- dlls/ntdll/tests/threadpool.c | 749 +++++++++++++++++----------------- 1 file changed, 375 insertions(+), 374 deletions(-) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index 6c28d0642d7..80a36fc71cf 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -17,6 +17,7 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#undef WINE_NO_LONG_TYPES /* temporary for migration */ #define NONAMELESSSTRUCT #define NONAMELESSUNION @@ -130,32 +131,32 @@ static void test_RtlQueueWorkItem(void) DWORD result; semaphore = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEDEFAULT); - ok(!status, "RtlQueueWorkItem failed with status %x\n", status); + ok(!status, "RtlQueueWorkItem failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEINIOTHREAD); - ok(!status, "RtlQueueWorkItem failed with status %x\n", status); + ok(!status, "RtlQueueWorkItem failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEINPERSISTENTTHREAD); - ok(!status, "RtlQueueWorkItem failed with status %x\n", status); + ok(!status, "RtlQueueWorkItem failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTELONGFUNCTION); - ok(!status, "RtlQueueWorkItem failed with status %x\n", status); + ok(!status, "RtlQueueWorkItem failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_TRANSFER_IMPERSONATION); - ok(!status, "RtlQueueWorkItem failed with status %x\n", status); + ok(!status, "RtlQueueWorkItem failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); CloseHandle(semaphore); } @@ -184,7 +185,7 @@ static void CALLBACK rtl_wait_cb(void *userdata, BOOLEAN timeout) if (info->semaphore2) { result = WaitForSingleObject(info->semaphore2, 200); - ok(result == info->wait_result, "expected %u, got %u\n", info->wait_result, result); + ok(result == info->wait_result, "expected %lu, got %lu\n", info->wait_result, result); ReleaseSemaphore(info->semaphore1, 1, NULL); } } @@ -219,257 +220,257 @@ static void test_RtlRegisterWait(void) wait1 = NULL; info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ok(wait1 != NULL, "expected wait1 != NULL\n"); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); /* infinite timeout, signal the semaphore two times */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 2, "expected info.userdata = 2, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* repeat test with WT_EXECUTEONLYONCE */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* finite timeout, no event */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* finite timeout, with event */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* test RtlRegisterWait WT_EXECUTEINWAITTHREAD flag */ info.userdata = 0; info.threadid = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); - ok(info.threadid && info.threadid != GetCurrentThreadId(), "unexpected wait thread id %x\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); + ok(info.threadid && info.threadid != GetCurrentThreadId(), "unexpected wait thread id %lx\n", info.threadid); threadid = info.threadid; result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); info.userdata = 0; info.threadid = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); - ok(info.threadid == threadid, "unexpected different wait thread id %x\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); + ok(info.threadid == threadid, "unexpected different wait thread id %lx\n", info.threadid); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* test RtlRegisterWait WT_EXECUTEINWAITTHREAD flag with 0 timeout */ info.userdata = 0; info.threadid = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); - ok(info.threadid == threadid, "unexpected different wait thread id %x\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); + ok(info.threadid == threadid, "unexpected different wait thread id %lx\n", info.threadid); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* test RtlRegisterWait WT_EXECUTEINWAITTHREAD flag with already signaled event */ info.userdata = 0; info.threadid = 0; ReleaseSemaphore(semaphores[1], 1, NULL); status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); - ok(info.threadid == threadid, "unexpected different wait thread id %x\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); + ok(info.threadid == threadid, "unexpected different wait thread id %lx\n", info.threadid); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* test for IO threads */ info.userdata = 0; info.threadid = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEINIOTHREAD); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); - ok(info.threadid != 0, "expected info.threadid != 0, got %u\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); + ok(info.threadid != 0, "expected info.threadid != 0, got %lu\n", info.threadid); thread = OpenThread(THREAD_SET_CONTEXT, FALSE, info.threadid); - ok(thread != NULL, "OpenThread failed with %u\n", GetLastError()); + ok(thread != NULL, "OpenThread failed with %lu\n", GetLastError()); rtl_wait_apc_semaphore = semaphores[0]; result = QueueUserAPC(rtl_wait_apc_cb, thread, 0); - ok(result != 0, "QueueUserAPC failed with %u\n", GetLastError()); + ok(result != 0, "QueueUserAPC failed with %lu\n", GetLastError()); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); rtl_wait_apc_semaphore = 0; CloseHandle(thread); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 2, "expected info.userdata = 2, got %lu\n", info.userdata); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); info.userdata = 0; info.threadid = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); - ok(info.threadid != 0, "expected info.threadid != 0, got %u\n", info.threadid); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); + ok(info.threadid != 0, "expected info.threadid != 0, got %lu\n", info.threadid); thread = OpenThread(THREAD_SET_CONTEXT, FALSE, info.threadid); - ok(thread != NULL, "OpenThread failed with %u\n", GetLastError()); + ok(thread != NULL, "OpenThread failed with %lu\n", GetLastError()); rtl_wait_apc_semaphore = semaphores[0]; result = QueueUserAPC(rtl_wait_apc_cb, thread, 0); - ok(result != 0, "QueueUserAPC failed with %u\n", GetLastError()); + ok(result != 0, "QueueUserAPC failed with %lu\n", GetLastError()); result = WaitForSingleObject(semaphores[0], 200); ok(result == WAIT_TIMEOUT || broken(result == WAIT_OBJECT_0) /* >= Win Vista */, - "WaitForSingleObject returned %u\n", result); + "WaitForSingleObject returned %lu\n", result); rtl_wait_apc_semaphore = 0; CloseHandle(thread); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 2, "expected info.userdata = 2, got %lu\n", info.userdata); Sleep(50); status = RtlDeregisterWait(wait1); - ok(!status, "RtlDeregisterWait failed with status %x\n", status); + ok(!status, "RtlDeregisterWait failed with status %lx\n", status); /* test RtlDeregisterWaitEx before wait expired */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); status = RtlDeregisterWaitEx(wait1, NULL); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); status = RtlDeregisterWaitEx(wait1, event); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(event, 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test RtlDeregisterWaitEx after wait expired */ info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); Sleep(50); status = RtlDeregisterWaitEx(wait1, NULL); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); Sleep(50); status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); Sleep(50); status = RtlDeregisterWaitEx(wait1, event); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(event, 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test RtlDeregisterWaitEx while callback is running */ info.semaphore2 = semaphores[1]; @@ -477,84 +478,84 @@ static void test_RtlRegisterWait(void) info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWait(wait1); - ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status); + ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWait(wait1); - ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status); + ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWaitEx(wait1, NULL); - ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status); + ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); info.wait_result = WAIT_TIMEOUT; info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); info.wait_result = WAIT_TIMEOUT; info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE); - ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status); + ok(!status, "RtlDeregisterWaitEx failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); info.wait_result = WAIT_OBJECT_0; info.userdata = 0; status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE); - ok(!status, "RtlRegisterWait failed with status %x\n", status); + ok(!status, "RtlRegisterWait failed with status %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); status = RtlDeregisterWaitEx(wait1, event); - ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status); + ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(event, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[0], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); CloseHandle(semaphores[0]); CloseHandle(semaphores[1]); @@ -586,21 +587,21 @@ static void test_tp_simple(void) int i; semaphore = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* post the callback using the default threadpool */ memset(&environment, 0, sizeof(environment)); environment.Version = 1; environment.Pool = NULL; status = pTpSimpleTryPost(simple_cb, semaphore, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* post the callback using the new threadpool */ @@ -608,9 +609,9 @@ static void test_tp_simple(void) environment.Version = 1; environment.Pool = pool; status = pTpSimpleTryPost(simple_cb, semaphore, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test with environment version 3 */ memset(&environment3, 0, sizeof(environment3)); @@ -622,15 +623,15 @@ static void test_tp_simple(void) { environment3.CallbackPriority = TP_CALLBACK_PRIORITY_HIGH + i; status = pTpSimpleTryPost(simple_cb, semaphore, (TP_CALLBACK_ENVIRON *)&environment3); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } environment3.CallbackPriority = 10; status = pTpSimpleTryPost(simple_cb, semaphore, (TP_CALLBACK_ENVIRON *)&environment3); ok(status == STATUS_INVALID_PARAMETER || broken(!status) /* Vista does not support priorities */, - "TpSimpleTryPost failed with status %x\n", status); + "TpSimpleTryPost failed with status %lx\n", status); /* test with invalid version number */ memset(&environment, 0, sizeof(environment)); @@ -639,17 +640,17 @@ static void test_tp_simple(void) status = pTpSimpleTryPost(simple_cb, semaphore, &environment); todo_wine ok(status == STATUS_INVALID_PARAMETER || broken(!status) /* Vista/2008 */, - "TpSimpleTryPost unexpectedly returned status %x\n", status); + "TpSimpleTryPost unexpectedly returned status %lx\n", status); if (!status) { result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } /* allocate a cleanup group for synchronization */ group = NULL; status = pTpAllocCleanupGroup(&group); - ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(!status, "TpAllocCleanupGroup failed with status %lx\n", status); ok(group != NULL, "expected pool != NULL\n"); /* use cleanup group to wait for a simple callback */ @@ -659,9 +660,9 @@ static void test_tp_simple(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpSimpleTryPost(simple2_cb, &userdata, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); - ok(userdata == 1, "expected userdata = 1, got %u\n", userdata); + ok(userdata == 1, "expected userdata = 1, got %lu\n", userdata); /* test cancellation of pending simple callbacks */ userdata = 0; @@ -673,10 +674,10 @@ static void test_tp_simple(void) for (i = 0; i < 100; i++) { status = pTpSimpleTryPost(simple2_cb, &userdata, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); } pTpReleaseCleanupGroupMembers(group, TRUE, NULL); - ok(userdata < 100, "expected userdata < 100, got %u\n", userdata); + ok(userdata < 100, "expected userdata < 100, got %lu\n", userdata); /* cleanup */ pTpReleaseCleanupGroup(group); @@ -708,7 +709,7 @@ static void test_tp_work(void) /* allocate new threadpool with only one thread */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); pTpSetPoolMaxThreads(pool, 1); @@ -718,7 +719,7 @@ static void test_tp_work(void) environment.Version = 1; environment.Pool = pool; status = pTpAllocWork(&work, work_cb, &userdata, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); /* post 5 identical work items at once */ @@ -726,14 +727,14 @@ static void test_tp_work(void) for (i = 0; i < 5; i++) pTpPostWork(work); pTpWaitForWork(work, FALSE); - ok(userdata == 5, "expected userdata = 5, got %u\n", userdata); + ok(userdata == 5, "expected userdata = 5, got %lu\n", userdata); /* add more tasks and cancel them immediately */ userdata = 0; for (i = 0; i < 10; i++) pTpPostWork(work); pTpWaitForWork(work, TRUE); - ok(userdata < 10, "expected userdata < 10, got %u\n", userdata); + ok(userdata < 10, "expected userdata < 10, got %lu\n", userdata); /* cleanup */ pTpReleaseWork(work); @@ -753,14 +754,14 @@ static void test_tp_work_scheduler(void) /* allocate new threadpool with only one thread */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); pTpSetPoolMaxThreads(pool, 1); /* create a cleanup group */ group = NULL; status = pTpAllocCleanupGroup(&group); - ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(!status, "TpAllocCleanupGroup failed with status %lx\n", status); ok(group != NULL, "expected pool != NULL\n"); /* the first work item has no cleanup group associated */ @@ -769,7 +770,7 @@ static void test_tp_work_scheduler(void) environment.Version = 1; environment.Pool = pool; status = pTpAllocWork(&work, work_cb, &userdata, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); /* allocate a second work item with a cleanup group */ @@ -779,7 +780,7 @@ static void test_tp_work_scheduler(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocWork(&work2, work2_cb, &userdata, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work2 != NULL, "expected work2 != NULL\n"); /* the 'work' callbacks are not blocking execution of 'work2' callbacks */ @@ -791,8 +792,8 @@ static void test_tp_work_scheduler(void) Sleep(500); pTpWaitForWork(work, TRUE); pTpWaitForWork(work2, TRUE); - ok(userdata & 0xffff, "expected userdata & 0xffff != 0, got %u\n", userdata & 0xffff); - ok(userdata >> 16, "expected userdata >> 16 != 0, got %u\n", userdata >> 16); + ok(userdata & 0xffff, "expected userdata & 0xffff != 0, got %lu\n", userdata & 0xffff); + ok(userdata >> 16, "expected userdata >> 16 != 0, got %lu\n", userdata >> 16); /* test TpReleaseCleanupGroupMembers on a work item */ userdata = 0; @@ -802,8 +803,8 @@ static void test_tp_work_scheduler(void) pTpPostWork(work2); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); pTpWaitForWork(work, TRUE); - ok((userdata & 0xffff) < 10, "expected userdata & 0xffff < 10, got %u\n", userdata & 0xffff); - ok((userdata >> 16) == 3, "expected userdata >> 16 == 3, got %u\n", userdata >> 16); + ok((userdata & 0xffff) < 10, "expected userdata & 0xffff < 10, got %lu\n", userdata & 0xffff); + ok((userdata >> 16) == 3, "expected userdata >> 16 == 3, got %lu\n", userdata >> 16); /* cleanup */ pTpReleaseWork(work); @@ -857,18 +858,18 @@ static void test_tp_group_wait(void) DWORD result; semaphore = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* allocate a cleanup group */ group = NULL; status = pTpAllocCleanupGroup(&group); - ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(!status, "TpAllocCleanupGroup failed with status %lx\n", status); ok(group != NULL, "expected pool != NULL\n"); /* release work object during TpReleaseCleanupGroupMembers */ @@ -878,11 +879,11 @@ static void test_tp_group_wait(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocWork(&work, work_release_cb, semaphore, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); /* release timer object during TpReleaseCleanupGroupMembers */ @@ -892,12 +893,12 @@ static void test_tp_group_wait(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocTimer(&timer, timer_release_cb, semaphore, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer != NULL, "expected timer != NULL\n"); when.QuadPart = 0; pTpSetTimer(timer, &when, 0, 0); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); /* release wait object during TpReleaseCleanupGroupMembers */ @@ -907,12 +908,12 @@ static void test_tp_group_wait(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocWait(&wait, wait_release_cb, semaphore, &environment); - ok(!status, "TpAllocWait failed with status %x\n", status); + ok(!status, "TpAllocWait failed with status %lx\n", status); ok(wait != NULL, "expected wait != NULL\n"); when.QuadPart = 0; pTpSetWait(wait, INVALID_HANDLE_VALUE, &when); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); /* cleanup */ @@ -932,13 +933,13 @@ static void CALLBACK simple_group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void status = pTpCallbackMayRunLong(instance); ok(status == STATUS_TOO_MANY_THREADS || broken(status == 1) /* Win Vista / 2008 */, - "expected STATUS_TOO_MANY_THREADS, got %08x\n", status); + "expected STATUS_TOO_MANY_THREADS, got %08lx\n", status); ReleaseSemaphore(semaphores[1], 1, NULL); for (i = 0; i < 4; i++) { result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } ReleaseSemaphore(semaphores[1], 1, NULL); } @@ -950,7 +951,7 @@ static void CALLBACK work_group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void * ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); } static void CALLBACK group_cancel_cleanup_release_cb(void *object, void *userdata) @@ -1016,21 +1017,21 @@ static void test_tp_group_cancel(void) int i; semaphores[0] = CreateSemaphoreA(NULL, 0, 4, NULL); - ok(semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphores[0] != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphores[1] != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* allocate new threadpool with only one thread */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); pTpSetPoolMaxThreads(pool, 1); /* allocate a cleanup group */ group = NULL; status = pTpAllocCleanupGroup(&group); - ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(!status, "TpAllocCleanupGroup failed with status %lx\n", status); ok(group != NULL, "expected pool != NULL\n"); /* test execution of cancellation callback */ @@ -1038,9 +1039,9 @@ static void test_tp_group_cancel(void) environment.Version = 1; environment.Pool = pool; status = pTpSimpleTryPost(simple_group_cancel_cb, semaphores, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); memset(&environment, 0, sizeof(environment)); environment.Version = 1; @@ -1048,28 +1049,28 @@ static void test_tp_group_cancel(void) environment.CleanupGroup = group; environment.CleanupGroupCancelCallback = group_cancel_cleanup_release_cb; status = pTpSimpleTryPost(unexpected_simple_cb, (void *)0xdeadbeef, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); work = NULL; status = pTpAllocWork(&work, unexpected_work_cb, (void *)0xdeadbeef, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); timer = NULL; status = pTpAllocTimer(&timer, unexpected_timer_cb, (void *)0xdeadbeef, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer != NULL, "expected timer != NULL\n"); wait = NULL; status = pTpAllocWait(&wait, unexpected_wait_cb, (void *)0xdeadbeef, &environment); - ok(!status, "TpAllocWait failed with status %x\n", status); + ok(!status, "TpAllocWait failed with status %lx\n", status); ok(wait != NULL, "expected wait != NULL\n"); group_cancel_tid = 0xdeadbeef; pTpReleaseCleanupGroupMembers(group, TRUE, semaphores); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n", + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %lx, got %lx\n", GetCurrentThreadId(), group_cancel_tid); /* test if cancellation callbacks are executed before or after wait */ @@ -1080,19 +1081,19 @@ static void test_tp_group_cancel(void) environment.CleanupGroup = group; environment.CleanupGroupCancelCallback = group_cancel_cleanup_release2_cb; status = pTpAllocWork(&work, work_group_cancel_cb, semaphores, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); pTpPostWork(work); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); group_cancel_tid = 0xdeadbeef; pTpReleaseCleanupGroupMembers(group, TRUE, semaphores); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n", + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %lx, got %lx\n", GetCurrentThreadId(), group_cancel_tid); /* group cancel callback is not executed if object is destroyed while waiting */ @@ -1103,12 +1104,12 @@ static void test_tp_group_cancel(void) environment.CleanupGroup = group; environment.CleanupGroupCancelCallback = unexpected_group_cancel_cleanup_cb; status = pTpAllocWork(&work, work_release_cb, semaphores[1], &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, TRUE, NULL); /* terminated simple callbacks should not trigger the group cancel callback */ @@ -1118,9 +1119,9 @@ static void test_tp_group_cancel(void) environment.CleanupGroup = group; environment.CleanupGroupCancelCallback = unexpected_group_cancel_cleanup_cb; status = pTpSimpleTryPost(simple_release_cb, semaphores[1], &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, TRUE, semaphores); /* test cancellation callback for objects with multiple instances */ @@ -1131,7 +1132,7 @@ static void test_tp_group_cancel(void) environment.CleanupGroup = group; environment.CleanupGroupCancelCallback = group_cancel_cleanup_increment_cb; status = pTpAllocWork(&work, work_cb, &userdata, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); /* post 10 identical work items at once */ @@ -1142,9 +1143,9 @@ static void test_tp_group_cancel(void) /* check if we get multiple cancellation callbacks */ group_cancel_tid = 0xdeadbeef; pTpReleaseCleanupGroupMembers(group, TRUE, &userdata2); - ok(userdata <= 5, "expected userdata <= 5, got %u\n", userdata); - ok(userdata2 == 1, "expected only one cancellation callback, got %u\n", userdata2); - ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n", + ok(userdata <= 5, "expected userdata <= 5, got %lu\n", userdata); + ok(userdata2 == 1, "expected only one cancellation callback, got %lu\n", userdata2); + ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %lx, got %lx\n", GetCurrentThreadId(), group_cancel_tid); /* cleanup */ @@ -1167,7 +1168,7 @@ static void CALLBACK instance_finalization_cb(TP_CALLBACK_INSTANCE *instance, vo Sleep(50); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[1], 1, NULL); } @@ -1187,7 +1188,7 @@ static void test_tp_instance(void) /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* test for TpCallbackReleaseSemaphoreOnCompletion */ @@ -1195,9 +1196,9 @@ static void test_tp_instance(void) environment.Version = 1; environment.Pool = pool; status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test for finalization callback */ memset(&environment, 0, sizeof(environment)); @@ -1205,11 +1206,11 @@ static void test_tp_instance(void) environment.Pool = pool; environment.FinalizationCallback = instance_finalization_cb; status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* cleanup */ pTpReleasePool(pool); @@ -1224,7 +1225,7 @@ static void CALLBACK disassociate_cb(TP_CALLBACK_INSTANCE *instance, void *userd pTpDisassociateCallback(instance); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[1], 1, NULL); } @@ -1235,7 +1236,7 @@ static void CALLBACK disassociate2_cb(TP_CALLBACK_INSTANCE *instance, void *user pTpDisassociateCallback(instance); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[1], 1, NULL); } @@ -1246,7 +1247,7 @@ static void CALLBACK disassociate3_cb(TP_CALLBACK_INSTANCE *instance, void *user pTpDisassociateCallback(instance); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[1], 1, NULL); } @@ -1268,12 +1269,12 @@ static void test_tp_disassociate(void) /* allocate new threadpool and cleanup group */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); group = NULL; status = pTpAllocCleanupGroup(&group); - ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(!status, "TpAllocCleanupGroup failed with status %lx\n", status); ok(group != NULL, "expected pool != NULL\n"); /* test TpDisassociateCallback on work objects without group */ @@ -1282,17 +1283,17 @@ static void test_tp_disassociate(void) environment.Version = 1; environment.Pool = pool; status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); pTpWaitForWork(work, FALSE); result = WaitForSingleObject(semaphores[1], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseWork(work); /* test TpDisassociateCallback on work objects with group (1) */ @@ -1302,17 +1303,17 @@ static void test_tp_disassociate(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); pTpWaitForWork(work, FALSE); result = WaitForSingleObject(semaphores[1], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); /* test TpDisassociateCallback on work objects with group (2) */ @@ -1322,7 +1323,7 @@ static void test_tp_disassociate(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpAllocWork(&work, disassociate2_cb, semaphores, &environment); - ok(!status, "TpAllocWork failed with status %x\n", status); + ok(!status, "TpAllocWork failed with status %lx\n", status); ok(work != NULL, "expected work != NULL\n"); pTpPostWork(work); @@ -1330,9 +1331,9 @@ static void test_tp_disassociate(void) ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test TpDisassociateCallback on simple callbacks */ memset(&environment, 0, sizeof(environment)); @@ -1340,15 +1341,15 @@ static void test_tp_disassociate(void) environment.Pool = pool; environment.CleanupGroup = group; status = pTpSimpleTryPost(disassociate3_cb, semaphores, &environment); - ok(!status, "TpSimpleTryPost failed with status %x\n", status); + ok(!status, "TpSimpleTryPost failed with status %lx\n", status); pTpReleaseCleanupGroupMembers(group, FALSE, NULL); ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* cleanup */ pTpReleaseCleanupGroup(group); @@ -1376,12 +1377,12 @@ static void test_tp_timer(void) int i; semaphore = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* allocate new timer */ @@ -1390,7 +1391,7 @@ static void test_tp_timer(void) environment.Version = 1; environment.Pool = pool; status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer != NULL, "expected timer != NULL\n"); success = pTpIsTimerSet(timer); @@ -1405,9 +1406,9 @@ static void test_tp_timer(void) pTpWaitForTimer(timer, FALSE); result = WaitForSingleObject(semaphore, 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphore, 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); success = pTpIsTimerSet(timer); ok(success, "TpIsTimerSet returned FALSE\n"); @@ -1421,9 +1422,9 @@ static void test_tp_timer(void) pTpWaitForTimer(timer, FALSE); result = WaitForSingleObject(semaphore, 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphore, 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); success = pTpIsTimerSet(timer); ok(success, "TpIsTimerSet returned FALSE\n"); @@ -1436,7 +1437,7 @@ static void test_tp_timer(void) pTpWaitForTimer(timer, FALSE); result = WaitForSingleObject(semaphore, 50); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); success = pTpIsTimerSet(timer); ok(success, "TpIsTimerSet returned FALSE\n"); @@ -1450,7 +1451,7 @@ static void test_tp_timer(void) CloseHandle(semaphore); semaphore = CreateSemaphoreA(NULL, 0, 3, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* allocate a new timer */ timer = NULL; @@ -1458,7 +1459,7 @@ static void test_tp_timer(void) environment.Version = 1; environment.Pool = pool; status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer != NULL, "expected timer != NULL\n"); /* test a relative timeout repeated periodically */ @@ -1472,11 +1473,11 @@ static void test_tp_timer(void) for (i = 0; i < 3; i++) { result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } ticks = GetTickCount() - ticks; ok(ticks >= 500 && (ticks <= 700 || broken(ticks <= 750)) /* Win 7 */, - "expected approximately 600 ticks, got %u\n", ticks); + "expected approximately 600 ticks, got %lu\n", ticks); /* unset the timer */ pTpSetTimer(timer, NULL, 0, 0); @@ -1516,12 +1517,12 @@ static void test_tp_window_length(void) BOOL merged; semaphore = CreateSemaphoreA(NULL, 0, 2, NULL); - ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + ok(semaphore != NULL, "CreateSemaphoreA failed %lu\n", GetLastError()); /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* allocate two identical timers */ @@ -1532,13 +1533,13 @@ static void test_tp_window_length(void) timer1 = NULL; info1.semaphore = semaphore; status = pTpAllocTimer(&timer1, window_length_cb, &info1, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer1 != NULL, "expected timer1 != NULL\n"); timer2 = NULL; info2.semaphore = semaphore; status = pTpAllocTimer(&timer2, window_length_cb, &info2, &environment); - ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(!status, "TpAllocTimer failed with status %lx\n", status); ok(timer2 != NULL, "expected timer2 != NULL\n"); /* choose parameters so that timers are not merged */ @@ -1553,9 +1554,9 @@ static void test_tp_window_length(void) pTpSetTimer(timer1, &when, 0, 75); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); ok(info2.ticks >= info1.ticks + 75 || broken(info2.ticks < info1.ticks + 75) /* Win 2008 */, "expected that timers are not merged\n"); @@ -1572,9 +1573,9 @@ static void test_tp_window_length(void) pTpSetTimer(timer1, &when, 0, 200); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); merged = info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50; ok(merged || broken(!merged) /* Win 10 */, "expected that timers are merged\n"); @@ -1591,9 +1592,9 @@ static void test_tp_window_length(void) pTpSetTimer(timer2, &when, 0, 0); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphore, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); merged = info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50; todo_wine @@ -1621,7 +1622,7 @@ static void CALLBACK wait_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, else if (result == WAIT_TIMEOUT) InterlockedExchangeAdd(&info->userdata, 0x10000); else - ok(0, "unexpected result %u\n", result); + ok(0, "unexpected result %lu\n", result); ReleaseSemaphore(info->semaphore, 1, NULL); } @@ -1645,7 +1646,7 @@ static void test_tp_wait(void) /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); /* allocate new wait items */ @@ -1655,12 +1656,12 @@ static void test_tp_wait(void) wait1 = NULL; status = pTpAllocWait(&wait1, wait_cb, &info, &environment); - ok(!status, "TpAllocWait failed with status %x\n", status); + ok(!status, "TpAllocWait failed with status %lx\n", status); ok(wait1 != NULL, "expected wait1 != NULL\n"); wait2 = NULL; status = pTpAllocWait(&wait2, wait_cb, &info, &environment); - ok(!status, "TpAllocWait failed with status %x\n", status); + ok(!status, "TpAllocWait failed with status %lx\n", status); ok(wait2 != NULL, "expected wait2 != NULL\n"); /* infinite timeout, signal the semaphore immediately */ @@ -1668,79 +1669,79 @@ static void test_tp_wait(void) pTpSetWait(wait1, semaphores[1], NULL); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* relative timeout, no event */ info.userdata = 0; when.QuadPart = (ULONGLONG)200 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* repeat test with call to TpWaitForWait(..., TRUE) */ info.userdata = 0; when.QuadPart = (ULONGLONG)200 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); pTpWaitForWait(wait1, TRUE); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[0], 200); ok(result == WAIT_OBJECT_0 || broken(result == WAIT_TIMEOUT) /* Win 8 */, - "WaitForSingleObject returned %u\n", result); + "WaitForSingleObject returned %lu\n", result); if (result == WAIT_OBJECT_0) - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); else - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* relative timeout, with event */ info.userdata = 0; when.QuadPart = (ULONGLONG)200 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* repeat test with call to TpWaitForWait(..., TRUE) */ info.userdata = 0; when.QuadPart = (ULONGLONG)200 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); pTpWaitForWait(wait1, TRUE); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); ok(result == WAIT_OBJECT_0 || broken(result == WAIT_TIMEOUT) /* Win 8 */, - "WaitForSingleObject returned %u\n", result); + "WaitForSingleObject returned %lu\n", result); if (result == WAIT_OBJECT_0) { - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); } else { - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } /* absolute timeout, no event */ @@ -1749,13 +1750,13 @@ static void test_tp_wait(void) when.QuadPart += (ULONGLONG)200 * 10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[0], 200); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* absolute timeout, with event */ info.userdata = 0; @@ -1763,63 +1764,63 @@ static void test_tp_wait(void) when.QuadPart += (ULONGLONG)200 * 10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* test timeout of zero */ info.userdata = 0; when.QuadPart = 0; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* cancel a pending wait */ info.userdata = 0; when.QuadPart = (ULONGLONG)250 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); pTpSetWait(wait1, NULL, (void *)0xdeadbeef); Sleep(50); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0, "expected info.userdata = 0, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); /* test with INVALID_HANDLE_VALUE */ info.userdata = 0; when.QuadPart = 0; pTpSetWait(wait1, INVALID_HANDLE_VALUE, &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); /* cancel a pending wait with INVALID_HANDLE_VALUE */ info.userdata = 0; when.QuadPart = (ULONGLONG)250 * -10000; pTpSetWait(wait1, semaphores[1], &when); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); when.QuadPart = 0; pTpSetWait(wait1, INVALID_HANDLE_VALUE, &when); Sleep(50); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); CloseHandle(semaphores[1]); semaphores[1] = CreateSemaphoreW(NULL, 0, 2, NULL); @@ -1832,12 +1833,12 @@ static void test_tp_wait(void) Sleep(50); ReleaseSemaphore(semaphores[1], 1, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 1, "expected info.userdata = 1, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* repeat test above with release count 2 */ info.userdata = 0; @@ -1846,12 +1847,12 @@ static void test_tp_wait(void) Sleep(50); result = ReleaseSemaphore(semaphores[1], 2, NULL); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); result = WaitForSingleObject(semaphores[0], 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(info.userdata == 2, "expected info.userdata = 2, got %lu\n", info.userdata); result = WaitForSingleObject(semaphores[1], 0); - ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %lu\n", result); /* cleanup */ pTpReleaseWait(wait1); @@ -1876,7 +1877,7 @@ static void CALLBACK multi_wait_cb(TP_CALLBACK_INSTANCE *instance, void *userdat else if (result == WAIT_TIMEOUT) multi_wait_info.result = 0x10000 | index; else - ok(0, "unexpected result %u\n", result); + ok(0, "unexpected result %lu\n", result); ReleaseSemaphore(multi_wait_info.semaphore, 1, NULL); } @@ -1899,7 +1900,7 @@ static void test_tp_multi_wait(void) /* allocate new threadpool */ pool = NULL; status = pTpAllocPool(&pool, NULL); - ok(!status, "TpAllocPool failed with status %x\n", status); + ok(!status, "TpAllocPool failed with status %lx\n", status); ok(pool != NULL, "expected pool != NULL\n"); memset(&environment, 0, sizeof(environment)); @@ -1914,7 +1915,7 @@ static void test_tp_multi_wait(void) waits[i] = NULL; status = pTpAllocWait(&waits[i], multi_wait_cb, (void *)(DWORD_PTR)i, &environment); - ok(!status, "TpAllocWait failed with status %x\n", status); + ok(!status, "TpAllocWait failed with status %lx\n", status); ok(waits[i] != NULL, "expected waits[%d] != NULL\n", i); pTpSetWait(waits[i], semaphores[i], NULL); @@ -1927,8 +1928,8 @@ static void test_tp_multi_wait(void) ReleaseSemaphore(semaphores[i], 1, NULL); result = WaitForSingleObject(semaphore, 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(multi_wait_info.result == i, "expected result %d, got %u\n", i, multi_wait_info.result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(multi_wait_info.result == i, "expected result %d, got %lu\n", i, multi_wait_info.result); pTpSetWait(waits[i], semaphores[i], NULL); } @@ -1940,8 +1941,8 @@ static void test_tp_multi_wait(void) ReleaseSemaphore(semaphores[i], 1, NULL); result = WaitForSingleObject(semaphore, 100); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - ok(multi_wait_info.result == i, "expected result %d, got %u\n", i, multi_wait_info.result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); + ok(multi_wait_info.result == i, "expected result %d, got %lu\n", i, multi_wait_info.result); pTpSetWait(waits[i], semaphores[i], NULL); } @@ -1957,7 +1958,7 @@ static void test_tp_multi_wait(void) for (i = 0; i < ARRAY_SIZE(semaphores); i++) { result = WaitForSingleObject(semaphore, 150); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu\n", result); } ok(multi_wait_info.result >> 16, "expected multi_wait_info.result >> 16 != 0\n"); @@ -2024,19 +2025,19 @@ static void test_tp_io(void) ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); status = pTpAllocPool(&pool, NULL); - ok(!status, "failed to allocate pool, status %#x\n", status); + ok(!status, "failed to allocate pool, status %#lx\n", status); server = CreateNamedPipeA("\\\\.\\pipe\\wine_tp_test", PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0, 1, 1024, 1024, 0, NULL); - ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %u.\n", GetLastError()); + ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %lu.\n", GetLastError()); client = CreateFileA("\\\\.\\pipe\\wine_tp_test", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0); - ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %u.\n", GetLastError()); + ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %lu.\n", GetLastError()); environment.Pool = pool; io = NULL; status = pTpAllocIoCompletion(&io, server, io_cb, &userdata, &environment); - ok(!status, "got %#x\n", status); + ok(!status, "got %#lx\n", status); ok(!!io, "expected non-NULL TP_IO\n"); pTpWaitForIoCompletion(io, FALSE); @@ -2049,16 +2050,16 @@ static void test_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); pTpWaitForIoCompletion(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == STATUS_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == STATUS_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); ok(!WaitForSingleObject(thread, 1000), "wait timed out\n"); @@ -2070,20 +2071,20 @@ static void test_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = ReadFile(server, in2, sizeof(in2), NULL, &ovl2); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); pTpWaitForIoCompletion(io, FALSE); ok(userdata.count == 2, "callback ran %u times\n", userdata.count); - ok(userdata.ret == STATUS_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == STATUS_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); /* The documentation is a bit unclear about passing TRUE to @@ -2100,7 +2101,7 @@ static void test_tp_io(void) pTpStartAsyncIoOperation(io); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(ret, "wrong ret %d\n", ret); @@ -2108,8 +2109,8 @@ static void test_tp_io(void) pTpWaitForIoCompletion(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == STATUS_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == STATUS_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); userdata.count = 0; @@ -2117,7 +2118,7 @@ static void test_tp_io(void) ret = ReadFile(server, NULL, 1, NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_NOACCESS, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError()); pTpCancelAsyncIoOperation(io); pTpWaitForIoCompletion(io, FALSE); @@ -2128,15 +2129,15 @@ static void test_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = CancelIo(server); - ok(ret, "CancelIo() failed, error %u\n", GetLastError()); + ok(ret, "CancelIo() failed, error %lu\n", GetLastError()); pTpWaitForIoCompletion(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == STATUS_CANCELLED, "got status %#x\n", userdata.ret); - ok(!userdata.length, "got length %lu\n", userdata.length); + ok(userdata.ret == STATUS_CANCELLED, "got status %#lx\n", userdata.ret); + ok(!userdata.length, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); userdata.count = 0; @@ -2145,8 +2146,8 @@ static void test_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); pTpWaitForIoCompletion(io, FALSE); if (0) @@ -2163,10 +2164,10 @@ static void test_tp_io(void) /* Test TPIO object destruction. */ server = CreateNamedPipeA("\\\\.\\pipe\\wine_tp_test", PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0, 1, 1024, 1024, 0, NULL); - ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %u.\n", GetLastError()); + ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %lu.\n", GetLastError()); io = NULL; status = pTpAllocIoCompletion(&io, server, io_cb, &userdata, &environment); - ok(!status, "got %#x\n", status); + ok(!status, "got %#lx\n", status); ret = HeapValidate(GetProcessHeap(), 0, io); ok(ret, "Got unexpected ret %#x.\n", ret); @@ -2178,14 +2179,14 @@ static void test_tp_io(void) server = CreateNamedPipeA("\\\\.\\pipe\\wine_tp_test", PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0, 1, 1024, 1024, 0, NULL); - ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %u.\n", GetLastError()); + ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %lu.\n", GetLastError()); client = CreateFileA("\\\\.\\pipe\\wine_tp_test", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0); - ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %u.\n", GetLastError()); + ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %lu.\n", GetLastError()); io = NULL; status = pTpAllocIoCompletion(&io, server, io_cb, &userdata, &environment); - ok(!status, "got %#x\n", status); + ok(!status, "got %#lx\n", status); pTpStartAsyncIoOperation(io); pTpWaitForIoCompletion(io, TRUE); ret = HeapValidate(GetProcessHeap(), 0, io); @@ -2204,7 +2205,7 @@ static void test_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); Sleep(2000); ret = HeapValidate(GetProcessHeap(), 0, io); ok(!ret, "Got unexpected ret %#x.\n", ret); @@ -2244,14 +2245,14 @@ static void test_kernel32_tp_io(void) ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); status = pTpAllocPool(&pool, NULL); - ok(!status, "failed to allocate pool, status %#x\n", status); + ok(!status, "failed to allocate pool, status %#lx\n", status); server = CreateNamedPipeA("\\\\.\\pipe\\wine_tp_test", PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0, 1, 1024, 1024, 0, NULL); - ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %u.\n", GetLastError()); + ok(server != INVALID_HANDLE_VALUE, "Failed to create server pipe, error %lu.\n", GetLastError()); client = CreateFileA("\\\\.\\pipe\\wine_tp_test", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0); - ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %u.\n", GetLastError()); + ok(client != INVALID_HANDLE_VALUE, "Failed to create client pipe, error %lu.\n", GetLastError()); environment.Pool = pool; io = NULL; @@ -2268,16 +2269,16 @@ static void test_kernel32_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); pWaitForThreadpoolIoCallbacks(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == ERROR_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == ERROR_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); ok(!WaitForSingleObject(thread, 1000), "wait timed out\n"); @@ -2289,20 +2290,20 @@ static void test_kernel32_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = ReadFile(server, in2, sizeof(in2), NULL, &ovl2); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); pWaitForThreadpoolIoCallbacks(io, FALSE); ok(userdata.count == 2, "callback ran %u times\n", userdata.count); - ok(userdata.ret == STATUS_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == STATUS_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); userdata.count = 0; @@ -2313,7 +2314,7 @@ static void test_kernel32_tp_io(void) pStartThreadpoolIo(io); ret = WriteFile(client, out, sizeof(out), &ret_size, NULL); - ok(ret, "WriteFile() failed, error %u\n", GetLastError()); + ok(ret, "WriteFile() failed, error %lu\n", GetLastError()); ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(ret, "wrong ret %d\n", ret); @@ -2321,8 +2322,8 @@ static void test_kernel32_tp_io(void) pWaitForThreadpoolIoCallbacks(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == ERROR_SUCCESS, "got status %#x\n", userdata.ret); - ok(userdata.length == 1, "got length %lu\n", userdata.length); + ok(userdata.ret == ERROR_SUCCESS, "got status %#lx\n", userdata.ret); + ok(userdata.length == 1, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); userdata.count = 0; @@ -2330,7 +2331,7 @@ static void test_kernel32_tp_io(void) ret = ReadFile(server, NULL, 1, NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_NOACCESS, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError()); pCancelThreadpoolIo(io); pWaitForThreadpoolIoCallbacks(io, FALSE); @@ -2341,15 +2342,15 @@ static void test_kernel32_tp_io(void) ret = ReadFile(server, in, sizeof(in), NULL, &ovl); ok(!ret, "wrong ret %d\n", ret); - ok(GetLastError() == ERROR_IO_PENDING, "wrong error %u\n", GetLastError()); + ok(GetLastError() == ERROR_IO_PENDING, "wrong error %lu\n", GetLastError()); ret = CancelIo(server); - ok(ret, "CancelIo() failed, error %u\n", GetLastError()); + ok(ret, "CancelIo() failed, error %lu\n", GetLastError()); pWaitForThreadpoolIoCallbacks(io, FALSE); ok(userdata.count == 1, "callback ran %u times\n", userdata.count); ok(userdata.ovl == &ovl, "expected %p, got %p\n", &ovl, userdata.ovl); - ok(userdata.ret == ERROR_OPERATION_ABORTED, "got status %#x\n", userdata.ret); - ok(!userdata.length, "got length %lu\n", userdata.length); + ok(userdata.ret == ERROR_OPERATION_ABORTED, "got status %#lx\n", userdata.ret); + ok(!userdata.length, "got length %Iu\n", userdata.length); ok(userdata.io == io, "expected %p, got %p\n", io, userdata.io); CloseHandle(ovl.hEvent);