thread.c 49.9 KB
Newer Older
1
/*
2
 * Unit test suite for thread functions.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * Copyright 2002 Geoffrey Hausheer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 22 23
/* Define _WIN32_WINNT to get SetThreadIdealProcessor on Windows */
#define _WIN32_WINNT 0x0500

24
#include <assert.h>
25
#include <stdarg.h>
26
#include <stdio.h>
27

28
#include "wine/test.h"
29
#include <windef.h>
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
#include <winbase.h>
#include <winnt.h>
#include <winerror.h>

/* Specify the number of simultaneous threads to test */
#define NUM_THREADS 4
/* Specify whether to test the extended priorities for Win2k/XP */
#define USE_EXTENDED_PRIORITIES 0
/* Specify whether to test the stack allocation in CreateThread */
#define CHECK_STACK 0

/* Set CHECK_STACK to 1 if you want to try to test the stack-limit from
   CreateThread.  So far I have been unable to make this work, and
   I am in doubt as to how portable it is.  Also, according to MSDN,
   you shouldn't mix C-run-time-libraries (i.e. alloca) with CreateThread.
   Anyhow, the check is currently commented out
*/
#if CHECK_STACK
48 49 50 51 52 53 54
# ifdef __try
#  define __TRY __try
#  define __EXCEPT __except
#  define __ENDTRY
# else
#  include "wine/exception.h"
# endif
55
#endif
56

57 58 59 60 61 62 63
static BOOL (WINAPI *pGetThreadPriorityBoost)(HANDLE,PBOOL);
static HANDLE (WINAPI *pOpenThread)(DWORD,BOOL,DWORD);
static BOOL (WINAPI *pQueueUserWorkItem)(LPTHREAD_START_ROUTINE,PVOID,ULONG);
static DWORD (WINAPI *pSetThreadIdealProcessor)(HANDLE,DWORD);
static BOOL (WINAPI *pSetThreadPriorityBoost)(HANDLE,BOOL);
static BOOL (WINAPI *pRegisterWaitForSingleObject)(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
static BOOL (WINAPI *pUnregisterWait)(HANDLE);
64
static BOOL (WINAPI *pIsWow64Process)(HANDLE,PBOOL);
65 66 67
static BOOL (WINAPI *pSetThreadErrorMode)(DWORD,PDWORD);
static DWORD (WINAPI *pGetThreadErrorMode)(void);
static DWORD (WINAPI *pRtlGetThreadErrorMode)(void);
68

69 70 71 72 73
static HANDLE create_target_process(const char *arg)
{
    char **argv;
    char cmdline[MAX_PATH];
    PROCESS_INFORMATION pi;
74
    BOOL ret;
75 76 77 78 79
    STARTUPINFO si = { 0 };
    si.cb = sizeof(si);

    winetest_get_mainargs( &argv );
    sprintf(cmdline, "%s %s %s", argv[0], argv[1], arg);
80 81 82 83
    ret = CreateProcess(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "error: %u\n", GetLastError());
    ret = CloseHandle(pi.hThread);
    ok(ret, "error %u\n", GetLastError());
84 85 86
    return pi.hProcess;
}

87 88 89 90 91 92 93 94 95
/* Functions not tested yet:
  AttachThreadInput
  SetThreadContext
  SwitchToThread

In addition there are no checks that the inheritance works properly in
CreateThread
*/

96 97 98 99
/* Functions to ensure that from a group of threads, only one executes
   certain chunks of code at a time, and we know which one is executing
   it.  It basically makes multithreaded execution linear, which defeats
   the purpose of multiple threads, but makes testing easy.  */
100
static HANDLE start_event, stop_event;
101
static LONG num_synced;
102

103
static void init_thread_sync_helpers(void)
104
{
105 106 107 108
  start_event = CreateEvent(NULL, TRUE, FALSE, NULL);
  ok(start_event != NULL, "CreateEvent failed\n");
  stop_event = CreateEvent(NULL, TRUE, FALSE, NULL);
  ok(stop_event != NULL, "CreateEvent failed\n");
109
  num_synced = -1;
110 111 112 113 114
}

static BOOL sync_threads_and_run_one(DWORD sync_id, DWORD my_id)
{
  LONG num = InterlockedIncrement(&num_synced);
115 116
  assert(-1 <= num && num <= 1);
  if (num == 1)
117 118 119 120
  {
      ResetEvent( stop_event );
      SetEvent( start_event );
  }
121 122
  else
  {
123
    DWORD ret = WaitForSingleObject(start_event, 10000);
124
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed %x\n",ret);
125 126 127 128 129 130 131
  }
  return sync_id == my_id;
}

static void resync_after_run(void)
{
  LONG num = InterlockedDecrement(&num_synced);
132 133
  assert(-1 <= num && num <= 1);
  if (num == -1)
134 135 136 137
  {
      ResetEvent( start_event );
      SetEvent( stop_event );
  }
138 139
  else
  {
140
    DWORD ret = WaitForSingleObject(stop_event, 10000);
141 142 143 144 145 146
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
  }
}

static void cleanup_thread_sync_helpers(void)
{
147 148
  CloseHandle(start_event);
  CloseHandle(stop_event);
149 150
}

151
static DWORD tlsIndex;
152 153 154 155 156 157 158

typedef struct {
  int threadnum;
  HANDLE *event;
  DWORD *threadmem;
} t1Struct;

159
/* WinME supports OpenThread but doesn't know about access restrictions so
160
   we require them to be either completely ignored or always obeyed.
161
*/
162
static INT obeying_ars = 0; /* -1 == no, 0 == dunno yet, 1 == yes */
163 164 165 166 167 168 169 170 171 172
#define obey_ar(x) \
  (obeying_ars == 0 \
    ? ((x) \
      ? (obeying_ars = +1) \
      : ((obeying_ars = -1), \
         trace("not restricted, assuming consistent behaviour\n"))) \
    : (obeying_ars < 0) \
      ? ok(!(x), "access restrictions obeyed\n") \
      : ok( (x), "access restrictions not obeyed\n"))

173
/* Basic test that simultaneous threads can access shared memory,
174 175 176
   that the thread local storage routines work correctly, and that
   threads actually run concurrently
*/
177
static DWORD WINAPI threadFunc1(LPVOID p)
178
{
179
   t1Struct *tstruct = p;
180 181 182
   int i;
/* write our thread # into shared memory */
   tstruct->threadmem[tstruct->threadnum]=GetCurrentThreadId();
183
   ok(TlsSetValue(tlsIndex,(LPVOID)(INT_PTR)(tstruct->threadnum+1))!=0,
184
      "TlsSetValue failed\n");
185 186 187 188 189 190 191 192 193 194 195
/* The threads synchronize before terminating.  This is done by
   Signaling an event, and waiting for all events to occur
*/
   SetEvent(tstruct->event[tstruct->threadnum]);
   WaitForMultipleObjects(NUM_THREADS,tstruct->event,TRUE,INFINITE);
/* Double check that all threads really did run by validating that
   they have all written to the shared memory. There should be no race
   here, since all threads were synchronized after the write.*/
   for(i=0;i<NUM_THREADS;i++) {
     while(tstruct->threadmem[i]==0) ;
   }
196 197 198 199

   /* lstrlenA contains an exception handler so this makes sure exceptions work in threads */
   ok( lstrlenA( (char *)0xdeadbeef ) == 0, "lstrlenA: unexpected success\n" );

200
/* Check that no one changed our tls memory */
201
   ok((INT_PTR)TlsGetValue(tlsIndex)-1==tstruct->threadnum,
202
      "TlsGetValue failed\n");
203
   return NUM_THREADS+tstruct->threadnum;
204 205
}

206
static DWORD WINAPI threadFunc2(LPVOID p)
207
{
208
   return 99;
209 210
}

211
static DWORD WINAPI threadFunc3(LPVOID p)
212 213 214 215
{
   HANDLE thread;
   thread=GetCurrentThread();
   SuspendThread(thread);
216
   return 99;
217 218
}

219
static DWORD WINAPI threadFunc4(LPVOID p)
220
{
221
   HANDLE event = p;
222
   if(event != NULL) {
223 224
     SetEvent(event);
   }
225
   Sleep(99000);
226
   return 0;
227 228 229
}

#if CHECK_STACK
230
static DWORD WINAPI threadFunc5(LPVOID p)
231
{
232
  DWORD *exitCode = p;
233 234 235 236 237 238 239 240 241 242 243 244
  SYSTEM_INFO sysInfo;
  sysInfo.dwPageSize=0;
  GetSystemInfo(&sysInfo);
  *exitCode=0;
   __TRY
   {
     alloca(2*sysInfo.dwPageSize);
   }
    __EXCEPT(1) {
     *exitCode=1;
   }
   __ENDTRY
245
   return 0;
246 247 248
}
#endif

249 250
static DWORD WINAPI threadFunc_SetEvent(LPVOID p)
{
251
    SetEvent(p);
252 253 254 255 256
    return 0;
}

static DWORD WINAPI threadFunc_CloseHandle(LPVOID p)
{
257
    CloseHandle(p);
258 259 260
    return 0;
}

261 262 263 264 265 266 267 268 269 270 271
static void create_function_addr_events(HANDLE events[2])
{
    char buffer[256];

    sprintf(buffer, "threadFunc_SetEvent %p", threadFunc_SetEvent);
    events[0] = CreateEvent(NULL, FALSE, FALSE, buffer);

    sprintf(buffer, "threadFunc_CloseHandle %p", threadFunc_CloseHandle);
    events[1] = CreateEvent(NULL, FALSE, FALSE, buffer);
}

272 273 274 275 276
/* check CreateRemoteThread */
static VOID test_CreateRemoteThread(void)
{
    HANDLE hProcess, hThread, hEvent, hRemoteEvent;
    DWORD tid, ret, exitcode;
277
    HANDLE hAddrEvents[2];
278 279 280 281

    hProcess = create_target_process("sleep");
    ok(hProcess != NULL, "Can't start process\n");

282 283 284 285 286 287 288 289 290 291
    /* ensure threadFunc_SetEvent & threadFunc_CloseHandle are the same
     * address as in the child process */
    create_function_addr_events(hAddrEvents);
    ret = WaitForMultipleObjects(2, hAddrEvents, TRUE, 5000);
    if (ret == WAIT_TIMEOUT)
    {
        skip("child process wasn't mapped at same address, so can't do CreateRemoteThread tests.\n");
        return;
    }

292 293 294 295 296 297 298
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    ok(hEvent != NULL, "Can't create event, err=%u\n", GetLastError());
    ret = DuplicateHandle(GetCurrentProcess(), hEvent, hProcess, &hRemoteEvent,
                          0, FALSE, DUPLICATE_SAME_ACCESS);
    ok(ret != 0, "DuplicateHandle failed, err=%u\n", GetLastError());

    /* create suspended remote thread with entry point SetEvent() */
299
    SetLastError(0xdeadbeef);
300 301
    hThread = CreateRemoteThread(hProcess, NULL, 0, threadFunc_SetEvent,
                                 hRemoteEvent, CREATE_SUSPENDED, &tid);
302 303
    if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
304
        win_skip("CreateRemoteThread is not implemented\n");
305 306
        goto cleanup;
    }
307
    ok(hThread != NULL, "CreateRemoteThread failed, err=%u\n", GetLastError());
308 309
    ok(tid != 0, "null tid\n");
    ret = SuspendThread(hThread);
310
    ok(ret == 1, "ret=%u, err=%u\n", ret, GetLastError());
311
    ret = ResumeThread(hThread);
312
    ok(ret == 2, "ret=%u, err=%u\n", ret, GetLastError());
313 314

    /* thread still suspended, so wait times out */
315
    ret = WaitForSingleObject(hEvent, 1000);
316 317 318
    ok(ret == WAIT_TIMEOUT, "wait did not time out, ret=%u\n", ret);

    ret = ResumeThread(hThread);
319
    ok(ret == 1, "ret=%u, err=%u\n", ret, GetLastError());
320 321

    /* wait that doesn't time out */
322
    ret = WaitForSingleObject(hEvent, 1000);
323
    ok(ret == WAIT_OBJECT_0, "object not signaled, ret=%u\n", ret);
324 325

    /* wait for thread end */
326
    ret = WaitForSingleObject(hThread, 1000);
327
    ok(ret == WAIT_OBJECT_0, "waiting for thread failed, ret=%u\n", ret);
328 329 330 331 332 333
    CloseHandle(hThread);

    /* create and wait for remote thread with entry point CloseHandle() */
    hThread = CreateRemoteThread(hProcess, NULL, 0,
                                 threadFunc_CloseHandle,
                                 hRemoteEvent, 0, &tid);
334
    ok(hThread != NULL, "CreateRemoteThread failed, err=%u\n", GetLastError());
335
    ret = WaitForSingleObject(hThread, 1000);
336
    ok(ret == WAIT_OBJECT_0, "waiting for thread failed, ret=%u\n", ret);
337 338 339 340 341 342
    CloseHandle(hThread);

    /* create remote thread with entry point SetEvent() */
    hThread = CreateRemoteThread(hProcess, NULL, 0,
                                 threadFunc_SetEvent,
                                 hRemoteEvent, 0, &tid);
343
    ok(hThread != NULL, "CreateRemoteThread failed, err=%u\n", GetLastError());
344 345

    /* closed handle, so wait times out */
346
    ret = WaitForSingleObject(hEvent, 1000);
347 348 349 350
    ok(ret == WAIT_TIMEOUT, "wait did not time out, ret=%u\n", ret);

    /* check that remote SetEvent() failed */
    ret = GetExitCodeThread(hThread, &exitcode);
351 352
    ok(ret != 0, "GetExitCodeThread failed, err=%u\n", GetLastError());
    if (ret) ok(exitcode == 0, "SetEvent succeeded, expected to fail\n");
353 354
    CloseHandle(hThread);

355
cleanup:
356 357 358 359 360
    TerminateProcess(hProcess, 0);
    CloseHandle(hEvent);
    CloseHandle(hProcess);
}

