[ADVAPI32_WINETEST] Revert service.c changes from 3c1b7834e1 to avoid testbot hangs...
[reactos.git] / modules / rostests / winetests / ntdll / threadpool.c
1 /*
2 * Unit test suite for thread pool functions
3 *
4 * Copyright 2015-2016 Sebastian Lackner
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "ntdll_test.h"
22
23 static HMODULE hntdll = 0;
24 static NTSTATUS (WINAPI *pTpAllocCleanupGroup)(TP_CLEANUP_GROUP **);
25 static NTSTATUS (WINAPI *pTpAllocPool)(TP_POOL **,PVOID);
26 static NTSTATUS (WINAPI *pTpAllocTimer)(TP_TIMER **,PTP_TIMER_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *);
27 static NTSTATUS (WINAPI *pTpAllocWait)(TP_WAIT **,PTP_WAIT_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *);
28 static NTSTATUS (WINAPI *pTpAllocWork)(TP_WORK **,PTP_WORK_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *);
29 static NTSTATUS (WINAPI *pTpCallbackMayRunLong)(TP_CALLBACK_INSTANCE *);
30 static VOID (WINAPI *pTpCallbackReleaseSemaphoreOnCompletion)(TP_CALLBACK_INSTANCE *,HANDLE,DWORD);
31 static VOID (WINAPI *pTpDisassociateCallback)(TP_CALLBACK_INSTANCE *);
32 static BOOL (WINAPI *pTpIsTimerSet)(TP_TIMER *);
33 static VOID (WINAPI *pTpReleaseWait)(TP_WAIT *);
34 static VOID (WINAPI *pTpPostWork)(TP_WORK *);
35 static VOID (WINAPI *pTpReleaseCleanupGroup)(TP_CLEANUP_GROUP *);
36 static VOID (WINAPI *pTpReleaseCleanupGroupMembers)(TP_CLEANUP_GROUP *,BOOL,PVOID);
37 static VOID (WINAPI *pTpReleasePool)(TP_POOL *);
38 static VOID (WINAPI *pTpReleaseTimer)(TP_TIMER *);
39 static VOID (WINAPI *pTpReleaseWork)(TP_WORK *);
40 static VOID (WINAPI *pTpSetPoolMaxThreads)(TP_POOL *,DWORD);
41 static VOID (WINAPI *pTpSetTimer)(TP_TIMER *,LARGE_INTEGER *,LONG,LONG);
42 static VOID (WINAPI *pTpSetWait)(TP_WAIT *,HANDLE,LARGE_INTEGER *);
43 static NTSTATUS (WINAPI *pTpSimpleTryPost)(PTP_SIMPLE_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *);
44 static VOID (WINAPI *pTpWaitForTimer)(TP_TIMER *,BOOL);
45 static VOID (WINAPI *pTpWaitForWait)(TP_WAIT *,BOOL);
46 static VOID (WINAPI *pTpWaitForWork)(TP_WORK *,BOOL);
47
48 #define NTDLL_GET_PROC(func) \
49 do \
50 { \
51 p ## func = (void *)GetProcAddress(hntdll, #func); \
52 if (!p ## func) trace("Failed to get address for %s\n", #func); \
53 } \
54 while (0)
55
56 static BOOL init_threadpool(void)
57 {
58 hntdll = GetModuleHandleA("ntdll");
59 if (!hntdll)
60 {
61 win_skip("Could not load ntdll\n");
62 return FALSE;
63 }
64
65 NTDLL_GET_PROC(TpAllocCleanupGroup);
66 NTDLL_GET_PROC(TpAllocPool);
67 NTDLL_GET_PROC(TpAllocTimer);
68 NTDLL_GET_PROC(TpAllocWait);
69 NTDLL_GET_PROC(TpAllocWork);
70 NTDLL_GET_PROC(TpCallbackMayRunLong);
71 NTDLL_GET_PROC(TpCallbackReleaseSemaphoreOnCompletion);
72 NTDLL_GET_PROC(TpDisassociateCallback);
73 NTDLL_GET_PROC(TpIsTimerSet);
74 NTDLL_GET_PROC(TpPostWork);
75 NTDLL_GET_PROC(TpReleaseCleanupGroup);
76 NTDLL_GET_PROC(TpReleaseCleanupGroupMembers);
77 NTDLL_GET_PROC(TpReleasePool);
78 NTDLL_GET_PROC(TpReleaseTimer);
79 NTDLL_GET_PROC(TpReleaseWait);
80 NTDLL_GET_PROC(TpReleaseWork);
81 NTDLL_GET_PROC(TpSetPoolMaxThreads);
82 NTDLL_GET_PROC(TpSetTimer);
83 NTDLL_GET_PROC(TpSetWait);
84 NTDLL_GET_PROC(TpSimpleTryPost);
85 NTDLL_GET_PROC(TpWaitForTimer);
86 NTDLL_GET_PROC(TpWaitForWait);
87 NTDLL_GET_PROC(TpWaitForWork);
88
89 if (!pTpAllocPool)
90 {
91 win_skip("Threadpool functions not supported, skipping tests\n");
92 return FALSE;
93 }
94
95 return TRUE;
96 }
97
98 #undef NTDLL_GET_PROC
99
100
101 static DWORD CALLBACK rtl_work_cb(void *userdata)
102 {
103 HANDLE semaphore = userdata;
104 trace("Running rtl_work callback\n");
105 ReleaseSemaphore(semaphore, 1, NULL);
106 return 0;
107 }
108
109 static void test_RtlQueueWorkItem(void)
110 {
111 HANDLE semaphore;
112 NTSTATUS status;
113 DWORD result;
114
115 semaphore = CreateSemaphoreA(NULL, 0, 1, NULL);
116 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
117
118 status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEDEFAULT);
119 ok(!status, "RtlQueueWorkItem failed with status %x\n", status);
120 result = WaitForSingleObject(semaphore, 1000);
121 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
122
123 status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEINIOTHREAD);
124 ok(!status, "RtlQueueWorkItem failed with status %x\n", status);
125 result = WaitForSingleObject(semaphore, 1000);
126 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
127
128 status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTEINPERSISTENTTHREAD);
129 ok(!status, "RtlQueueWorkItem failed with status %x\n", status);
130 result = WaitForSingleObject(semaphore, 1000);
131 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
132
133 status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_EXECUTELONGFUNCTION);
134 ok(!status, "RtlQueueWorkItem failed with status %x\n", status);
135 result = WaitForSingleObject(semaphore, 1000);
136 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
137
138 status = RtlQueueWorkItem(rtl_work_cb, semaphore, WT_TRANSFER_IMPERSONATION);
139 ok(!status, "RtlQueueWorkItem failed with status %x\n", status);
140 result = WaitForSingleObject(semaphore, 1000);
141 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
142
143 CloseHandle(semaphore);
144 }
145
146 struct rtl_wait_info
147 {
148 HANDLE semaphore1;
149 HANDLE semaphore2;
150 DWORD wait_result;
151 DWORD threadid;
152 LONG userdata;
153 };
154
155 static void CALLBACK rtl_wait_cb(void *userdata, BOOLEAN timeout)
156 {
157 struct rtl_wait_info *info = userdata;
158 DWORD result;
159
160 trace("Running rtl_wait callback\n");
161
162 if (!timeout)
163 InterlockedIncrement(&info->userdata);
164 else
165 InterlockedExchangeAdd(&info->userdata, 0x10000);
166 info->threadid = GetCurrentThreadId();
167 ReleaseSemaphore(info->semaphore1, 1, NULL);
168
169 if (info->semaphore2)
170 {
171 result = WaitForSingleObject(info->semaphore2, 200);
172 ok(result == info->wait_result, "expected %u, got %u\n", info->wait_result, result);
173 ReleaseSemaphore(info->semaphore1, 1, NULL);
174 }
175 }
176
177 static HANDLE rtl_wait_apc_semaphore;
178
179 static void CALLBACK rtl_wait_apc_cb(ULONG_PTR userdata)
180 {
181 trace("Running rtl_wait_apc callback\n");
182 if (rtl_wait_apc_semaphore)
183 ReleaseSemaphore(rtl_wait_apc_semaphore, 1, NULL);
184 }
185
186 static void test_RtlRegisterWait(void)
187 {
188 HANDLE wait1, event, thread;
189 struct rtl_wait_info info;
190 HANDLE semaphores[2];
191 NTSTATUS status;
192 DWORD result;
193
194 semaphores[0] = CreateSemaphoreW(NULL, 0, 2, NULL);
195 ok(semaphores[0] != NULL, "failed to create semaphore\n");
196 semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL);
197 ok(semaphores[1] != NULL, "failed to create semaphore\n");
198 info.semaphore1 = semaphores[0];
199 info.semaphore2 = NULL;
200
201 event = CreateEventW(NULL, FALSE, FALSE, NULL);
202 ok(event != NULL, "failed to create event\n");
203
204 /* basic test for RtlRegisterWait and RtlDeregisterWait */
205 wait1 = NULL;
206 info.userdata = 0;
207 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
208 ok(!status, "RtlRegisterWait failed with status %x\n", status);
209 ok(wait1 != NULL, "expected wait1 != NULL\n");
210 status = RtlDeregisterWait(wait1);
211 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
212 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
213
214 /* infinite timeout, signal the semaphore two times */
215 info.userdata = 0;
216 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
217 ok(!status, "RtlRegisterWait failed with status %x\n", status);
218 ReleaseSemaphore(semaphores[1], 1, NULL);
219 result = WaitForSingleObject(semaphores[0], 100);
220 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
221 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
222 ReleaseSemaphore(semaphores[1], 1, NULL);
223 result = WaitForSingleObject(semaphores[0], 100);
224 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
225 ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata);
226 result = WaitForSingleObject(semaphores[1], 0);
227 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
228 Sleep(50);
229 status = RtlDeregisterWait(wait1);
230 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
231
232 /* repeat test with WT_EXECUTEONLYONCE */
233 info.userdata = 0;
234 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE);
235 ok(!status, "RtlRegisterWait failed with status %x\n", status);
236 ReleaseSemaphore(semaphores[1], 1, NULL);
237 result = WaitForSingleObject(semaphores[0], 100);
238 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
239 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
240 ReleaseSemaphore(semaphores[1], 1, NULL);
241 result = WaitForSingleObject(semaphores[0], 100);
242 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
243 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
244 result = WaitForSingleObject(semaphores[1], 0);
245 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
246 Sleep(50);
247 status = RtlDeregisterWait(wait1);
248 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
249
250 /* finite timeout, no event */
251 info.userdata = 0;
252 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEDEFAULT);
253 ok(!status, "RtlRegisterWait failed with status %x\n", status);
254 result = WaitForSingleObject(semaphores[0], 100);
255 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
256 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
257 result = WaitForSingleObject(semaphores[0], 200);
258 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
259 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
260 result = WaitForSingleObject(semaphores[1], 0);
261 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
262 Sleep(50);
263 status = RtlDeregisterWait(wait1);
264 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
265
266 /* finite timeout, with event */
267 info.userdata = 0;
268 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 200, WT_EXECUTEDEFAULT);
269 ok(!status, "RtlRegisterWait failed with status %x\n", status);
270 result = WaitForSingleObject(semaphores[0], 100);
271 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
272 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
273 ReleaseSemaphore(semaphores[1], 1, NULL);
274 result = WaitForSingleObject(semaphores[0], 100);
275 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
276 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
277 result = WaitForSingleObject(semaphores[1], 0);
278 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
279 Sleep(50);
280 status = RtlDeregisterWait(wait1);
281 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
282
283 /* test for IO threads */
284 info.userdata = 0;
285 info.threadid = 0;
286 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEINIOTHREAD);
287 ok(!status, "RtlRegisterWait failed with status %x\n", status);
288 ReleaseSemaphore(semaphores[1], 1, NULL);
289 result = WaitForSingleObject(semaphores[0], 100);
290 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
291 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
292 ok(info.threadid != 0, "expected info.threadid != 0, got %u\n", info.threadid);
293 thread = OpenThread(THREAD_SET_CONTEXT, FALSE, info.threadid);
294 ok(thread != NULL, "OpenThread failed with %u\n", GetLastError());
295 rtl_wait_apc_semaphore = semaphores[0];
296 result = QueueUserAPC(rtl_wait_apc_cb, thread, 0);
297 ok(result != 0, "QueueUserAPC failed with %u\n", GetLastError());
298 result = WaitForSingleObject(semaphores[0], 200);
299 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
300 rtl_wait_apc_semaphore = 0;
301 CloseHandle(thread);
302 ReleaseSemaphore(semaphores[1], 1, NULL);
303 result = WaitForSingleObject(semaphores[0], 100);
304 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
305 ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata);
306 Sleep(50);
307 status = RtlDeregisterWait(wait1);
308 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
309
310 info.userdata = 0;
311 info.threadid = 0;
312 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
313 ok(!status, "RtlRegisterWait failed with status %x\n", status);
314 ReleaseSemaphore(semaphores[1], 1, NULL);
315 result = WaitForSingleObject(semaphores[0], 100);
316 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
317 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
318 ok(info.threadid != 0, "expected info.threadid != 0, got %u\n", info.threadid);
319 thread = OpenThread(THREAD_SET_CONTEXT, FALSE, info.threadid);
320 ok(thread != NULL, "OpenThread failed with %u\n", GetLastError());
321 rtl_wait_apc_semaphore = semaphores[0];
322 result = QueueUserAPC(rtl_wait_apc_cb, thread, 0);
323 ok(result != 0, "QueueUserAPC failed with %u\n", GetLastError());
324 result = WaitForSingleObject(semaphores[0], 200);
325 ok(result == WAIT_TIMEOUT || broken(result == WAIT_OBJECT_0) /* >= Win Vista */,
326 "WaitForSingleObject returned %u\n", result);
327 rtl_wait_apc_semaphore = 0;
328 CloseHandle(thread);
329 ReleaseSemaphore(semaphores[1], 1, NULL);
330 result = WaitForSingleObject(semaphores[0], 100);
331 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
332 ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata);
333 Sleep(50);
334 status = RtlDeregisterWait(wait1);
335 ok(!status, "RtlDeregisterWait failed with status %x\n", status);
336
337 /* test RtlDeregisterWaitEx before wait expired */
338 info.userdata = 0;
339 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
340 ok(!status, "RtlRegisterWait failed with status %x\n", status);
341 status = RtlDeregisterWaitEx(wait1, NULL);
342 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
343 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
344
345 info.userdata = 0;
346 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
347 ok(!status, "RtlRegisterWait failed with status %x\n", status);
348 status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE);
349 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
350 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
351
352 info.userdata = 0;
353 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEDEFAULT);
354 ok(!status, "RtlRegisterWait failed with status %x\n", status);
355 status = RtlDeregisterWaitEx(wait1, event);
356 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
357 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
358 result = WaitForSingleObject(event, 200);
359 todo_wine
360 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
361
362 /* test RtlDeregisterWaitEx after wait expired */
363 info.userdata = 0;
364 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE);
365 ok(!status, "RtlRegisterWait failed with status %x\n", status);
366 result = WaitForSingleObject(semaphores[0], 100);
367 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
368 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
369 Sleep(50);
370 status = RtlDeregisterWaitEx(wait1, NULL);
371 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
372 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
373
374 info.userdata = 0;
375 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE);
376 ok(!status, "RtlRegisterWait failed with status %x\n", status);
377 result = WaitForSingleObject(semaphores[0], 100);
378 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
379 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
380 Sleep(50);
381 status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE);
382 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
383 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
384
385 info.userdata = 0;
386 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, 0, WT_EXECUTEONLYONCE);
387 ok(!status, "RtlRegisterWait failed with status %x\n", status);
388 result = WaitForSingleObject(semaphores[0], 100);
389 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
390 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
391 Sleep(50);
392 status = RtlDeregisterWaitEx(wait1, event);
393 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
394 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
395 result = WaitForSingleObject(event, 200);
396 todo_wine
397 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
398
399 /* test RtlDeregisterWaitEx while callback is running */
400 info.semaphore2 = semaphores[1];
401 info.wait_result = WAIT_OBJECT_0;
402
403 info.userdata = 0;
404 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE);
405 ok(!status, "RtlRegisterWait failed with status %x\n", status);
406 ReleaseSemaphore(semaphores[1], 1, NULL);
407 result = WaitForSingleObject(semaphores[0], 1000);
408 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
409 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
410 status = RtlDeregisterWait(wait1);
411 ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status);
412 ReleaseSemaphore(semaphores[1], 1, NULL);
413 result = WaitForSingleObject(semaphores[0], 1000);
414 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
415
416 info.userdata = 0;
417 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE);
418 ok(!status, "RtlRegisterWait failed with status %x\n", status);
419 ReleaseSemaphore(semaphores[1], 1, NULL);
420 result = WaitForSingleObject(semaphores[0], 1000);
421 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
422 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
423 status = RtlDeregisterWaitEx(wait1, NULL);
424 ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status);
425 ReleaseSemaphore(semaphores[1], 1, NULL);
426 result = WaitForSingleObject(semaphores[0], 1000);
427 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
428
429 info.wait_result = WAIT_TIMEOUT;
430 info.userdata = 0;
431 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE);
432 ok(!status, "RtlRegisterWait failed with status %x\n", status);
433 ReleaseSemaphore(semaphores[1], 1, NULL);
434 result = WaitForSingleObject(semaphores[0], 1000);
435 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
436 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
437 status = RtlDeregisterWaitEx(wait1, INVALID_HANDLE_VALUE);
438 ok(!status, "RtlDeregisterWaitEx failed with status %x\n", status);
439 result = WaitForSingleObject(semaphores[0], 0);
440 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
441
442 info.wait_result = WAIT_OBJECT_0;
443 info.userdata = 0;
444 status = RtlRegisterWait(&wait1, semaphores[1], rtl_wait_cb, &info, INFINITE, WT_EXECUTEONLYONCE);
445 ok(!status, "RtlRegisterWait failed with status %x\n", status);
446 ReleaseSemaphore(semaphores[1], 1, NULL);
447 result = WaitForSingleObject(semaphores[0], 1000);
448 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
449 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
450 status = RtlDeregisterWaitEx(wait1, event);
451 ok(status == STATUS_PENDING, "expected STATUS_PENDING, got %x\n", status);
452 ReleaseSemaphore(semaphores[1], 1, NULL);
453 result = WaitForSingleObject(event, 1000);
454 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
455 result = WaitForSingleObject(semaphores[0], 0);
456 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
457
458 CloseHandle(semaphores[0]);
459 CloseHandle(semaphores[1]);
460 CloseHandle(event);
461 }
462
463 static void CALLBACK simple_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
464 {
465 HANDLE semaphore = userdata;
466 trace("Running simple callback\n");
467 ReleaseSemaphore(semaphore, 1, NULL);
468 }
469
470 static void CALLBACK simple2_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
471 {
472 trace("Running simple2 callback\n");
473 Sleep(50);
474 InterlockedIncrement((LONG *)userdata);
475 }
476
477 static void test_tp_simple(void)
478 {
479 TP_CALLBACK_ENVIRON environment;
480 TP_CALLBACK_ENVIRON_V3 environment3;
481 TP_CLEANUP_GROUP *group;
482 HANDLE semaphore;
483 NTSTATUS status;
484 TP_POOL *pool;
485 LONG userdata;
486 DWORD result;
487 int i;
488
489 semaphore = CreateSemaphoreA(NULL, 0, 1, NULL);
490 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
491
492 /* post the callback using the default threadpool */
493 memset(&environment, 0, sizeof(environment));
494 environment.Version = 1;
495 environment.Pool = NULL;
496 status = pTpSimpleTryPost(simple_cb, semaphore, &environment);
497 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
498 result = WaitForSingleObject(semaphore, 1000);
499 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
500
501 /* allocate new threadpool */
502 pool = NULL;
503 status = pTpAllocPool(&pool, NULL);
504 ok(!status, "TpAllocPool failed with status %x\n", status);
505 ok(pool != NULL, "expected pool != NULL\n");
506
507 /* post the callback using the new threadpool */
508 memset(&environment, 0, sizeof(environment));
509 environment.Version = 1;
510 environment.Pool = pool;
511 status = pTpSimpleTryPost(simple_cb, semaphore, &environment);
512 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
513 result = WaitForSingleObject(semaphore, 1000);
514 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
515
516 /* test with environment version 3 */
517 memset(&environment3, 0, sizeof(environment3));
518 environment3.Version = 3;
519 environment3.Pool = pool;
520 environment3.CallbackPriority = TP_CALLBACK_PRIORITY_NORMAL;
521 environment3.Size = sizeof(environment3);
522 status = pTpSimpleTryPost(simple_cb, semaphore, (TP_CALLBACK_ENVIRON *)&environment3);
523 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
524 result = WaitForSingleObject(semaphore, 1000);
525 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
526
527 /* test with invalid version number */
528 memset(&environment, 0, sizeof(environment));
529 environment.Version = 9999;
530 environment.Pool = pool;
531 status = pTpSimpleTryPost(simple_cb, semaphore, &environment);
532 todo_wine
533 ok(status == STATUS_INVALID_PARAMETER || broken(!status) /* Vista/2008 */,
534 "TpSimpleTryPost unexpectedly returned status %x\n", status);
535 if (!status)
536 {
537 result = WaitForSingleObject(semaphore, 1000);
538 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
539 }
540
541 /* allocate a cleanup group for synchronization */
542 group = NULL;
543 status = pTpAllocCleanupGroup(&group);
544 ok(!status, "TpAllocCleanupGroup failed with status %x\n", status);
545 ok(group != NULL, "expected pool != NULL\n");
546
547 /* use cleanup group to wait for a simple callback */
548 userdata = 0;
549 memset(&environment, 0, sizeof(environment));
550 environment.Version = 1;
551 environment.Pool = pool;
552 environment.CleanupGroup = group;
553 status = pTpSimpleTryPost(simple2_cb, &userdata, &environment);
554 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
555 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
556 ok(userdata == 1, "expected userdata = 1, got %u\n", userdata);
557
558 /* test cancellation of pending simple callbacks */
559 userdata = 0;
560 pTpSetPoolMaxThreads(pool, 10);
561 memset(&environment, 0, sizeof(environment));
562 environment.Version = 1;
563 environment.Pool = pool;
564 environment.CleanupGroup = group;
565 for (i = 0; i < 100; i++)
566 {
567 status = pTpSimpleTryPost(simple2_cb, &userdata, &environment);
568 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
569 }
570 pTpReleaseCleanupGroupMembers(group, TRUE, NULL);
571 ok(userdata < 100, "expected userdata < 100, got %u\n", userdata);
572
573 /* cleanup */
574 pTpReleaseCleanupGroup(group);
575 pTpReleasePool(pool);
576 CloseHandle(semaphore);
577 }
578
579 static void CALLBACK work_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
580 {
581 trace("Running work callback\n");
582 Sleep(100);
583 InterlockedIncrement((LONG *)userdata);
584 }
585
586 static void CALLBACK work2_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
587 {
588 trace("Running work2 callback\n");
589 Sleep(100);
590 InterlockedExchangeAdd((LONG *)userdata, 0x10000);
591 }
592
593 static void test_tp_work(void)
594 {
595 TP_CALLBACK_ENVIRON environment;
596 TP_WORK *work;
597 TP_POOL *pool;
598 NTSTATUS status;
599 LONG userdata;
600 int i;
601
602 /* allocate new threadpool with only one thread */
603 pool = NULL;
604 status = pTpAllocPool(&pool, NULL);
605 ok(!status, "TpAllocPool failed with status %x\n", status);
606 ok(pool != NULL, "expected pool != NULL\n");
607 pTpSetPoolMaxThreads(pool, 1);
608
609 /* allocate new work item */
610 work = NULL;
611 memset(&environment, 0, sizeof(environment));
612 environment.Version = 1;
613 environment.Pool = pool;
614 status = pTpAllocWork(&work, work_cb, &userdata, &environment);
615 ok(!status, "TpAllocWork failed with status %x\n", status);
616 ok(work != NULL, "expected work != NULL\n");
617
618 /* post 5 identical work items at once */
619 userdata = 0;
620 for (i = 0; i < 5; i++)
621 pTpPostWork(work);
622 pTpWaitForWork(work, FALSE);
623 ok(userdata == 5, "expected userdata = 5, got %u\n", userdata);
624
625 /* add more tasks and cancel them immediately */
626 userdata = 0;
627 for (i = 0; i < 10; i++)
628 pTpPostWork(work);
629 pTpWaitForWork(work, TRUE);
630 ok(userdata < 10, "expected userdata < 10, got %u\n", userdata);
631
632 /* cleanup */
633 pTpReleaseWork(work);
634 pTpReleasePool(pool);
635 }
636
637 static void test_tp_work_scheduler(void)
638 {
639 TP_CALLBACK_ENVIRON environment;
640 TP_CLEANUP_GROUP *group;
641 TP_WORK *work, *work2;
642 TP_POOL *pool;
643 NTSTATUS status;
644 LONG userdata;
645 int i;
646
647 /* allocate new threadpool with only one thread */
648 pool = NULL;
649 status = pTpAllocPool(&pool, NULL);
650 ok(!status, "TpAllocPool failed with status %x\n", status);
651 ok(pool != NULL, "expected pool != NULL\n");
652 pTpSetPoolMaxThreads(pool, 1);
653
654 /* create a cleanup group */
655 group = NULL;
656 status = pTpAllocCleanupGroup(&group);
657 ok(!status, "TpAllocCleanupGroup failed with status %x\n", status);
658 ok(group != NULL, "expected pool != NULL\n");
659
660 /* the first work item has no cleanup group associated */
661 work = NULL;
662 memset(&environment, 0, sizeof(environment));
663 environment.Version = 1;
664 environment.Pool = pool;
665 status = pTpAllocWork(&work, work_cb, &userdata, &environment);
666 ok(!status, "TpAllocWork failed with status %x\n", status);
667 ok(work != NULL, "expected work != NULL\n");
668
669 /* allocate a second work item with a cleanup group */
670 work2 = NULL;
671 memset(&environment, 0, sizeof(environment));
672 environment.Version = 1;
673 environment.Pool = pool;
674 environment.CleanupGroup = group;
675 status = pTpAllocWork(&work2, work2_cb, &userdata, &environment);
676 ok(!status, "TpAllocWork failed with status %x\n", status);
677 ok(work2 != NULL, "expected work2 != NULL\n");
678
679 /* the 'work' callbacks are not blocking execution of 'work2' callbacks */
680 userdata = 0;
681 for (i = 0; i < 10; i++)
682 pTpPostWork(work);
683 for (i = 0; i < 10; i++)
684 pTpPostWork(work2);
685 Sleep(500);
686 pTpWaitForWork(work, TRUE);
687 pTpWaitForWork(work2, TRUE);
688 ok(userdata & 0xffff, "expected userdata & 0xffff != 0, got %u\n", userdata & 0xffff);
689 ok(userdata >> 16, "expected userdata >> 16 != 0, got %u\n", userdata >> 16);
690
691 /* test TpReleaseCleanupGroupMembers on a work item */
692 userdata = 0;
693 for (i = 0; i < 10; i++)
694 pTpPostWork(work);
695 for (i = 0; i < 3; i++)
696 pTpPostWork(work2);
697 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
698 pTpWaitForWork(work, TRUE);
699 ok((userdata & 0xffff) < 10, "expected userdata & 0xffff < 10, got %u\n", userdata & 0xffff);
700 ok((userdata >> 16) == 3, "expected userdata >> 16 == 3, got %u\n", userdata >> 16);
701
702 /* cleanup */
703 pTpReleaseWork(work);
704 pTpReleaseCleanupGroup(group);
705 pTpReleasePool(pool);
706 }
707
708 static void CALLBACK simple_release_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
709 {
710 HANDLE *semaphores = userdata;
711 trace("Running simple release callback\n");
712 ReleaseSemaphore(semaphores, 1, NULL);
713 Sleep(200); /* wait until main thread is in TpReleaseCleanupGroupMembers */
714 }
715
716 static void CALLBACK work_release_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
717 {
718 HANDLE semaphore = userdata;
719 trace("Running work release callback\n");
720 ReleaseSemaphore(semaphore, 1, NULL);
721 Sleep(200); /* wait until main thread is in TpReleaseCleanupGroupMembers */
722 pTpReleaseWork(work);
723 }
724
725 static void CALLBACK timer_release_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer)
726 {
727 HANDLE semaphore = userdata;
728 trace("Running timer release callback\n");
729 ReleaseSemaphore(semaphore, 1, NULL);
730 Sleep(200); /* wait until main thread is in TpReleaseCleanupGroupMembers */
731 pTpReleaseTimer(timer);
732 }
733
734 static void CALLBACK wait_release_cb(TP_CALLBACK_INSTANCE *instance, void *userdata,
735 TP_WAIT *wait, TP_WAIT_RESULT result)
736 {
737 HANDLE semaphore = userdata;
738 trace("Running wait release callback\n");
739 ReleaseSemaphore(semaphore, 1, NULL);
740 Sleep(200); /* wait until main thread is in TpReleaseCleanupGroupMembers */
741 pTpReleaseWait(wait);
742 }
743
744 static void test_tp_group_wait(void)
745 {
746 TP_CALLBACK_ENVIRON environment;
747 TP_CLEANUP_GROUP *group;
748 LARGE_INTEGER when;
749 HANDLE semaphore;
750 NTSTATUS status;
751 TP_TIMER *timer;
752 TP_WAIT *wait;
753 TP_WORK *work;
754 TP_POOL *pool;
755 DWORD result;
756
757 semaphore = CreateSemaphoreA(NULL, 0, 1, NULL);
758 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
759
760 /* allocate new threadpool */
761 pool = NULL;
762 status = pTpAllocPool(&pool, NULL);
763 ok(!status, "TpAllocPool failed with status %x\n", status);
764 ok(pool != NULL, "expected pool != NULL\n");
765
766 /* allocate a cleanup group */
767 group = NULL;
768 status = pTpAllocCleanupGroup(&group);
769 ok(!status, "TpAllocCleanupGroup failed with status %x\n", status);
770 ok(group != NULL, "expected pool != NULL\n");
771
772 /* release work object during TpReleaseCleanupGroupMembers */
773 work = NULL;
774 memset(&environment, 0, sizeof(environment));
775 environment.Version = 1;
776 environment.Pool = pool;
777 environment.CleanupGroup = group;
778 status = pTpAllocWork(&work, work_release_cb, semaphore, &environment);
779 ok(!status, "TpAllocWork failed with status %x\n", status);
780 ok(work != NULL, "expected work != NULL\n");
781 pTpPostWork(work);
782 result = WaitForSingleObject(semaphore, 1000);
783 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
784 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
785
786 /* release timer object during TpReleaseCleanupGroupMembers */
787 timer = NULL;
788 memset(&environment, 0, sizeof(environment));
789 environment.Version = 1;
790 environment.Pool = pool;
791 environment.CleanupGroup = group;
792 status = pTpAllocTimer(&timer, timer_release_cb, semaphore, &environment);
793 ok(!status, "TpAllocTimer failed with status %x\n", status);
794 ok(timer != NULL, "expected timer != NULL\n");
795 when.QuadPart = 0;
796 pTpSetTimer(timer, &when, 0, 0);
797 result = WaitForSingleObject(semaphore, 1000);
798 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
799 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
800
801 /* release wait object during TpReleaseCleanupGroupMembers */
802 wait = NULL;
803 memset(&environment, 0, sizeof(environment));
804 environment.Version = 1;
805 environment.Pool = pool;
806 environment.CleanupGroup = group;
807 status = pTpAllocWait(&wait, wait_release_cb, semaphore, &environment);
808 ok(!status, "TpAllocWait failed with status %x\n", status);
809 ok(wait != NULL, "expected wait != NULL\n");
810 when.QuadPart = 0;
811 pTpSetWait(wait, INVALID_HANDLE_VALUE, &when);
812 result = WaitForSingleObject(semaphore, 1000);
813 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
814 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
815
816 /* cleanup */
817 pTpReleaseCleanupGroup(group);
818 pTpReleasePool(pool);
819 CloseHandle(semaphore);
820 }
821
822 static DWORD group_cancel_tid;
823
824 static void CALLBACK simple_group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
825 {
826 HANDLE *semaphores = userdata;
827 NTSTATUS status;
828 DWORD result;
829 int i;
830
831 trace("Running simple group cancel callback\n");
832
833 status = pTpCallbackMayRunLong(instance);
834 ok(status == STATUS_TOO_MANY_THREADS || broken(status == 1) /* Win Vista / 2008 */,
835 "expected STATUS_TOO_MANY_THREADS, got %08x\n", status);
836
837 ReleaseSemaphore(semaphores[1], 1, NULL);
838 for (i = 0; i < 4; i++)
839 {
840 result = WaitForSingleObject(semaphores[0], 1000);
841 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
842 }
843 ReleaseSemaphore(semaphores[1], 1, NULL);
844 }
845
846 static void CALLBACK work_group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
847 {
848 HANDLE *semaphores = userdata;
849 DWORD result;
850
851 trace("Running work group cancel callback\n");
852
853 ReleaseSemaphore(semaphores[1], 1, NULL);
854 result = WaitForSingleObject(semaphores[0], 200);
855 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
856 }
857
858 static void CALLBACK group_cancel_cleanup_release_cb(void *object, void *userdata)
859 {
860 HANDLE *semaphores = userdata;
861 trace("Running group cancel cleanup release callback\n");
862 group_cancel_tid = GetCurrentThreadId();
863 ok(object == (void *)0xdeadbeef, "expected 0xdeadbeef, got %p\n", object);
864 ReleaseSemaphore(semaphores[0], 1, NULL);
865 }
866
867 static void CALLBACK group_cancel_cleanup_release2_cb(void *object, void *userdata)
868 {
869 HANDLE *semaphores = userdata;
870 trace("Running group cancel cleanup release2 callback\n");
871 group_cancel_tid = GetCurrentThreadId();
872 ok(object == userdata, "expected %p, got %p\n", userdata, object);
873 ReleaseSemaphore(semaphores[0], 1, NULL);
874 }
875
876 static void CALLBACK group_cancel_cleanup_increment_cb(void *object, void *userdata)
877 {
878 trace("Running group cancel cleanup increment callback\n");
879 group_cancel_tid = GetCurrentThreadId();
880 InterlockedIncrement((LONG *)userdata);
881 }
882
883 static void CALLBACK unexpected_simple_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
884 {
885 ok(0, "Unexpected callback\n");
886 }
887
888 static void CALLBACK unexpected_work_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
889 {
890 ok(0, "Unexpected callback\n");
891 }
892
893 static void CALLBACK unexpected_timer_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer)
894 {
895 ok(0, "Unexpected callback\n");
896 }
897
898 static void CALLBACK unexpected_wait_cb(TP_CALLBACK_INSTANCE *instance, void *userdata,
899 TP_WAIT *wait, TP_WAIT_RESULT result)
900 {
901 ok(0, "Unexpected callback\n");
902 }
903
904 static void CALLBACK unexpected_group_cancel_cleanup_cb(void *object, void *userdata)
905 {
906 ok(0, "Unexpected callback\n");
907 }
908
909 static void test_tp_group_cancel(void)
910 {
911 TP_CALLBACK_ENVIRON environment;
912 TP_CLEANUP_GROUP *group;
913 LONG userdata, userdata2;
914 HANDLE semaphores[2];
915 NTSTATUS status;
916 TP_TIMER *timer;
917 TP_WAIT *wait;
918 TP_WORK *work;
919 TP_POOL *pool;
920 DWORD result;
921 int i;
922
923 semaphores[0] = CreateSemaphoreA(NULL, 0, 4, NULL);
924 ok(semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
925 semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL);
926 ok(semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
927
928 /* allocate new threadpool with only one thread */
929 pool = NULL;
930 status = pTpAllocPool(&pool, NULL);
931 ok(!status, "TpAllocPool failed with status %x\n", status);
932 ok(pool != NULL, "expected pool != NULL\n");
933 pTpSetPoolMaxThreads(pool, 1);
934
935 /* allocate a cleanup group */
936 group = NULL;
937 status = pTpAllocCleanupGroup(&group);
938 ok(!status, "TpAllocCleanupGroup failed with status %x\n", status);
939 ok(group != NULL, "expected pool != NULL\n");
940
941 /* test execution of cancellation callback */
942 memset(&environment, 0, sizeof(environment));
943 environment.Version = 1;
944 environment.Pool = pool;
945 status = pTpSimpleTryPost(simple_group_cancel_cb, semaphores, &environment);
946 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
947 result = WaitForSingleObject(semaphores[1], 1000);
948 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
949
950 memset(&environment, 0, sizeof(environment));
951 environment.Version = 1;
952 environment.Pool = pool;
953 environment.CleanupGroup = group;
954 environment.CleanupGroupCancelCallback = group_cancel_cleanup_release_cb;
955 status = pTpSimpleTryPost(unexpected_simple_cb, (void *)0xdeadbeef, &environment);
956 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
957
958 work = NULL;
959 status = pTpAllocWork(&work, unexpected_work_cb, (void *)0xdeadbeef, &environment);
960 ok(!status, "TpAllocWork failed with status %x\n", status);
961 ok(work != NULL, "expected work != NULL\n");
962
963 timer = NULL;
964 status = pTpAllocTimer(&timer, unexpected_timer_cb, (void *)0xdeadbeef, &environment);
965 ok(!status, "TpAllocTimer failed with status %x\n", status);
966 ok(timer != NULL, "expected timer != NULL\n");
967
968 wait = NULL;
969 status = pTpAllocWait(&wait, unexpected_wait_cb, (void *)0xdeadbeef, &environment);
970 ok(!status, "TpAllocWait failed with status %x\n", status);
971 ok(wait != NULL, "expected wait != NULL\n");
972
973 group_cancel_tid = 0xdeadbeef;
974 pTpReleaseCleanupGroupMembers(group, TRUE, semaphores);
975 result = WaitForSingleObject(semaphores[1], 1000);
976 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
977 ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n",
978 GetCurrentThreadId(), group_cancel_tid);
979
980 /* test if cancellation callbacks are executed before or after wait */
981 work = NULL;
982 memset(&environment, 0, sizeof(environment));
983 environment.Version = 1;
984 environment.Pool = pool;
985 environment.CleanupGroup = group;
986 environment.CleanupGroupCancelCallback = group_cancel_cleanup_release2_cb;
987 status = pTpAllocWork(&work, work_group_cancel_cb, semaphores, &environment);
988 ok(!status, "TpAllocWork failed with status %x\n", status);
989 ok(work != NULL, "expected work != NULL\n");
990 pTpPostWork(work);
991 pTpPostWork(work);
992
993 result = WaitForSingleObject(semaphores[1], 1000);
994 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
995
996 group_cancel_tid = 0xdeadbeef;
997 pTpReleaseCleanupGroupMembers(group, TRUE, semaphores);
998 result = WaitForSingleObject(semaphores[0], 1000);
999 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1000 ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n",
1001 GetCurrentThreadId(), group_cancel_tid);
1002
1003 /* group cancel callback is not executed if object is destroyed while waiting */
1004 work = NULL;
1005 memset(&environment, 0, sizeof(environment));
1006 environment.Version = 1;
1007 environment.Pool = pool;
1008 environment.CleanupGroup = group;
1009 environment.CleanupGroupCancelCallback = unexpected_group_cancel_cleanup_cb;
1010 status = pTpAllocWork(&work, work_release_cb, semaphores[1], &environment);
1011 ok(!status, "TpAllocWork failed with status %x\n", status);
1012 ok(work != NULL, "expected work != NULL\n");
1013 pTpPostWork(work);
1014
1015 result = WaitForSingleObject(semaphores[1], 1000);
1016 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1017 pTpReleaseCleanupGroupMembers(group, TRUE, NULL);
1018
1019 /* terminated simple callbacks should not trigger the group cancel callback */
1020 memset(&environment, 0, sizeof(environment));
1021 environment.Version = 1;
1022 environment.Pool = pool;
1023 environment.CleanupGroup = group;
1024 environment.CleanupGroupCancelCallback = unexpected_group_cancel_cleanup_cb;
1025 status = pTpSimpleTryPost(simple_release_cb, semaphores[1], &environment);
1026 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
1027 result = WaitForSingleObject(semaphores[1], 1000);
1028 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1029 pTpReleaseCleanupGroupMembers(group, TRUE, semaphores);
1030
1031 /* test cancellation callback for objects with multiple instances */
1032 work = NULL;
1033 memset(&environment, 0, sizeof(environment));
1034 environment.Version = 1;
1035 environment.Pool = pool;
1036 environment.CleanupGroup = group;
1037 environment.CleanupGroupCancelCallback = group_cancel_cleanup_increment_cb;
1038 status = pTpAllocWork(&work, work_cb, &userdata, &environment);
1039 ok(!status, "TpAllocWork failed with status %x\n", status);
1040 ok(work != NULL, "expected work != NULL\n");
1041
1042 /* post 10 identical work items at once */
1043 userdata = userdata2 = 0;
1044 for (i = 0; i < 10; i++)
1045 pTpPostWork(work);
1046
1047 /* check if we get multiple cancellation callbacks */
1048 group_cancel_tid = 0xdeadbeef;
1049 pTpReleaseCleanupGroupMembers(group, TRUE, &userdata2);
1050 ok(userdata <= 5, "expected userdata <= 5, got %u\n", userdata);
1051 ok(userdata2 == 1, "expected only one cancellation callback, got %u\n", userdata2);
1052 ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n",
1053 GetCurrentThreadId(), group_cancel_tid);
1054
1055 /* cleanup */
1056 pTpReleaseCleanupGroup(group);
1057 pTpReleasePool(pool);
1058 CloseHandle(semaphores[0]);
1059 CloseHandle(semaphores[1]);
1060 }
1061
1062 static void CALLBACK instance_semaphore_completion_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
1063 {
1064 HANDLE *semaphores = userdata;
1065 trace("Running instance completion callback\n");
1066 pTpCallbackReleaseSemaphoreOnCompletion(instance, semaphores[0], 1);
1067 }
1068
1069 static void CALLBACK instance_finalization_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
1070 {
1071 HANDLE *semaphores = userdata;
1072 DWORD result;
1073
1074 trace("Running instance finalization callback\n");
1075
1076 result = WaitForSingleObject(semaphores[0], 100);
1077 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1078 ReleaseSemaphore(semaphores[1], 1, NULL);
1079 }
1080
1081 static void test_tp_instance(void)
1082 {
1083 TP_CALLBACK_ENVIRON environment;
1084 HANDLE semaphores[2];
1085 NTSTATUS status;
1086 TP_POOL *pool;
1087 DWORD result;
1088
1089 semaphores[0] = CreateSemaphoreW(NULL, 0, 1, NULL);
1090 ok(semaphores[0] != NULL, "failed to create semaphore\n");
1091 semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL);
1092 ok(semaphores[1] != NULL, "failed to create semaphore\n");
1093
1094 /* allocate new threadpool */
1095 pool = NULL;
1096 status = pTpAllocPool(&pool, NULL);
1097 ok(!status, "TpAllocPool failed with status %x\n", status);
1098 ok(pool != NULL, "expected pool != NULL\n");
1099
1100 /* test for TpCallbackReleaseSemaphoreOnCompletion */
1101 memset(&environment, 0, sizeof(environment));
1102 environment.Version = 1;
1103 environment.Pool = pool;
1104 status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment);
1105 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
1106 result = WaitForSingleObject(semaphores[0], 1000);
1107 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1108
1109 /* test for finalization callback */
1110 memset(&environment, 0, sizeof(environment));
1111 environment.Version = 1;
1112 environment.Pool = pool;
1113 environment.FinalizationCallback = instance_finalization_cb;
1114 status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment);
1115 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
1116 result = WaitForSingleObject(semaphores[0], 1000);
1117 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1118 result = WaitForSingleObject(semaphores[1], 1000);
1119 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1120
1121 /* cleanup */
1122 pTpReleasePool(pool);
1123 CloseHandle(semaphores[0]);
1124 CloseHandle(semaphores[1]);
1125 }
1126
1127 static void CALLBACK disassociate_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
1128 {
1129 HANDLE *semaphores = userdata;
1130 DWORD result;
1131
1132 trace("Running disassociate callback\n");
1133
1134 pTpDisassociateCallback(instance);
1135 result = WaitForSingleObject(semaphores[0], 1000);
1136 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1137 ReleaseSemaphore(semaphores[1], 1, NULL);
1138 }
1139
1140 static void CALLBACK disassociate2_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work)
1141 {
1142 HANDLE *semaphores = userdata;
1143 DWORD result;
1144
1145 trace("Running disassociate2 callback\n");
1146
1147 pTpDisassociateCallback(instance);
1148 result = WaitForSingleObject(semaphores[0], 100);
1149 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1150 ReleaseSemaphore(semaphores[1], 1, NULL);
1151 }
1152
1153 static void CALLBACK disassociate3_cb(TP_CALLBACK_INSTANCE *instance, void *userdata)
1154 {
1155 HANDLE *semaphores = userdata;
1156 DWORD result;
1157
1158 trace("Running disassociate3 callback\n");
1159
1160 pTpDisassociateCallback(instance);
1161 result = WaitForSingleObject(semaphores[0], 100);
1162 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1163 ReleaseSemaphore(semaphores[1], 1, NULL);
1164 }
1165
1166 static void test_tp_disassociate(void)
1167 {
1168 TP_CALLBACK_ENVIRON environment;
1169 TP_CLEANUP_GROUP *group;
1170 HANDLE semaphores[2];
1171 NTSTATUS status;
1172 TP_POOL *pool;
1173 TP_WORK *work;
1174 DWORD result;
1175
1176 semaphores[0] = CreateSemaphoreW(NULL, 0, 1, NULL);
1177 ok(semaphores[0] != NULL, "failed to create semaphore\n");
1178 semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL);
1179 ok(semaphores[1] != NULL, "failed to create semaphore\n");
1180
1181 /* allocate new threadpool and cleanup group */
1182 pool = NULL;
1183 status = pTpAllocPool(&pool, NULL);
1184 ok(!status, "TpAllocPool failed with status %x\n", status);
1185 ok(pool != NULL, "expected pool != NULL\n");
1186
1187 group = NULL;
1188 status = pTpAllocCleanupGroup(&group);
1189 ok(!status, "TpAllocCleanupGroup failed with status %x\n", status);
1190 ok(group != NULL, "expected pool != NULL\n");
1191
1192 /* test TpDisassociateCallback on work objects without group */
1193 work = NULL;
1194 memset(&environment, 0, sizeof(environment));
1195 environment.Version = 1;
1196 environment.Pool = pool;
1197 status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment);
1198 ok(!status, "TpAllocWork failed with status %x\n", status);
1199 ok(work != NULL, "expected work != NULL\n");
1200
1201 pTpPostWork(work);
1202 pTpWaitForWork(work, FALSE);
1203
1204 result = WaitForSingleObject(semaphores[1], 100);
1205 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1206 ReleaseSemaphore(semaphores[0], 1, NULL);
1207 result = WaitForSingleObject(semaphores[1], 1000);
1208 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1209 pTpReleaseWork(work);
1210
1211 /* test TpDisassociateCallback on work objects with group (1) */
1212 work = NULL;
1213 memset(&environment, 0, sizeof(environment));
1214 environment.Version = 1;
1215 environment.Pool = pool;
1216 environment.CleanupGroup = group;
1217 status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment);
1218 ok(!status, "TpAllocWork failed with status %x\n", status);
1219 ok(work != NULL, "expected work != NULL\n");
1220
1221 pTpPostWork(work);
1222 pTpWaitForWork(work, FALSE);
1223
1224 result = WaitForSingleObject(semaphores[1], 100);
1225 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1226 ReleaseSemaphore(semaphores[0], 1, NULL);
1227 result = WaitForSingleObject(semaphores[1], 1000);
1228 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1229 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
1230
1231 /* test TpDisassociateCallback on work objects with group (2) */
1232 work = NULL;
1233 memset(&environment, 0, sizeof(environment));
1234 environment.Version = 1;
1235 environment.Pool = pool;
1236 environment.CleanupGroup = group;
1237 status = pTpAllocWork(&work, disassociate2_cb, semaphores, &environment);
1238 ok(!status, "TpAllocWork failed with status %x\n", status);
1239 ok(work != NULL, "expected work != NULL\n");
1240
1241 pTpPostWork(work);
1242 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
1243
1244 ReleaseSemaphore(semaphores[0], 1, NULL);
1245 result = WaitForSingleObject(semaphores[1], 1000);
1246 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1247 result = WaitForSingleObject(semaphores[0], 1000);
1248 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1249
1250 /* test TpDisassociateCallback on simple callbacks */
1251 memset(&environment, 0, sizeof(environment));
1252 environment.Version = 1;
1253 environment.Pool = pool;
1254 environment.CleanupGroup = group;
1255 status = pTpSimpleTryPost(disassociate3_cb, semaphores, &environment);
1256 ok(!status, "TpSimpleTryPost failed with status %x\n", status);
1257
1258 pTpReleaseCleanupGroupMembers(group, FALSE, NULL);
1259
1260 ReleaseSemaphore(semaphores[0], 1, NULL);
1261 result = WaitForSingleObject(semaphores[1], 1000);
1262 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1263 result = WaitForSingleObject(semaphores[0], 1000);
1264 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1265
1266 /* cleanup */
1267 pTpReleaseCleanupGroup(group);
1268 pTpReleasePool(pool);
1269 CloseHandle(semaphores[0]);
1270 CloseHandle(semaphores[1]);
1271 }
1272
1273 static void CALLBACK timer_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer)
1274 {
1275 HANDLE semaphore = userdata;
1276 trace("Running timer callback\n");
1277 ReleaseSemaphore(semaphore, 1, NULL);
1278 }
1279
1280 static void test_tp_timer(void)
1281 {
1282 TP_CALLBACK_ENVIRON environment;
1283 DWORD result, ticks;
1284 LARGE_INTEGER when;
1285 HANDLE semaphore;
1286 NTSTATUS status;
1287 TP_TIMER *timer;
1288 TP_POOL *pool;
1289 BOOL success;
1290 int i;
1291
1292 semaphore = CreateSemaphoreA(NULL, 0, 1, NULL);
1293 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
1294
1295 /* allocate new threadpool */
1296 pool = NULL;
1297 status = pTpAllocPool(&pool, NULL);
1298 ok(!status, "TpAllocPool failed with status %x\n", status);
1299 ok(pool != NULL, "expected pool != NULL\n");
1300
1301 /* allocate new timer */
1302 timer = NULL;
1303 memset(&environment, 0, sizeof(environment));
1304 environment.Version = 1;
1305 environment.Pool = pool;
1306 status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment);
1307 ok(!status, "TpAllocTimer failed with status %x\n", status);
1308 ok(timer != NULL, "expected timer != NULL\n");
1309
1310 success = pTpIsTimerSet(timer);
1311 ok(!success, "TpIsTimerSet returned TRUE\n");
1312
1313 /* test timer with a relative timeout */
1314 when.QuadPart = (ULONGLONG)200 * -10000;
1315 pTpSetTimer(timer, &when, 0, 0);
1316 success = pTpIsTimerSet(timer);
1317 ok(success, "TpIsTimerSet returned FALSE\n");
1318
1319 pTpWaitForTimer(timer, FALSE);
1320
1321 result = WaitForSingleObject(semaphore, 100);
1322 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1323 result = WaitForSingleObject(semaphore, 200);
1324 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1325 success = pTpIsTimerSet(timer);
1326 ok(success, "TpIsTimerSet returned FALSE\n");
1327
1328 /* test timer with an absolute timeout */
1329 NtQuerySystemTime( &when );
1330 when.QuadPart += (ULONGLONG)200 * 10000;
1331 pTpSetTimer(timer, &when, 0, 0);
1332 success = pTpIsTimerSet(timer);
1333 ok(success, "TpIsTimerSet returned FALSE\n");
1334
1335 pTpWaitForTimer(timer, FALSE);
1336
1337 result = WaitForSingleObject(semaphore, 100);
1338 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1339 result = WaitForSingleObject(semaphore, 200);
1340 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1341 success = pTpIsTimerSet(timer);
1342 ok(success, "TpIsTimerSet returned FALSE\n");
1343
1344 /* test timer with zero timeout */
1345 when.QuadPart = 0;
1346 pTpSetTimer(timer, &when, 0, 0);
1347 success = pTpIsTimerSet(timer);
1348 ok(success, "TpIsTimerSet returned FALSE\n");
1349
1350 pTpWaitForTimer(timer, FALSE);
1351
1352 result = WaitForSingleObject(semaphore, 50);
1353 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1354 success = pTpIsTimerSet(timer);
1355 ok(success, "TpIsTimerSet returned FALSE\n");
1356
1357 /* unset the timer */
1358 pTpSetTimer(timer, NULL, 0, 0);
1359 success = pTpIsTimerSet(timer);
1360 ok(!success, "TpIsTimerSet returned TRUE\n");
1361 pTpWaitForTimer(timer, TRUE);
1362
1363 pTpReleaseTimer(timer);
1364 CloseHandle(semaphore);
1365
1366 semaphore = CreateSemaphoreA(NULL, 0, 3, NULL);
1367 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
1368
1369 /* allocate a new timer */
1370 timer = NULL;
1371 memset(&environment, 0, sizeof(environment));
1372 environment.Version = 1;
1373 environment.Pool = pool;
1374 status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment);
1375 ok(!status, "TpAllocTimer failed with status %x\n", status);
1376 ok(timer != NULL, "expected timer != NULL\n");
1377
1378 /* test a relative timeout repeated periodically */
1379 when.QuadPart = (ULONGLONG)200 * -10000;
1380 pTpSetTimer(timer, &when, 200, 0);
1381 success = pTpIsTimerSet(timer);
1382 ok(success, "TpIsTimerSet returned FALSE\n");
1383
1384 /* wait until the timer was triggered three times */
1385 ticks = GetTickCount();
1386 for (i = 0; i < 3; i++)
1387 {
1388 result = WaitForSingleObject(semaphore, 1000);
1389 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1390 }
1391 ticks = GetTickCount() - ticks;
1392 ok(ticks >= 500 && (ticks <= 700 || broken(ticks <= 750)) /* Win 7 */,
1393 "expected approximately 600 ticks, got %u\n", ticks);
1394
1395 /* unset the timer */
1396 pTpSetTimer(timer, NULL, 0, 0);
1397 success = pTpIsTimerSet(timer);
1398 ok(!success, "TpIsTimerSet returned TRUE\n");
1399 pTpWaitForTimer(timer, TRUE);
1400
1401 /* cleanup */
1402 pTpReleaseTimer(timer);
1403 pTpReleasePool(pool);
1404 CloseHandle(semaphore);
1405 }
1406
1407 struct window_length_info
1408 {
1409 HANDLE semaphore;
1410 DWORD ticks;
1411 };
1412
1413 static void CALLBACK window_length_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer)
1414 {
1415 struct window_length_info *info = userdata;
1416 trace("Running window length callback\n");
1417 info->ticks = GetTickCount();
1418 ReleaseSemaphore(info->semaphore, 1, NULL);
1419 }
1420
1421 static void test_tp_window_length(void)
1422 {
1423 struct window_length_info info1, info2;
1424 TP_CALLBACK_ENVIRON environment;
1425 TP_TIMER *timer1, *timer2;
1426 LARGE_INTEGER when;
1427 HANDLE semaphore;
1428 NTSTATUS status;
1429 TP_POOL *pool;
1430 DWORD result;
1431 BOOL merged;
1432
1433 semaphore = CreateSemaphoreA(NULL, 0, 2, NULL);
1434 ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
1435
1436 /* allocate new threadpool */
1437 pool = NULL;
1438 status = pTpAllocPool(&pool, NULL);
1439 ok(!status, "TpAllocPool failed with status %x\n", status);
1440 ok(pool != NULL, "expected pool != NULL\n");
1441
1442 /* allocate two identical timers */
1443 memset(&environment, 0, sizeof(environment));
1444 environment.Version = 1;
1445 environment.Pool = pool;
1446
1447 timer1 = NULL;
1448 info1.semaphore = semaphore;
1449 status = pTpAllocTimer(&timer1, window_length_cb, &info1, &environment);
1450 ok(!status, "TpAllocTimer failed with status %x\n", status);
1451 ok(timer1 != NULL, "expected timer1 != NULL\n");
1452
1453 timer2 = NULL;
1454 info2.semaphore = semaphore;
1455 status = pTpAllocTimer(&timer2, window_length_cb, &info2, &environment);
1456 ok(!status, "TpAllocTimer failed with status %x\n", status);
1457 ok(timer2 != NULL, "expected timer2 != NULL\n");
1458
1459 /* choose parameters so that timers are not merged */
1460 info1.ticks = 0;
1461 info2.ticks = 0;
1462
1463 NtQuerySystemTime( &when );
1464 when.QuadPart += (ULONGLONG)250 * 10000;
1465 pTpSetTimer(timer2, &when, 0, 0);
1466 Sleep(50);
1467 when.QuadPart -= (ULONGLONG)150 * 10000;
1468 pTpSetTimer(timer1, &when, 0, 75);
1469
1470 result = WaitForSingleObject(semaphore, 1000);
1471 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1472 result = WaitForSingleObject(semaphore, 1000);
1473 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1474 ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n");
1475 ok(info2.ticks >= info1.ticks + 75 || broken(info2.ticks < info1.ticks + 75) /* Win 2008 */,
1476 "expected that timers are not merged\n");
1477
1478 /* timers will be merged */
1479 info1.ticks = 0;
1480 info2.ticks = 0;
1481
1482 NtQuerySystemTime( &when );
1483 when.QuadPart += (ULONGLONG)250 * 10000;
1484 pTpSetTimer(timer2, &when, 0, 0);
1485 Sleep(50);
1486 when.QuadPart -= (ULONGLONG)150 * 10000;
1487 pTpSetTimer(timer1, &when, 0, 200);
1488
1489 result = WaitForSingleObject(semaphore, 1000);
1490 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1491 result = WaitForSingleObject(semaphore, 1000);
1492 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1493 ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n");
1494 merged = info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50;
1495 ok(merged || broken(!merged) /* Win 10 */, "expected that timers are merged\n");
1496
1497 /* on Windows the timers also get merged in this case */
1498 info1.ticks = 0;
1499 info2.ticks = 0;
1500
1501 NtQuerySystemTime( &when );
1502 when.QuadPart += (ULONGLONG)100 * 10000;
1503 pTpSetTimer(timer1, &when, 0, 200);
1504 Sleep(50);
1505 when.QuadPart += (ULONGLONG)150 * 10000;
1506 pTpSetTimer(timer2, &when, 0, 0);
1507
1508 result = WaitForSingleObject(semaphore, 1000);
1509 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1510 result = WaitForSingleObject(semaphore, 1000);
1511 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1512 ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n");
1513 merged = info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50;
1514 todo_wine
1515 ok(merged || broken(!merged) /* Win 10 */, "expected that timers are merged\n");
1516
1517 /* cleanup */
1518 pTpReleaseTimer(timer1);
1519 pTpReleaseTimer(timer2);
1520 pTpReleasePool(pool);
1521 CloseHandle(semaphore);
1522 }
1523
1524 struct wait_info
1525 {
1526 HANDLE semaphore;
1527 LONG userdata;
1528 };
1529
1530 static void CALLBACK wait_cb(TP_CALLBACK_INSTANCE *instance, void *userdata,
1531 TP_WAIT *wait, TP_WAIT_RESULT result)
1532 {
1533 struct wait_info *info = userdata;
1534 trace("Running wait callback\n");
1535
1536 if (result == WAIT_OBJECT_0)
1537 InterlockedIncrement(&info->userdata);
1538 else if (result == WAIT_TIMEOUT)
1539 InterlockedExchangeAdd(&info->userdata, 0x10000);
1540 else
1541 ok(0, "unexpected result %u\n", result);
1542 ReleaseSemaphore(info->semaphore, 1, NULL);
1543 }
1544
1545 static void test_tp_wait(void)
1546 {
1547 TP_CALLBACK_ENVIRON environment;
1548 TP_WAIT *wait1, *wait2;
1549 struct wait_info info;
1550 HANDLE semaphores[2];
1551 LARGE_INTEGER when;
1552 NTSTATUS status;
1553 TP_POOL *pool;
1554 DWORD result;
1555
1556 semaphores[0] = CreateSemaphoreW(NULL, 0, 2, NULL);
1557 ok(semaphores[0] != NULL, "failed to create semaphore\n");
1558 semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL);
1559 ok(semaphores[1] != NULL, "failed to create semaphore\n");
1560 info.semaphore = semaphores[0];
1561
1562 /* allocate new threadpool */
1563 pool = NULL;
1564 status = pTpAllocPool(&pool, NULL);
1565 ok(!status, "TpAllocPool failed with status %x\n", status);
1566 ok(pool != NULL, "expected pool != NULL\n");
1567
1568 /* allocate new wait items */
1569 memset(&environment, 0, sizeof(environment));
1570 environment.Version = 1;
1571 environment.Pool = pool;
1572
1573 wait1 = NULL;
1574 status = pTpAllocWait(&wait1, wait_cb, &info, &environment);
1575 ok(!status, "TpAllocWait failed with status %x\n", status);
1576 ok(wait1 != NULL, "expected wait1 != NULL\n");
1577
1578 wait2 = NULL;
1579 status = pTpAllocWait(&wait2, wait_cb, &info, &environment);
1580 ok(!status, "TpAllocWait failed with status %x\n", status);
1581 ok(wait2 != NULL, "expected wait2 != NULL\n");
1582
1583 /* infinite timeout, signal the semaphore immediately */
1584 info.userdata = 0;
1585 pTpSetWait(wait1, semaphores[1], NULL);
1586 ReleaseSemaphore(semaphores[1], 1, NULL);
1587 result = WaitForSingleObject(semaphores[0], 100);
1588 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1589 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
1590 result = WaitForSingleObject(semaphores[1], 0);
1591 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1592
1593 /* relative timeout, no event */
1594 info.userdata = 0;
1595 when.QuadPart = (ULONGLONG)200 * -10000;
1596 pTpSetWait(wait1, semaphores[1], &when);
1597 result = WaitForSingleObject(semaphores[0], 100);
1598 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1599 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1600 result = WaitForSingleObject(semaphores[0], 200);
1601 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1602 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1603 result = WaitForSingleObject(semaphores[1], 0);
1604 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1605
1606 /* repeat test with call to TpWaitForWait(..., TRUE) */
1607 info.userdata = 0;
1608 when.QuadPart = (ULONGLONG)200 * -10000;
1609 pTpSetWait(wait1, semaphores[1], &when);
1610 result = WaitForSingleObject(semaphores[0], 100);
1611 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1612 pTpWaitForWait(wait1, TRUE);
1613 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1614 result = WaitForSingleObject(semaphores[0], 200);
1615 ok(result == WAIT_OBJECT_0 || broken(result == WAIT_TIMEOUT) /* Win 8 */,
1616 "WaitForSingleObject returned %u\n", result);
1617 if (result == WAIT_OBJECT_0)
1618 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1619 else
1620 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1621 result = WaitForSingleObject(semaphores[1], 0);
1622 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1623
1624 /* relative timeout, with event */
1625 info.userdata = 0;
1626 when.QuadPart = (ULONGLONG)200 * -10000;
1627 pTpSetWait(wait1, semaphores[1], &when);
1628 result = WaitForSingleObject(semaphores[0], 100);
1629 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1630 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1631 ReleaseSemaphore(semaphores[1], 1, NULL);
1632 result = WaitForSingleObject(semaphores[0], 100);
1633 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1634 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
1635 result = WaitForSingleObject(semaphores[1], 0);
1636 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1637
1638 /* repeat test with call to TpWaitForWait(..., TRUE) */
1639 info.userdata = 0;
1640 when.QuadPart = (ULONGLONG)200 * -10000;
1641 pTpSetWait(wait1, semaphores[1], &when);
1642 result = WaitForSingleObject(semaphores[0], 100);
1643 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1644 pTpWaitForWait(wait1, TRUE);
1645 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1646 ReleaseSemaphore(semaphores[1], 1, NULL);
1647 result = WaitForSingleObject(semaphores[0], 100);
1648 ok(result == WAIT_OBJECT_0 || broken(result == WAIT_TIMEOUT) /* Win 8 */,
1649 "WaitForSingleObject returned %u\n", result);
1650 if (result == WAIT_OBJECT_0)
1651 {
1652 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
1653 result = WaitForSingleObject(semaphores[1], 0);
1654 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1655 }
1656 else
1657 {
1658 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1659 result = WaitForSingleObject(semaphores[1], 0);
1660 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1661 }
1662
1663 /* absolute timeout, no event */
1664 info.userdata = 0;
1665 NtQuerySystemTime( &when );
1666 when.QuadPart += (ULONGLONG)200 * 10000;
1667 pTpSetWait(wait1, semaphores[1], &when);
1668 result = WaitForSingleObject(semaphores[0], 100);
1669 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1670 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1671 result = WaitForSingleObject(semaphores[0], 200);
1672 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1673 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1674 result = WaitForSingleObject(semaphores[1], 0);
1675 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1676
1677 /* absolute timeout, with event */
1678 info.userdata = 0;
1679 NtQuerySystemTime( &when );
1680 when.QuadPart += (ULONGLONG)200 * 10000;
1681 pTpSetWait(wait1, semaphores[1], &when);
1682 result = WaitForSingleObject(semaphores[0], 100);
1683 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1684 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1685 ReleaseSemaphore(semaphores[1], 1, NULL);
1686 result = WaitForSingleObject(semaphores[0], 100);
1687 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1688 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
1689 result = WaitForSingleObject(semaphores[1], 0);
1690 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1691
1692 /* test timeout of zero */
1693 info.userdata = 0;
1694 when.QuadPart = 0;
1695 pTpSetWait(wait1, semaphores[1], &when);
1696 result = WaitForSingleObject(semaphores[0], 100);
1697 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1698 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1699 result = WaitForSingleObject(semaphores[1], 0);
1700 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1701
1702 /* cancel a pending wait */
1703 info.userdata = 0;
1704 when.QuadPart = (ULONGLONG)250 * -10000;
1705 pTpSetWait(wait1, semaphores[1], &when);
1706 result = WaitForSingleObject(semaphores[0], 100);
1707 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1708 pTpSetWait(wait1, NULL, (void *)0xdeadbeef);
1709 Sleep(50);
1710 ReleaseSemaphore(semaphores[1], 1, NULL);
1711 result = WaitForSingleObject(semaphores[0], 100);
1712 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1713 ok(info.userdata == 0, "expected info.userdata = 0, got %u\n", info.userdata);
1714 result = WaitForSingleObject(semaphores[1], 0);
1715 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1716
1717 /* test with INVALID_HANDLE_VALUE */
1718 info.userdata = 0;
1719 when.QuadPart = 0;
1720 pTpSetWait(wait1, INVALID_HANDLE_VALUE, &when);
1721 result = WaitForSingleObject(semaphores[0], 100);
1722 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1723 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1724
1725 /* cancel a pending wait with INVALID_HANDLE_VALUE */
1726 info.userdata = 0;
1727 when.QuadPart = (ULONGLONG)250 * -10000;
1728 pTpSetWait(wait1, semaphores[1], &when);
1729 result = WaitForSingleObject(semaphores[0], 100);
1730 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1731 when.QuadPart = 0;
1732 pTpSetWait(wait1, INVALID_HANDLE_VALUE, &when);
1733 Sleep(50);
1734 ReleaseSemaphore(semaphores[1], 1, NULL);
1735 result = WaitForSingleObject(semaphores[0], 100);
1736 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1737 ok(info.userdata == 0x10000, "expected info.userdata = 0x10000, got %u\n", info.userdata);
1738 result = WaitForSingleObject(semaphores[1], 0);
1739 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1740
1741 CloseHandle(semaphores[1]);
1742 semaphores[1] = CreateSemaphoreW(NULL, 0, 2, NULL);
1743 ok(semaphores[1] != NULL, "failed to create semaphore\n");
1744
1745 /* add two wait objects with the same semaphore */
1746 info.userdata = 0;
1747 pTpSetWait(wait1, semaphores[1], NULL);
1748 pTpSetWait(wait2, semaphores[1], NULL);
1749 Sleep(50);
1750 ReleaseSemaphore(semaphores[1], 1, NULL);
1751 result = WaitForSingleObject(semaphores[0], 100);
1752 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1753 result = WaitForSingleObject(semaphores[0], 100);
1754 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1755 ok(info.userdata == 1, "expected info.userdata = 1, got %u\n", info.userdata);
1756 result = WaitForSingleObject(semaphores[1], 0);
1757 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1758
1759 /* repeat test above with release count 2 */
1760 info.userdata = 0;
1761 pTpSetWait(wait1, semaphores[1], NULL);
1762 pTpSetWait(wait2, semaphores[1], NULL);
1763 Sleep(50);
1764 result = ReleaseSemaphore(semaphores[1], 2, NULL);
1765 result = WaitForSingleObject(semaphores[0], 100);
1766 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1767 result = WaitForSingleObject(semaphores[0], 100);
1768 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1769 ok(info.userdata == 2, "expected info.userdata = 2, got %u\n", info.userdata);
1770 result = WaitForSingleObject(semaphores[1], 0);
1771 ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result);
1772
1773 /* cleanup */
1774 pTpReleaseWait(wait1);
1775 pTpReleaseWait(wait2);
1776 pTpReleasePool(pool);
1777 CloseHandle(semaphores[0]);
1778 CloseHandle(semaphores[1]);
1779 }
1780
1781 static struct
1782 {
1783 HANDLE semaphore;
1784 DWORD result;
1785 } multi_wait_info;
1786
1787 static void CALLBACK multi_wait_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WAIT *wait, TP_WAIT_RESULT result)
1788 {
1789 DWORD index = (DWORD)(DWORD_PTR)userdata;
1790
1791 if (result == WAIT_OBJECT_0)
1792 multi_wait_info.result = index;
1793 else if (result == WAIT_TIMEOUT)
1794 multi_wait_info.result = 0x10000 | index;
1795 else
1796 ok(0, "unexpected result %u\n", result);
1797 ReleaseSemaphore(multi_wait_info.semaphore, 1, NULL);
1798 }
1799
1800 static void test_tp_multi_wait(void)
1801 {
1802 TP_CALLBACK_ENVIRON environment;
1803 HANDLE semaphores[512];
1804 TP_WAIT *waits[512];
1805 LARGE_INTEGER when;
1806 HANDLE semaphore;
1807 NTSTATUS status;
1808 TP_POOL *pool;
1809 DWORD result;
1810 int i;
1811
1812 semaphore = CreateSemaphoreW(NULL, 0, 512, NULL);
1813 ok(semaphore != NULL, "failed to create semaphore\n");
1814 multi_wait_info.semaphore = semaphore;
1815
1816 /* allocate new threadpool */
1817 pool = NULL;
1818 status = pTpAllocPool(&pool, NULL);
1819 ok(!status, "TpAllocPool failed with status %x\n", status);
1820 ok(pool != NULL, "expected pool != NULL\n");
1821
1822 memset(&environment, 0, sizeof(environment));
1823 environment.Version = 1;
1824 environment.Pool = pool;
1825
1826 /* create semaphores and corresponding wait objects */
1827 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1828 {
1829 semaphores[i] = CreateSemaphoreW(NULL, 0, 1, NULL);
1830 ok(semaphores[i] != NULL, "failed to create semaphore %i\n", i);
1831
1832 waits[i] = NULL;
1833 status = pTpAllocWait(&waits[i], multi_wait_cb, (void *)(DWORD_PTR)i, &environment);
1834 ok(!status, "TpAllocWait failed with status %x\n", status);
1835 ok(waits[i] != NULL, "expected waits[%d] != NULL\n", i);
1836
1837 pTpSetWait(waits[i], semaphores[i], NULL);
1838 }
1839
1840 /* release all semaphores and wait for callback */
1841 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1842 {
1843 multi_wait_info.result = 0;
1844 ReleaseSemaphore(semaphores[i], 1, NULL);
1845
1846 result = WaitForSingleObject(semaphore, 100);
1847 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1848 ok(multi_wait_info.result == i, "expected result %d, got %u\n", i, multi_wait_info.result);
1849
1850 pTpSetWait(waits[i], semaphores[i], NULL);
1851 }
1852
1853 /* repeat the same test in reverse order */
1854 for (i = sizeof(semaphores)/sizeof(semaphores[0]) - 1; i >= 0; i--)
1855 {
1856 multi_wait_info.result = 0;
1857 ReleaseSemaphore(semaphores[i], 1, NULL);
1858
1859 result = WaitForSingleObject(semaphore, 100);
1860 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1861 ok(multi_wait_info.result == i, "expected result %d, got %u\n", i, multi_wait_info.result);
1862
1863 pTpSetWait(waits[i], semaphores[i], NULL);
1864 }
1865
1866 /* test timeout of wait objects */
1867 multi_wait_info.result = 0;
1868 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1869 {
1870 when.QuadPart = (ULONGLONG)50 * -10000;
1871 pTpSetWait(waits[i], semaphores[i], &when);
1872 }
1873
1874 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1875 {
1876 result = WaitForSingleObject(semaphore, 150);
1877 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
1878 }
1879
1880 ok(multi_wait_info.result >> 16, "expected multi_wait_info.result >> 16 != 0\n");
1881
1882 /* destroy the wait objects and semaphores while waiting */
1883 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1884 {
1885 pTpSetWait(waits[i], semaphores[i], NULL);
1886 }
1887
1888 Sleep(50);
1889
1890 for (i = 0; i < sizeof(semaphores)/sizeof(semaphores[0]); i++)
1891 {
1892 pTpReleaseWait(waits[i]);
1893 NtClose(semaphores[i]);
1894 }
1895
1896 pTpReleasePool(pool);
1897 CloseHandle(semaphore);
1898 }
1899
1900 START_TEST(threadpool)
1901 {
1902 test_RtlQueueWorkItem();
1903 test_RtlRegisterWait();
1904
1905 if (!init_threadpool())
1906 return;
1907
1908 test_tp_simple();
1909 test_tp_work();
1910 test_tp_work_scheduler();
1911 test_tp_group_wait();
1912 test_tp_group_cancel();
1913 test_tp_instance();
1914 test_tp_disassociate();
1915 test_tp_timer();
1916 test_tp_window_length();
1917 test_tp_wait();
1918 test_tp_multi_wait();
1919 }