361
/* Check basic functionality of CreateThread and Tls* functions */
362
static VOID test_CreateThread_basic(void)
363 364 365 366 367 368 369
{
   HANDLE thread[NUM_THREADS],event[NUM_THREADS];
   DWORD threadid[NUM_THREADS],curthreadId;
   DWORD threadmem[NUM_THREADS];
   DWORD exitCode;
   t1Struct tstruct[NUM_THREADS];
   int error;
370
   DWORD i,j;
371
   DWORD GLE, ret;
372
   DWORD tid;
373
   BOOL bRet;
374

375 376 377
   /* lstrlenA contains an exception handler so this makes sure exceptions work in the main thread */
   ok( lstrlenA( (char *)0xdeadbeef ) == 0, "lstrlenA: unexpected success\n" );

378 379 380
/* Retrieve current Thread ID for later comparisons */
  curthreadId=GetCurrentThreadId();
/* Allocate some local storage */
381
  ok((tlsIndex=TlsAlloc())!=TLS_OUT_OF_INDEXES,"TlsAlloc failed\n");
382 383 384
/* Create events for thread synchronization */
  for(i=0;i<NUM_THREADS;i++) {
    threadmem[i]=0;
385
/* Note that it doesn't matter what type of event we choose here.  This
386 387 388 389 390 391 392 393 394 395
   test isn't trying to thoroughly test events
*/
    event[i]=CreateEventA(NULL,TRUE,FALSE,NULL);
    tstruct[i].threadnum=i;
    tstruct[i].threadmem=threadmem;
    tstruct[i].event=event;
  }

/* Test that passing arguments to threads works okay */
  for(i=0;i<NUM_THREADS;i++) {
396
    thread[i] = CreateThread(NULL,0,threadFunc1,
397
                             &tstruct[i],0,&threadid[i]);
398
    ok(thread[i]!=NULL,"Create Thread failed\n");
399 400 401 402
  }
/* Test that the threads actually complete */
  for(i=0;i<NUM_THREADS;i++) {
    error=WaitForSingleObject(thread[i],5000);
403
    ok(error==WAIT_OBJECT_0, "Thread did not complete within timelimit\n");
404 405
    if(error!=WAIT_OBJECT_0) {
      TerminateThread(thread[i],i+NUM_THREADS);
406
    }
407 408
    ok(GetExitCodeThread(thread[i],&exitCode),"Could not retrieve ext code\n");
    ok(exitCode==i+NUM_THREADS,"Thread returned an incorrect exit code\n");
409 410 411
  }
/* Test that each thread executed in its parent's address space
   (it was able to change threadmem and pass that change back to its parent)
412
   and that each thread id was independent).  Note that we prove that the
413 414 415 416 417 418 419 420 421 422 423
   threads actually execute concurrently by having them block on each other
   in threadFunc1
*/
  for(i=0;i<NUM_THREADS;i++) {
    error=0;
    for(j=i+1;j<NUM_THREADS;j++) {
      if (threadmem[i]==threadmem[j]) {
        error=1;
      }
    }
    ok(!error && threadmem[i]==threadid[i] && threadmem[i]!=curthreadId,
424 425
         "Thread did not execute successfully\n");
    ok(CloseHandle(thread[i])!=0,"CloseHandle failed\n");
426
  }
427 428

  SetLastError(0xCAFEF00D);
429 430
  bRet = TlsFree(tlsIndex);
  ok(bRet, "TlsFree failed: %08x\n", GetLastError());
431 432 433 434 435 436 437 438
  ok(GetLastError()==0xCAFEF00D,
     "GetLastError: expected 0xCAFEF00D, got %08x\n", GetLastError());

  /* Test freeing an already freed TLS index */
  SetLastError(0xCAFEF00D);
  ok(TlsFree(tlsIndex)==0,"TlsFree succeeded\n");
  ok(GetLastError()==ERROR_INVALID_PARAMETER,
     "GetLastError: expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
439 440 441

  /* Test how passing NULL as a pointer to threadid works */
  SetLastError(0xFACEaBAD);
442
  thread[0] = CreateThread(NULL,0,threadFunc2,NULL,0,&tid);
443 444
  GLE = GetLastError();
  if (thread[0]) { /* NT */
445
    ok(GLE==0xFACEaBAD, "CreateThread set last error to %d, expected 4207848365\n", GLE);
446 447 448
    ret = WaitForSingleObject(thread[0],100);
    ok(ret==WAIT_OBJECT_0, "threadFunc2 did not exit during 100 ms\n");
    ret = GetExitCodeThread(thread[0],&exitCode);
449 450
    ok(ret!=0, "GetExitCodeThread returned %d (expected nonzero)\n", ret);
    ok(exitCode==99, "threadFunc2 exited with code: %d (expected 99)\n", exitCode);
451 452 453
    ok(CloseHandle(thread[0])!=0,"Error closing thread handle\n");
  }
  else { /* 9x */
454
    ok(GLE==ERROR_INVALID_PARAMETER, "CreateThread set last error to %d, expected 87\n", GLE);
455
  }
456 457 458
}

/* Check that using the CREATE_SUSPENDED flag works */
459
static VOID test_CreateThread_suspended(void)
460 461 462
{
  HANDLE thread;
  DWORD threadId;
463
  DWORD suspend_count;
464 465
  int error;

466
  thread = CreateThread(NULL,0,threadFunc2,NULL,
467
                        CREATE_SUSPENDED,&threadId);
468
  ok(thread!=NULL,"Create Thread failed\n");
469
/* Check that the thread is suspended */
470 471
  ok(SuspendThread(thread)==1,"Thread did not start suspended\n");
  ok(ResumeThread(thread)==2,"Resume thread returned an invalid value\n");
472 473 474 475 476
/* Check that resume thread didn't actually start the thread.  I can't think
   of a better way of checking this than just waiting.  I am not sure if this
   will work on slow computers.
*/
  ok(WaitForSingleObject(thread,1000)==WAIT_TIMEOUT,
477
     "ResumeThread should not have actually started the thread\n");
478
/* Now actually resume the thread and make sure that it actually completes*/
479
  ok(ResumeThread(thread)==1,"Resume thread returned an invalid value\n");
480
  ok((error=WaitForSingleObject(thread,1000))==WAIT_OBJECT_0,
481
     "Thread did not resume\n");
482 483 484
  if(error!=WAIT_OBJECT_0) {
    TerminateThread(thread,1);
  }
485 486 487 488 489

  suspend_count = SuspendThread(thread);
  ok(suspend_count == -1, "SuspendThread returned %d, expected -1\n", suspend_count);

  suspend_count = ResumeThread(thread);
490 491 492
  ok(suspend_count == 0 ||
     broken(suspend_count == -1), /* win9x */
     "ResumeThread returned %d, expected 0\n", suspend_count);
493

494
  ok(CloseHandle(thread)!=0,"CloseHandle failed\n");
495 496 497
}

/* Check that SuspendThread and ResumeThread work */
498
static VOID test_SuspendThread(void)
499 500
{
  HANDLE thread,access_thread;
501 502
  DWORD threadId,exitCode,error;
  int i;
503

504
  thread = CreateThread(NULL,0,threadFunc3,NULL,
505
                        0,&threadId);
506
  ok(thread!=NULL,"Create Thread failed\n");
507 508 509 510 511 512 513 514 515 516 517 518 519 520
/* Check that the thread is suspended */
/* Note that this is a polling method, and there is a race between
   SuspendThread being called (in the child, and the loop below timing out,
   so the test could fail on a heavily loaded or slow computer.
*/
  error=0;
  for(i=0;error==0 && i<100;i++) {
    error=SuspendThread(thread);
    ResumeThread(thread);
    if(error==0) {
      Sleep(50);
      i++;
    }
  }
521
  ok(error==1,"SuspendThread did not work\n");
522
/* check that access restrictions are obeyed */
523 524
  if (pOpenThread) {
    access_thread=pOpenThread(THREAD_ALL_ACCESS & (~THREAD_SUSPEND_RESUME),
525
                           0,threadId);
526
    ok(access_thread!=NULL,"OpenThread returned an invalid handle\n");
527
    if (access_thread!=NULL) {
528 529
      obey_ar(SuspendThread(access_thread)==~0U);
      obey_ar(ResumeThread(access_thread)==~0U);
530
      ok(CloseHandle(access_thread)!=0,"CloseHandle Failed\n");
531 532 533 534
    }
  }
/* Double check that the thread really is suspended */
  ok((error=GetExitCodeThread(thread,&exitCode))!=0 && exitCode==STILL_ACTIVE,
535
     "Thread did not really suspend\n");
536
/* Resume the thread, and make sure it actually completes */
537
  ok(ResumeThread(thread)==1,"Resume thread returned an invalid value\n");
538
  ok((error=WaitForSingleObject(thread,1000))==WAIT_OBJECT_0,
539
     "Thread did not resume\n");
540 541 542
  if(error!=WAIT_OBJECT_0) {
    TerminateThread(thread,1);
  }
543 544
  /* Trying to suspend a terminated thread should fail */
  error=SuspendThread(thread);
545 546
  ok(error==~0U, "wrong return code: %d\n", error);
  ok(GetLastError()==ERROR_ACCESS_DENIED || GetLastError()==ERROR_NO_MORE_ITEMS, "unexpected error code: %d\n", GetLastError());
547

548
  ok(CloseHandle(thread)!=0,"CloseHandle Failed\n");
549 550 551 552
}

/* Check that TerminateThread works properly
*/
553
static VOID test_TerminateThread(void)
554
{
555
  HANDLE thread,access_thread,event;
556
  DWORD threadId,exitCode;
557
  event=CreateEventA(NULL,TRUE,FALSE,NULL);
558
  thread = CreateThread(NULL,0,threadFunc4,event,0,&threadId);
559
  ok(thread!=NULL,"Create Thread failed\n");
560
/* TerminateThread has a race condition in Wine.  If the thread is terminated
561 562 563 564 565
   before it starts, it leaves a process behind.  Therefore, we wait for the
   thread to signal that it has started.  There is no easy way to force the
   race to occur, so we don't try to find it.
*/
  ok(WaitForSingleObject(event,5000)==WAIT_OBJECT_0,
566
     "TerminateThread didn't work\n");
567
/* check that access restrictions are obeyed */
568 569
  if (pOpenThread) {
    access_thread=pOpenThread(THREAD_ALL_ACCESS & (~THREAD_TERMINATE),
570
                             0,threadId);
571
    ok(access_thread!=NULL,"OpenThread returned an invalid handle\n");
572
    if (access_thread!=NULL) {
573
      obey_ar(TerminateThread(access_thread,99)==0);
574
      ok(CloseHandle(access_thread)!=0,"CloseHandle Failed\n");
575 576 577
    }
  }
/* terminate a job and make sure it terminates */
578
  ok(TerminateThread(thread,99)!=0,"TerminateThread failed\n");
579
  ok(WaitForSingleObject(thread,5000)==WAIT_OBJECT_0,
580
     "TerminateThread didn't work\n");
581
  ok(GetExitCodeThread(thread,&exitCode)!=STILL_ACTIVE,
582 583 584
     "TerminateThread should not leave the thread 'STILL_ACTIVE'\n");
  ok(exitCode==99, "TerminateThread returned invalid exit code\n");
  ok(CloseHandle(thread)!=0,"Error Closing thread handle\n");
585 586 587 588 589
}

/* Check if CreateThread obeys the specified stack size.  This code does
   not work properly, and is currently disabled
*/
590
static VOID test_CreateThread_stack(void)
591 592 593 594 595 596 597 598 599 600 601 602 603 604
{
#if CHECK_STACK
/* The only way I know of to test the stack size is to use alloca
   and __try/__except.  However, this is probably not portable,
   and I couldn't get it to work under Wine anyhow.  However, here
   is the code which should allow for testing that CreateThread
   respects the stack-size limit
*/
     HANDLE thread;
     DWORD threadId,exitCode;

     SYSTEM_INFO sysInfo;
     sysInfo.dwPageSize=0;
     GetSystemInfo(&sysInfo);
605
     ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page size\n");
606
     thread = CreateThread(NULL,sysInfo.dwPageSize,
607
                           threadFunc5,&exitCode,
608 609
                           0,&threadId);
     ok(WaitForSingleObject(thread,5000)==WAIT_OBJECT_0,
610 611 612
        "TerminateThread didn't work\n");
     ok(exitCode==1,"CreateThread did not obey stack-size-limit\n");
     ok(CloseHandle(thread)!=0,"CloseHandle failed\n");
613 614 615
#endif
}

616
/* Check whether setting/retrieving thread priorities works */
617
static VOID test_thread_priority(void)
618 619 620 621
{
   HANDLE curthread,access_thread;
   DWORD curthreadId,exitCode;
   int min_priority=-2,max_priority=2;
622
   BOOL disabled,rc;
623
   int i;
624 625 626 627 628 629 630 631 632 633

   curthread=GetCurrentThread();
   curthreadId=GetCurrentThreadId();
/* Check thread priority */
/* NOTE: on Win2k/XP priority can be from -7 to 6.  All other platforms it
         is -2 to 2.  However, even on a real Win2k system, using thread
         priorities beyond the -2 to 2 range does not work.  If you want to try
         anyway, enable USE_EXTENDED_PRIORITIES
*/
   ok(GetThreadPriority(curthread)==THREAD_PRIORITY_NORMAL,
634
      "GetThreadPriority Failed\n");
635

636
   if (pOpenThread) {
637
/* check that access control is obeyed */
638
     access_thread=pOpenThread(THREAD_ALL_ACCESS &
639 640
                       (~THREAD_QUERY_INFORMATION) & (~THREAD_SET_INFORMATION),
                       0,curthreadId);
641
     ok(access_thread!=NULL,"OpenThread returned an invalid handle\n");
642
     if (access_thread!=NULL) {
643 644 645
       obey_ar(SetThreadPriority(access_thread,1)==0);
       obey_ar(GetThreadPriority(access_thread)==THREAD_PRIORITY_ERROR_RETURN);
       obey_ar(GetExitCodeThread(access_thread,&exitCode)==0);
646
       ok(CloseHandle(access_thread),"Error Closing thread handle\n");
647
     }
648
   }
649
#if USE_EXTENDED_PRIORITIES
650
   min_priority=-7; max_priority=6;
651 652
#endif
   for(i=min_priority;i<=max_priority;i++) {
653
     ok(SetThreadPriority(curthread,i)!=0,
654
        "SetThreadPriority Failed for priority: %d\n",i);
655
     ok(GetThreadPriority(curthread)==i,
656
        "GetThreadPriority Failed for priority: %d\n",i);
657 658
   }
   ok(SetThreadPriority(curthread,THREAD_PRIORITY_TIME_CRITICAL)!=0,
659
      "SetThreadPriority Failed\n");
660
   ok(GetThreadPriority(curthread)==THREAD_PRIORITY_TIME_CRITICAL,
661
      "GetThreadPriority Failed\n");
662
   ok(SetThreadPriority(curthread,THREAD_PRIORITY_IDLE)!=0,
663
       "SetThreadPriority Failed\n");
664
   ok(GetThreadPriority(curthread)==THREAD_PRIORITY_IDLE,
665 666
       "GetThreadPriority Failed\n");
   ok(SetThreadPriority(curthread,0)!=0,"SetThreadPriority Failed\n");
667

668 669 670 671 672 673
/* Check that the thread priority is not changed if SetThreadPriority
   is called with a value outside of the max/min range */
   SetThreadPriority(curthread,min_priority);
   SetLastError(0xdeadbeef);
   rc = SetThreadPriority(curthread,min_priority-1);

674
   ok(rc == FALSE, "SetThreadPriority passed with a bad argument\n");
675 676 677 678
   ok(GetLastError() == ERROR_INVALID_PARAMETER ||
      GetLastError() == ERROR_INVALID_PRIORITY /* Win9x */,
      "SetThreadPriority error %d, expected ERROR_INVALID_PARAMETER or ERROR_INVALID_PRIORITY\n",
      GetLastError());
679 680
   ok(GetThreadPriority(curthread)==min_priority,
      "GetThreadPriority didn't return min_priority\n");
681 682 683 684 685

   SetThreadPriority(curthread,max_priority);
   SetLastError(0xdeadbeef);
   rc = SetThreadPriority(curthread,max_priority+1);

686
   ok(rc == FALSE, "SetThreadPriority passed with a bad argument\n");
687 688 689 690
   ok(GetLastError() == ERROR_INVALID_PARAMETER ||
      GetLastError() == ERROR_INVALID_PRIORITY /* Win9x */,
      "SetThreadPriority error %d, expected ERROR_INVALID_PARAMETER or ERROR_INVALID_PRIORITY\n",
      GetLastError());
691 692
   ok(GetThreadPriority(curthread)==max_priority,
      "GetThreadPriority didn't return max_priority\n");
693

694
/* Check thread priority boost */
695 696 697 698 699 700
   if (!pGetThreadPriorityBoost || !pSetThreadPriorityBoost) 
     return; /* Win9x */

   SetLastError(0xdeadbeef);
   rc=pGetThreadPriorityBoost(curthread,&disabled);
   if (rc==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
701 702 703 704
   {
      win_skip("GetThreadPriorityBoost is not implemented on WinME\n");
      return;
   }
705

706
   ok(rc!=0,"error=%d\n",GetLastError());
707

708
   if (pOpenThread) {
709
/* check that access control is obeyed */
710 711 712 713 714 715
     access_thread=pOpenThread(THREAD_ALL_ACCESS &
                       (~THREAD_QUERY_INFORMATION) & (~THREAD_SET_INFORMATION),
                       0,curthreadId);
     ok(access_thread!=NULL,"OpenThread returned an invalid handle\n");
     if (access_thread!=NULL) {
       obey_ar(pSetThreadPriorityBoost(access_thread,1)==0);
716
       todo_wine obey_ar(pGetThreadPriorityBoost(access_thread,&disabled)==0);
717 718
       ok(CloseHandle(access_thread),"Error Closing thread handle\n");
     }
719 720 721 722
   }

   todo_wine {
     rc = pSetThreadPriorityBoost(curthread,1);
723
     ok( rc != 0, "error=%d\n",GetLastError());
724 725
     rc=pGetThreadPriorityBoost(curthread,&disabled);
     ok(rc!=0 && disabled==1,
726
        "rc=%d error=%d disabled=%d\n",rc,GetLastError(),disabled);
727 728

     rc = pSetThreadPriorityBoost(curthread,0);
729
     ok( rc != 0, "error=%d\n",GetLastError());
730
   }
731 732 733
   rc=pGetThreadPriorityBoost(curthread,&disabled);
   ok(rc!=0 && disabled==0,
      "rc=%d error=%d disabled=%d\n",rc,GetLastError(),disabled);
734 735 736
}

/* check the GetThreadTimes function */
737
static VOID test_GetThreadTimes(void)
738
{
739
     HANDLE thread,access_thread=NULL;
740 741 742 743
     FILETIME creationTime,exitTime,kernelTime,userTime;
     DWORD threadId;
     int error;

744
     thread = CreateThread(NULL,0,threadFunc2,NULL,
745 746
                           CREATE_SUSPENDED,&threadId);

747
     ok(thread!=NULL,"Create Thread failed\n");
748
/* check that access control is obeyed */
749 750
     if (pOpenThread) {
       access_thread=pOpenThread(THREAD_ALL_ACCESS &
751
                                   (~THREAD_QUERY_INFORMATION), 0,threadId);
752
       ok(access_thread!=NULL,
753
          "OpenThread returned an invalid handle\n");
754
     }
755
     ok(ResumeThread(thread)==1,"Resume thread returned an invalid value\n");
756
     ok(WaitForSingleObject(thread,5000)==WAIT_OBJECT_0,
757
        "ResumeThread didn't work\n");
758 759 760 761 762
     creationTime.dwLowDateTime=99; creationTime.dwHighDateTime=99;
     exitTime.dwLowDateTime=99;     exitTime.dwHighDateTime=99;
     kernelTime.dwLowDateTime=99;   kernelTime.dwHighDateTime=99;
     userTime.dwLowDateTime=99;     userTime.dwHighDateTime=99;
/* GetThreadTimes should set all of the parameters passed to it */
763 764
     error=GetThreadTimes(thread,&creationTime,&exitTime,
                          &kernelTime,&userTime);
765 766 767 768

     if (error == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
       win_skip("GetThreadTimes is not implemented\n");
     else {
769
       ok(error!=0,"GetThreadTimes failed\n");
770
       ok(creationTime.dwLowDateTime!=99 || creationTime.dwHighDateTime!=99,
771
          "creationTime was invalid\n");
772
       ok(exitTime.dwLowDateTime!=99 || exitTime.dwHighDateTime!=99,
773
          "exitTime was invalid\n");
774
       ok(kernelTime.dwLowDateTime!=99 || kernelTime.dwHighDateTime!=99,
775
          "kernelTimewas invalid\n");
776
       ok(userTime.dwLowDateTime!=99 || userTime.dwHighDateTime!=99,
777 778
          "userTime was invalid\n");
       ok(CloseHandle(thread)!=0,"CloseHandle failed\n");
779 780 781 782 783 784 785 786 787
       if(access_thread!=NULL)
       {
         error=GetThreadTimes(access_thread,&creationTime,&exitTime,
                              &kernelTime,&userTime);
         obey_ar(error==0);
       }
     }
     if(access_thread!=NULL) {
       ok(CloseHandle(access_thread)!=0,"CloseHandle Failed\n");
788
     }
789 790 791 792 793
}

/* Check the processor affinity functions */
/* NOTE: These functions should also be checked that they obey access control
*/
794
static VOID test_thread_processor(void)
795 796
{
   HANDLE curthread,curproc;
797
   DWORD_PTR processMask,systemMask,retMask;
798 799
   SYSTEM_INFO sysInfo;
   int error=0;
800 801 802
   BOOL is_wow64;

   if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
803 804 805 806

   sysInfo.dwNumberOfProcessors=0;
   GetSystemInfo(&sysInfo);
   ok(sysInfo.dwNumberOfProcessors>0,
807
      "GetSystemInfo failed to return a valid # of processors\n");
808 809
/* Use the current Thread/process for all tests */
   curthread=GetCurrentThread();
810
   ok(curthread!=NULL,"GetCurrentThread failed\n");
811
   curproc=GetCurrentProcess();
812
   ok(curproc!=NULL,"GetCurrentProcess failed\n");
813 814
/* Check the Affinity Mask functions */
   ok(GetProcessAffinityMask(curproc,&processMask,&systemMask)!=0,
815
      "GetProcessAffinityMask failed\n");
816
   ok(SetThreadAffinityMask(curthread,processMask)==processMask,
817
      "SetThreadAffinityMask failed\n");
818
   ok(SetThreadAffinityMask(curthread,processMask+1)==0,
819
      "SetThreadAffinityMask passed for an illegal processor\n");
820
/* NOTE: Pre-Vista does not recognize the "all processors" flag (all bits set) */
821
   retMask = SetThreadAffinityMask(curthread,~0);
822 823
   ok(broken(retMask==0) || retMask==processMask,
      "SetThreadAffinityMask(thread,-1) failed to request all processors.\n");
824 825 826 827 828 829 830 831 832 833
   if (retMask == processMask && sizeof(ULONG_PTR) > sizeof(ULONG))
   {
       /* only the low 32-bits matter */
       retMask = SetThreadAffinityMask(curthread,~(ULONG_PTR)0);
       ok(retMask == processMask, "SetThreadAffinityMask failed\n");
       retMask = SetThreadAffinityMask(curthread,~(ULONG_PTR)0 >> 3);
       ok(retMask == processMask, "SetThreadAffinityMask failed\n");
       retMask = SetThreadAffinityMask(curthread,~(ULONG_PTR)1);
       ok(retMask == 0, "SetThreadAffinityMask succeeded\n");
   }
834
/* NOTE: This only works on WinNT/2000/XP) */
835
   if (pSetThreadIdealProcessor) {
836 837 838 839 840 841
     SetLastError(0xdeadbeef);
     error=pSetThreadIdealProcessor(curthread,0);
     if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
     {
       win_skip("SetThreadIdealProcessor is not implemented\n");
       return;
842
     }
843 844
     ok(error!=-1, "SetThreadIdealProcessor failed\n");

845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
     if (is_wow64)
     {
         SetLastError(0xdeadbeef);
         error=pSetThreadIdealProcessor(curthread,MAXIMUM_PROCESSORS+1);
         todo_wine
         ok(error!=-1, "SetThreadIdealProcessor failed for %u on Wow64\n", MAXIMUM_PROCESSORS+1);

         SetLastError(0xdeadbeef);
         error=pSetThreadIdealProcessor(curthread,65);
         ok(error==-1, "SetThreadIdealProcessor succeeded with an illegal processor #\n");
         ok(GetLastError()==ERROR_INVALID_PARAMETER,
            "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
     }
     else
     {
         SetLastError(0xdeadbeef);
         error=pSetThreadIdealProcessor(curthread,MAXIMUM_PROCESSORS+1);
         ok(error==-1, "SetThreadIdealProcessor succeeded with an illegal processor #\n");
         ok(GetLastError()==ERROR_INVALID_PARAMETER,
            "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
     }
866 867

     error=pSetThreadIdealProcessor(curthread,MAXIMUM_PROCESSORS);
868
     ok(error!=-1, "SetThreadIdealProcessor failed\n");
869 870 871
   }
}

872 873 874 875 876 877 878
static VOID test_GetThreadExitCode(void)
{
    DWORD exitCode, threadid;
    DWORD GLE, ret;
    HANDLE thread;

    ret = GetExitCodeThread((HANDLE)0x2bad2bad,&exitCode);
879
    ok(ret==0, "GetExitCodeThread returned non zero value: %d\n", ret);
880
    GLE = GetLastError();
881
    ok(GLE==ERROR_INVALID_HANDLE, "GetLastError returned %d (expected 6)\n", GLE);
882 883 884 885 886 887

    thread = CreateThread(NULL,0,threadFunc2,NULL,0,&threadid);
    ret = WaitForSingleObject(thread,100);
    ok(ret==WAIT_OBJECT_0, "threadFunc2 did not exit during 100 ms\n");
    ret = GetExitCodeThread(thread,&exitCode);
    ok(ret==exitCode || ret==1, 
888 889
       "GetExitCodeThread returned %d (expected 1 or %d)\n", ret, exitCode);
    ok(exitCode==99, "threadFunc2 exited with code %d (expected 99)\n", exitCode);
890 891 892
    ok(CloseHandle(thread)!=0,"Error closing thread handle\n");
}

893 894 895
#ifdef __i386__

static int test_value = 0;
896
static HANDLE event;
897

898
static void WINAPI set_test_val( int val )
899 900
{
    test_value += val;
901
    ExitThread(0);
902 903 904 905
}

static DWORD WINAPI threadFunc6(LPVOID p)
{
906 907
    SetEvent( event );
    Sleep( 1000 );
908 909 910 911 912 913 914 915
    test_value *= (int)p;
    return 0;
}

static void test_SetThreadContext(void)
{
    CONTEXT ctx;
    int *stack;
916 917 918
    HANDLE thread;
    DWORD threadid;
    DWORD prevcount;
919
    BOOL ret;
920 921

    SetLastError(0xdeadbeef);
922 923
    event = CreateEvent( NULL, TRUE, FALSE, NULL );
    thread = CreateThread( NULL, 0, threadFunc6, (void *)2, 0, &threadid );
924
    ok( thread != NULL, "CreateThread failed : (%d)\n", GetLastError() );
925 926 927 928 929
    if (!thread)
    {
        trace("Thread creation failed, skipping rest of test\n");
        return;
    }
930 931 932
    WaitForSingleObject( event, INFINITE );
    SuspendThread( thread );
    CloseHandle( event );
933 934

    ctx.ContextFlags = CONTEXT_FULL;
935
    SetLastError(0xdeadbeef);
936 937 938 939 940 941 942 943 944 945 946 947
    ret = GetThreadContext( thread, &ctx );
    ok( ret, "GetThreadContext failed : (%u)\n", GetLastError() );

    if (ret)
    {
        /* simulate a call to set_test_val(10) */
        stack = (int *)ctx.Esp;
        stack[-1] = 10;
        stack[-2] = ctx.Eip;
        ctx.Esp -= 2 * sizeof(int *);
        ctx.Eip = (DWORD)set_test_val;
        SetLastError(0xdeadbeef);
948 949
        ret = SetThreadContext( thread, &ctx );
        ok( ret, "SetThreadContext failed : (%d)\n", GetLastError() );
950
    }
951 952 953

    SetLastError(0xdeadbeef);
    prevcount = ResumeThread( thread );
954
    ok ( prevcount == 1, "Previous suspend count (%d) instead of 1, last error : (%d)\n",
955 956
                         prevcount, GetLastError() );

957
    WaitForSingleObject( thread, INFINITE );
958
    ok( test_value == 10, "test_value %d\n", test_value );
959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974

    ctx.ContextFlags = CONTEXT_FULL;
    SetLastError(0xdeadbeef);
    ret = GetThreadContext( thread, &ctx );
    ok( !ret, "GetThreadContext succeeded\n" );
    ok( GetLastError() == ERROR_GEN_FAILURE || broken(GetLastError() == ERROR_INVALID_HANDLE), /* win2k */
        "wrong error %u\n", GetLastError() );

    SetLastError(0xdeadbeef);
    ret = SetThreadContext( thread, &ctx );
    ok( !ret, "SetThreadContext succeeded\n" );
    ok( GetLastError() == ERROR_GEN_FAILURE || GetLastError() == ERROR_ACCESS_DENIED ||
        broken(GetLastError() == ERROR_INVALID_HANDLE), /* win2k */
        "wrong error %u\n", GetLastError() );

    CloseHandle( thread );
975 976 977 978
}

#endif  /* __i386__ */

979 980 981 982 983 984 985 986 987 988 989 990 991 992
static HANDLE finish_event;
static LONG times_executed;

static DWORD CALLBACK work_function(void *p)
{
    LONG executed = InterlockedIncrement(&times_executed);

    if (executed == 100)
        SetEvent(finish_event);
    return 0;
}

static void test_QueueUserWorkItem(void)
{
993
    INT_PTR i;
994 995 996
    DWORD wait_result;
    DWORD before, after;

997 998 999
    /* QueueUserWorkItem not present on win9x */
    if (!pQueueUserWorkItem) return;

1000 1001 1002 1003 1004 1005
    finish_event = CreateEvent(NULL, TRUE, FALSE, NULL);

    before = GetTickCount();

    for (i = 0; i < 100; i++)
    {
1006
        BOOL ret = pQueueUserWorkItem(work_function, (void *)i, WT_EXECUTEDEFAULT);
1007
        ok(ret, "QueueUserWorkItem failed with error %d\n", GetLastError());
1008 1009 1010 1011 1012
    }

    wait_result = WaitForSingleObject(finish_event, 10000);

    after = GetTickCount();
1013 1014
    trace("100 QueueUserWorkItem calls took %dms\n", after - before);
    ok(wait_result == WAIT_OBJECT_0, "wait failed with error 0x%x\n", wait_result);
1015 1016 1017

    ok(times_executed == 100, "didn't execute all of the work items\n");
}
1018

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
static void CALLBACK signaled_function(PVOID p, BOOLEAN TimerOrWaitFired)
{
    HANDLE event = p;
    SetEvent(event);
    ok(!TimerOrWaitFired, "wait shouldn't have timed out\n");
}

static void CALLBACK timeout_function(PVOID p, BOOLEAN TimerOrWaitFired)
{
    HANDLE event = p;
    SetEvent(event);
    ok(TimerOrWaitFired, "wait should have timed out\n");
}

static void test_RegisterWaitForSingleObject(void)
{
    BOOL ret;
    HANDLE wait_handle;
    HANDLE handle;
    HANDLE complete_event;

    if (!pRegisterWaitForSingleObject || !pUnregisterWait)
    {
1042
        win_skip("RegisterWaitForSingleObject or UnregisterWait not implemented\n");
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
        return;
    }

    /* test signaled case */

    handle = CreateEvent(NULL, TRUE, TRUE, NULL);
    complete_event = CreateEvent(NULL, FALSE, FALSE, NULL);

    ret = pRegisterWaitForSingleObject(&wait_handle, handle, signaled_function, complete_event, INFINITE, WT_EXECUTEONLYONCE);
    ok(ret, "RegisterWaitForSingleObject failed with error %d\n", GetLastError());

    WaitForSingleObject(complete_event, INFINITE);
    /* give worker thread chance to complete */
    Sleep(100);

    ret = pUnregisterWait(wait_handle);
    ok(ret, "UnregisterWait failed with error %d\n", GetLastError());

    /* test cancel case */

    ResetEvent(handle);

    ret = pRegisterWaitForSingleObject(&wait_handle, handle, signaled_function, complete_event, INFINITE, WT_EXECUTEONLYONCE);
    ok(ret, "RegisterWaitForSingleObject failed with error %d\n", GetLastError());

    ret = pUnregisterWait(wait_handle);
    ok(ret, "UnregisterWait failed with error %d\n", GetLastError());

    /* test timeout case */

    ret = pRegisterWaitForSingleObject(&wait_handle, handle, timeout_function, complete_event, 0, WT_EXECUTEONLYONCE);
    ok(ret, "RegisterWaitForSingleObject failed with error %d\n", GetLastError());

    WaitForSingleObject(complete_event, INFINITE);
    /* give worker thread chance to complete */
    Sleep(100);

    ret = pUnregisterWait(wait_handle);
    ok(ret, "UnregisterWait failed with error %d\n", GetLastError());
}

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
static DWORD TLS_main;
static DWORD TLS_index0, TLS_index1;

static DWORD WINAPI TLS_InheritanceProc(LPVOID p)
{
  /* We should NOT inherit the TLS values from our parent or from the
     main thread.  */
  LPVOID val;

  val = TlsGetValue(TLS_main);
  ok(val == NULL, "TLS inheritance failed\n");

  val = TlsGetValue(TLS_index0);
  ok(val == NULL, "TLS inheritance failed\n");

  val = TlsGetValue(TLS_index1);
  ok(val == NULL, "TLS inheritance failed\n");

  return 0;
}

/* Basic TLS usage test.  Make sure we can create slots and the values we
   store in them are separate among threads.  Also test TLS value
   inheritance with TLS_InheritanceProc.  */
static DWORD WINAPI TLS_ThreadProc(LPVOID p)
{
1110
  LONG_PTR id = (LONG_PTR) p;
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
  LPVOID val;
  BOOL ret;

  if (sync_threads_and_run_one(0, id))
  {
    TLS_index0 = TlsAlloc();
    ok(TLS_index0 != TLS_OUT_OF_INDEXES, "TlsAlloc failed\n");
  }
  resync_after_run();

  if (sync_threads_and_run_one(1, id))
  {
    TLS_index1 = TlsAlloc();
    ok(TLS_index1 != TLS_OUT_OF_INDEXES, "TlsAlloc failed\n");

    /* Slot indices should be different even if created in different
       threads.  */
    ok(TLS_index0 != TLS_index1, "TlsAlloc failed\n");

    /* Both slots should be initialized to NULL */
    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");
  }
  resync_after_run();

  if (sync_threads_and_run_one(0, id))
  {
    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");

    ret = TlsSetValue(TLS_index0, (LPVOID) 1);
    ok(ret, "TlsSetValue failed\n");

    ret = TlsSetValue(TLS_index1, (LPVOID) 2);
    ok(ret, "TlsSetValue failed\n");

    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 1, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 2, "TLS slot not initialized correctly\n");
  }
  resync_after_run();

  if (sync_threads_and_run_one(1, id))
  {
    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == NULL, "TLS slot not initialized correctly\n");

    ret = TlsSetValue(TLS_index0, (LPVOID) 3);
    ok(ret, "TlsSetValue failed\n");

    ret = TlsSetValue(TLS_index1, (LPVOID) 4);
    ok(ret, "TlsSetValue failed\n");

    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 3, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 4, "TLS slot not initialized correctly\n");
  }
  resync_after_run();

  if (sync_threads_and_run_one(0, id))
  {
    HANDLE thread;
1196
    DWORD waitret, tid;
1197 1198 1199 1200 1201 1202 1203 1204 1205

    val = TlsGetValue(TLS_index0);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 1, "TLS slot not initialized correctly\n");

    val = TlsGetValue(TLS_index1);
    ok(GetLastError() == ERROR_SUCCESS, "TlsGetValue failed\n");
    ok(val == (LPVOID) 2, "TLS slot not initialized correctly\n");

1206
    thread = CreateThread(NULL, 0, TLS_InheritanceProc, 0, 0, &tid);
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
    ok(thread != NULL, "CreateThread failed\n");
    waitret = WaitForSingleObject(thread, 60000);
    ok(waitret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(thread);

    ret = TlsFree(TLS_index0);
    ok(ret, "TlsFree failed\n");
  }
  resync_after_run();

  if (sync_threads_and_run_one(1, id))
  {
    ret = TlsFree(TLS_index1);
    ok(ret, "TlsFree failed\n");
  }
  resync_after_run();

  return 0;
}

static void test_TLS(void)
{
  HANDLE threads[2];
1230
  LONG_PTR i;
1231 1232 1233
  DWORD ret;
  BOOL suc;

1234
  init_thread_sync_helpers();
1235 1236 1237 1238 1239 1240 1241 1242 1243

  /* Allocate a TLS slot in the main thread to test for inheritance.  */
  TLS_main = TlsAlloc();
  ok(TLS_main != TLS_OUT_OF_INDEXES, "TlsAlloc failed\n");
  suc = TlsSetValue(TLS_main, (LPVOID) 4114);
  ok(suc, "TlsSetValue failed\n");

  for (i = 0; i < 2; ++i)
  {
1244 1245 1246
    DWORD tid;

    threads[i] = CreateThread(NULL, 0, TLS_ThreadProc, (LPVOID) i, 0, &tid);
1247 1248 1249 1250
    ok(threads[i] != NULL, "CreateThread failed\n");
  }

  ret = WaitForMultipleObjects(2, threads, TRUE, 60000);
1251
  ok(ret == WAIT_OBJECT_0 || ret == WAIT_OBJECT_0+1 /* nt4 */, "WaitForMultipleObjects failed %u\n",ret);
1252 1253 1254 1255 1256 1257 1258 1259 1260

  for (i = 0; i < 2; ++i)
    CloseHandle(threads[i]);

  suc = TlsFree(TLS_main);
  ok(suc, "TlsFree failed\n");
  cleanup_thread_sync_helpers();
}

1261 1262 1263 1264 1265 1266 1267 1268 1269
static void test_ThreadErrorMode(void)
{
    DWORD oldmode;
    DWORD mode;
    DWORD rtlmode;
    BOOL ret;

    if (!pSetThreadErrorMode || !pGetThreadErrorMode)
    {
1270
        win_skip("SetThreadErrorMode and/or GetThreadErrorMode unavailable (added in Windows 7)\n");
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
        return;
    }

    if (!pRtlGetThreadErrorMode) {
        win_skip("RtlGetThreadErrorMode not available\n");
        return;
    }

    oldmode = pGetThreadErrorMode();

    ret = pSetThreadErrorMode(0, &mode);
    ok(ret, "SetThreadErrorMode failed\n");
    ok(mode == oldmode,
       "SetThreadErrorMode returned old mode 0x%x, expected 0x%x\n",
       mode, oldmode);
    mode = pGetThreadErrorMode();
    ok(mode == 0, "GetThreadErrorMode returned mode 0x%x, expected 0\n", mode);
    rtlmode = pRtlGetThreadErrorMode();
    ok(rtlmode == 0,
       "RtlGetThreadErrorMode returned mode 0x%x, expected 0\n", mode);

    ret = pSetThreadErrorMode(SEM_FAILCRITICALERRORS, &mode);
    ok(ret, "SetThreadErrorMode failed\n");
    ok(mode == 0,
       "SetThreadErrorMode returned old mode 0x%x, expected 0\n", mode);
    mode = pGetThreadErrorMode();
    ok(mode == SEM_FAILCRITICALERRORS,
       "GetThreadErrorMode returned mode 0x%x, expected SEM_FAILCRITICALERRORS\n",
       mode);
    rtlmode = pRtlGetThreadErrorMode();
    ok(rtlmode == 0x10,
       "RtlGetThreadErrorMode returned mode 0x%x, expected 0x10\n", mode);

    ret = pSetThreadErrorMode(SEM_NOGPFAULTERRORBOX, &mode);
    ok(ret, "SetThreadErrorMode failed\n");
    ok(mode == SEM_FAILCRITICALERRORS,
       "SetThreadErrorMode returned old mode 0x%x, expected SEM_FAILCRITICALERRORS\n",
       mode);
    mode = pGetThreadErrorMode();
    ok(mode == SEM_NOGPFAULTERRORBOX,
       "GetThreadErrorMode returned mode 0x%x, expected SEM_NOGPFAULTERRORBOX\n",
       mode);
    rtlmode = pRtlGetThreadErrorMode();
    ok(rtlmode == 0x20,
       "RtlGetThreadErrorMode returned mode 0x%x, expected 0x20\n", mode);

    ret = pSetThreadErrorMode(SEM_NOOPENFILEERRORBOX, NULL);
    ok(ret, "SetThreadErrorMode failed\n");
    mode = pGetThreadErrorMode();
    ok(mode == SEM_NOOPENFILEERRORBOX,
       "GetThreadErrorMode returned mode 0x%x, expected SEM_NOOPENFILEERRORBOX\n",
       mode);
    rtlmode = pRtlGetThreadErrorMode();
    ok(rtlmode == 0x40,
       "RtlGetThreadErrorMode returned mode 0x%x, expected 0x40\n", rtlmode);

    for (mode = 1; mode; mode <<= 1)
    {
        ret = pSetThreadErrorMode(mode, NULL);
        if (mode & (SEM_FAILCRITICALERRORS |
                    SEM_NOGPFAULTERRORBOX |
                    SEM_NOOPENFILEERRORBOX))
        {
            ok(ret,
               "SetThreadErrorMode(0x%x,NULL) failed with error %d\n",
               mode, GetLastError());
        }
        else
        {
            DWORD GLE = GetLastError();
            ok(!ret,
               "SetThreadErrorMode(0x%x,NULL) succeeded, expected failure\n",
               mode);
            ok(GLE == ERROR_INVALID_PARAMETER,
               "SetThreadErrorMode(0x%x,NULL) failed with %d, "
               "expected ERROR_INVALID_PARAMETER\n",
               mode, GLE);
        }
    }

    pSetThreadErrorMode(oldmode, NULL);
}

1354
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
static inline void set_fpu_cw(WORD cw)
{
    __asm__ volatile ("fnclex; fldcw %0" : : "m" (cw));
}

static inline WORD get_fpu_cw(void)
{
    WORD cw = 0;
    __asm__ volatile ("fnstcw %0" : "=m" (cw));
    return cw;
}

struct fpu_thread_ctx
{
    WORD cw;
    HANDLE finished;
};

static DWORD WINAPI fpu_thread(void *param)
{
    struct fpu_thread_ctx *ctx = param;
    BOOL ret;

    ctx->cw = get_fpu_cw();

    ret = SetEvent(ctx->finished);
    ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());

    return 0;
}

static WORD get_thread_fpu_cw(void)
{
    struct fpu_thread_ctx ctx;
    DWORD tid, res;
    HANDLE thread;

    ctx.finished = CreateEvent(NULL, FALSE, FALSE, NULL);
    ok(!!ctx.finished, "Failed to create event, last error %#x.\n", GetLastError());

    thread = CreateThread(NULL, 0, fpu_thread, &ctx, 0, &tid);
    ok(!!thread, "Failed to create thread, last error %#x.\n", GetLastError());

    res = WaitForSingleObject(ctx.finished, INFINITE);
    ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());

    res = CloseHandle(ctx.finished);
    ok(!!res, "Failed to close event handle, last error %#x.\n", GetLastError());

    return ctx.cw;
}

static void test_thread_fpu_cw(void)
{
1409
    WORD initial_cw, cw;
1410 1411

    initial_cw = get_fpu_cw();
1412
    ok(initial_cw == 0x27f, "Expected FPU control word 0x27f, got %#x.\n", initial_cw);
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430

    cw = get_thread_fpu_cw();
    ok(cw == 0x27f, "Expected FPU control word 0x27f, got %#x.\n", cw);

    set_fpu_cw(0xf60);
    cw = get_fpu_cw();
    ok(cw == 0xf60, "Expected FPU control word 0xf60, got %#x.\n", cw);

    cw = get_thread_fpu_cw();
    ok(cw == 0x27f, "Expected FPU control word 0x27f, got %#x.\n", cw);

    cw = get_fpu_cw();
    ok(cw == 0xf60, "Expected FPU control word 0xf60, got %#x.\n", cw);

    set_fpu_cw(initial_cw);
    cw = get_fpu_cw();
    ok(cw == initial_cw, "Expected FPU control word %#x, got %#x.\n", initial_cw, cw);
}
1431
#endif
1432

1433 1434 1435
START_TEST(thread)
{
   HINSTANCE lib;
1436
   HINSTANCE ntdll;
1437 1438 1439
   int argc;
   char **argv;
   argc = winetest_get_mainargs( &argv );
1440 1441 1442
/* Neither Cygwin nor mingW export OpenThread, so do a dynamic check
   so that the compile passes
*/
1443 1444
   lib=GetModuleHandleA("kernel32.dll");
   ok(lib!=NULL,"Couldn't get a handle for kernel32.dll\n");
1445 1446 1447 1448 1449 1450 1451
   pGetThreadPriorityBoost=(void *)GetProcAddress(lib,"GetThreadPriorityBoost");
   pOpenThread=(void *)GetProcAddress(lib,"OpenThread");
   pQueueUserWorkItem=(void *)GetProcAddress(lib,"QueueUserWorkItem");
   pSetThreadIdealProcessor=(void *)GetProcAddress(lib,"SetThreadIdealProcessor");
   pSetThreadPriorityBoost=(void *)GetProcAddress(lib,"SetThreadPriorityBoost");
   pRegisterWaitForSingleObject=(void *)GetProcAddress(lib,"RegisterWaitForSingleObject");
   pUnregisterWait=(void *)GetProcAddress(lib,"UnregisterWait");
1452
   pIsWow64Process=(void *)GetProcAddress(lib,"IsWow64Process");
1453 1454 1455 1456 1457 1458 1459 1460
   pSetThreadErrorMode=(void *)GetProcAddress(lib,"SetThreadErrorMode");
   pGetThreadErrorMode=(void *)GetProcAddress(lib,"GetThreadErrorMode");

   ntdll=GetModuleHandleA("ntdll.dll");
   if (ntdll)
   {
       pRtlGetThreadErrorMode=(void *)GetProcAddress(ntdll,"RtlGetThreadErrorMode");
   }
1461 1462 1463 1464 1465

   if (argc >= 3)
   {
       if (!strcmp(argv[2], "sleep"))
       {
1466 1467 1468 1469
           HANDLE hAddrEvents[2];
           create_function_addr_events(hAddrEvents);
           SetEvent(hAddrEvents[0]);
           SetEvent(hAddrEvents[1]);
1470 1471 1472 1473 1474 1475
           Sleep(5000); /* spawned process runs for at most 5 seconds */
           return;
       }
       while (1)
       {
           HANDLE hThread;
1476 1477
           DWORD tid;
           hThread = CreateThread(NULL, 0, threadFunc2, NULL, 0, &tid);
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
           ok(hThread != NULL, "CreateThread failed, error %u\n",
              GetLastError());
           ok(WaitForSingleObject(hThread, 200) == WAIT_OBJECT_0,
              "Thread did not exit in time\n");
           if (hThread == NULL) break;
           CloseHandle(hThread);
       }
       return;
   }

   test_CreateRemoteThread();
1489 1490 1491 1492 1493 1494 1495 1496
   test_CreateThread_basic();
   test_CreateThread_suspended();
   test_SuspendThread();
   test_TerminateThread();
   test_CreateThread_stack();
   test_thread_priority();
   test_GetThreadTimes();
   test_thread_processor();
1497
   test_GetThreadExitCode();
1498 1499 1500
#ifdef __i386__
   test_SetThreadContext();
#endif
1501
   test_QueueUserWorkItem();
1502
   test_RegisterWaitForSingleObject();
1503
   test_TLS();
1504
   test_ThreadErrorMode();
1505 1506 1507
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
   test_thread_fpu_cw();
#endif
1508
}