git.oblomov.eu Git - wine/blob - dlls/kernel32/tests/process.c

   1 /*
   2  * Unit test suite for CreateProcess function.
   3  *
   4  * Copyright 2002 Eric Pouech
   5  * Copyright 2006 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "wincon.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35
  36 #include "wine/test.h"
  37
  38 static HINSTANCE hkernel32;
  39 static LPVOID (WINAPI *pVirtualAllocEx)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD);
  40 static BOOL   (WINAPI *pVirtualFreeEx)(HANDLE, LPVOID, SIZE_T, DWORD);
  41
  42 /* ############################### */
  43 static char     base[MAX_PATH];
  44 static char     selfname[MAX_PATH];
  45 static char*    exename;
  46 static char     resfile[MAX_PATH];
  47
  48 static int      myARGC;
  49 static char**   myARGV;
  50
  51 /* As some environment variables get very long on Unix, we only test for
  52  * the first 127 bytes.
  53  * Note that increasing this value past 256 may exceed the buffer size
  54  * limitations of the *Profile functions (at least on Wine).
  55  */
  56 #define MAX_LISTED_ENV_VAR      128
  57
  58 /* ---------------- portable memory allocation thingie */
  59
  60 static char     memory[1024*256];
  61 static char*    memory_index = memory;
  62
  63 static char*    grab_memory(size_t len)
  64 {
  65     char*       ret = memory_index;
  66     /* align on dword */
  67     len = (len + 3) & ~3;
  68     memory_index += len;
  69     assert(memory_index <= memory + sizeof(memory));
  70     return ret;
  71 }
  72
  73 static void     release_memory(void)
  74 {
  75     memory_index = memory;
  76 }
  77
  78 /* ---------------- simplistic tool to encode/decode strings (to hide \ " ' and such) */
  79
  80 static const char* encodeA(const char* str)
  81 {
  82     char*       ptr;
  83     size_t      len,i;
  84
  85     if (!str) return "";
  86     len = strlen(str) + 1;
  87     ptr = grab_memory(len * 2 + 1);
  88     for (i = 0; i < len; i++)
  89         sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]);
  90     ptr[2 * len] = '\0';
  91     return ptr;
  92 }
  93
  94 static const char* encodeW(const WCHAR* str)
  95 {
  96     char*       ptr;
  97     size_t      len,i;
  98
  99     if (!str) return "";
 100     len = lstrlenW(str) + 1;
 101     ptr = grab_memory(len * 4 + 1);
 102     assert(ptr);
 103     for (i = 0; i < len; i++)
 104         sprintf(&ptr[i * 4], "%04x", (unsigned int)(unsigned short)str[i]);
 105     ptr[4 * len] = '\0';
 106     return ptr;
 107 }
 108
 109 static unsigned decode_char(char c)
 110 {
 111     if (c >= '0' && c <= '9') return c - '0';
 112     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
 113     assert(c >= 'A' && c <= 'F');
 114     return c - 'A' + 10;
 115 }
 116
 117 static char*    decodeA(const char* str)
 118 {
 119     char*       ptr;
 120     size_t      len,i;
 121
 122     len = strlen(str) / 2;
 123     if (!len--) return NULL;
 124     ptr = grab_memory(len + 1);
 125     for (i = 0; i < len; i++)
 126         ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]);
 127     ptr[len] = '\0';
 128     return ptr;
 129 }
 130
 131 /* This will be needed to decode Unicode strings saved by the child process
 132  * when we test Unicode functions.
 133  */
 134 static WCHAR*   decodeW(const char* str)
 135 {
 136     size_t      len;
 137     WCHAR*      ptr;
 138     int         i;
 139
 140     len = strlen(str) / 4;
 141     if (!len--) return NULL;
 142     ptr = (WCHAR*)grab_memory(len * 2 + 1);
 143     for (i = 0; i < len; i++)
 144         ptr[i] = (decode_char(str[4 * i]) << 12) |
 145             (decode_char(str[4 * i + 1]) << 8) |
 146             (decode_char(str[4 * i + 2]) << 4) |
 147             (decode_char(str[4 * i + 3]) << 0);
 148     ptr[len] = '\0';
 149     return ptr;
 150 }
 151
 152 /******************************************************************
 153  *              init
 154  *
 155  * generates basic information like:
 156  *      base:           absolute path to curr dir
 157  *      selfname:       the way to reinvoke ourselves
 158  *      exename:        executable without the path
 159  * function-pointers, which are not implemented in all windows versions
 160  */
 161 static int     init(void)
 162 {
 163     char *p;
 164
 165     myARGC = winetest_get_mainargs( &myARGV );
 166     if (!GetCurrentDirectoryA(sizeof(base), base)) return 0;
 167     strcpy(selfname, myARGV[0]);
 168
 169     /* Strip the path of selfname */
 170     if ((p = strrchr(selfname, '\\')) != NULL) exename = p + 1;
 171     else exename = selfname;
 172
 173     if ((p = strrchr(exename, '/')) != NULL) exename = p + 1;
 174
 175     hkernel32 = GetModuleHandleA("kernel32");
 176     pVirtualAllocEx = (void *) GetProcAddress(hkernel32, "VirtualAllocEx");
 177     pVirtualFreeEx = (void *) GetProcAddress(hkernel32, "VirtualFreeEx");
 178     return 1;
 179 }
 180
 181 /******************************************************************
 182  *              get_file_name
 183  *
 184  * generates an absolute file_name for temporary file
 185  *
 186  */
 187 static void     get_file_name(char* buf)
 188 {
 189     char        path[MAX_PATH];
 190
 191     buf[0] = '\0';
 192     GetTempPathA(sizeof(path), path);
 193     GetTempFileNameA(path, "wt", 0, buf);
 194 }
 195
 196 /******************************************************************
 197  *              static void     childPrintf
 198  *
 199  */
 200 static void     childPrintf(HANDLE h, const char* fmt, ...)
 201 {
 202     va_list     valist;
 203     char        buffer[1024+4*MAX_LISTED_ENV_VAR];
 204     DWORD       w;
 205
 206     va_start(valist, fmt);
 207     vsprintf(buffer, fmt, valist);
 208     va_end(valist);
 209     WriteFile(h, buffer, strlen(buffer), &w, NULL);
 210 }
 211
 212
 213 /******************************************************************
 214  *              doChild
 215  *
 216  * output most of the information in the child process
 217  */
 218 static void     doChild(const char* file, const char* option)
 219 {
 220     STARTUPINFOA        siA;
 221     STARTUPINFOW        siW;
 222     int                 i;
 223     char*               ptrA;
 224     WCHAR*              ptrW;
 225     char                bufA[MAX_PATH];
 226     WCHAR               bufW[MAX_PATH];
 227     HANDLE              hFile = CreateFileA(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 228     BOOL ret;
 229
 230     if (hFile == INVALID_HANDLE_VALUE) return;
 231
 232     /* output of startup info (Ansi) */
 233     GetStartupInfoA(&siA);
 234     childPrintf(hFile,
 235                 "[StartupInfoA]\ncb=%08ld\nlpDesktop=%s\nlpTitle=%s\n"
 236                 "dwX=%lu\ndwY=%lu\ndwXSize=%lu\ndwYSize=%lu\n"
 237                 "dwXCountChars=%lu\ndwYCountChars=%lu\ndwFillAttribute=%lu\n"
 238                 "dwFlags=%lu\nwShowWindow=%u\n"
 239                 "hStdInput=%lu\nhStdOutput=%lu\nhStdError=%lu\n\n",
 240                 siA.cb, encodeA(siA.lpDesktop), encodeA(siA.lpTitle),
 241                 siA.dwX, siA.dwY, siA.dwXSize, siA.dwYSize,
 242                 siA.dwXCountChars, siA.dwYCountChars, siA.dwFillAttribute,
 243                 siA.dwFlags, siA.wShowWindow,
 244                 (DWORD)siA.hStdInput, (DWORD)siA.hStdOutput, (DWORD)siA.hStdError);
 245
 246     /* since GetStartupInfoW is only implemented in win2k,
 247      * zero out before calling so we can notice the difference
 248      */
 249     memset(&siW, 0, sizeof(siW));
 250     GetStartupInfoW(&siW);
 251     childPrintf(hFile,
 252                 "[StartupInfoW]\ncb=%08ld\nlpDesktop=%s\nlpTitle=%s\n"
 253                 "dwX=%lu\ndwY=%lu\ndwXSize=%lu\ndwYSize=%lu\n"
 254                 "dwXCountChars=%lu\ndwYCountChars=%lu\ndwFillAttribute=%lu\n"
 255                 "dwFlags=%lu\nwShowWindow=%u\n"
 256                 "hStdInput=%lu\nhStdOutput=%lu\nhStdError=%lu\n\n",
 257                 siW.cb, encodeW(siW.lpDesktop), encodeW(siW.lpTitle),
 258                 siW.dwX, siW.dwY, siW.dwXSize, siW.dwYSize,
 259                 siW.dwXCountChars, siW.dwYCountChars, siW.dwFillAttribute,
 260                 siW.dwFlags, siW.wShowWindow,
 261                 (DWORD)siW.hStdInput, (DWORD)siW.hStdOutput, (DWORD)siW.hStdError);
 262
 263     /* Arguments */
 264     childPrintf(hFile, "[Arguments]\nargcA=%d\n", myARGC);
 265     for (i = 0; i < myARGC; i++)
 266     {
 267         childPrintf(hFile, "argvA%d=%s\n", i, encodeA(myARGV[i]));
 268     }
 269     childPrintf(hFile, "CommandLineA=%s\n", encodeA(GetCommandLineA()));
 270
 271 #if 0
 272     int                 argcW;
 273     WCHAR**             argvW;
 274
 275     /* this is part of shell32... and should be tested there */
 276     argvW = CommandLineToArgvW(GetCommandLineW(), &argcW);
 277     for (i = 0; i < argcW; i++)
 278     {
 279         childPrintf(hFile, "argvW%d=%s\n", i, encodeW(argvW[i]));
 280     }
 281 #endif
 282     childPrintf(hFile, "CommandLineW=%s\n\n", encodeW(GetCommandLineW()));
 283
 284     /* output of environment (Ansi) */
 285     ptrA = GetEnvironmentStringsA();
 286     if (ptrA)
 287     {
 288         char    env_var[MAX_LISTED_ENV_VAR];
 289
 290         childPrintf(hFile, "[EnvironmentA]\n");
 291         i = 0;
 292         while (*ptrA)
 293         {
 294             lstrcpynA(env_var, ptrA, MAX_LISTED_ENV_VAR);
 295             childPrintf(hFile, "env%d=%s\n", i, encodeA(env_var));
 296             i++;
 297             ptrA += strlen(ptrA) + 1;
 298         }
 299         childPrintf(hFile, "len=%d\n\n", i);
 300     }
 301
 302     /* output of environment (Unicode) */
 303     ptrW = GetEnvironmentStringsW();
 304     if (ptrW)
 305     {
 306         WCHAR   env_var[MAX_LISTED_ENV_VAR];
 307
 308         childPrintf(hFile, "[EnvironmentW]\n");
 309         i = 0;
 310         while (*ptrW)
 311         {
 312             lstrcpynW(env_var, ptrW, MAX_LISTED_ENV_VAR - 1);
 313             env_var[MAX_LISTED_ENV_VAR - 1] = '\0';
 314             childPrintf(hFile, "env%d=%s\n", i, encodeW(env_var));
 315             i++;
 316             ptrW += lstrlenW(ptrW) + 1;
 317         }
 318         childPrintf(hFile, "len=%d\n\n", i);
 319     }
 320
 321     childPrintf(hFile, "[Misc]\n");
 322     if (GetCurrentDirectoryA(sizeof(bufA), bufA))
 323         childPrintf(hFile, "CurrDirA=%s\n", encodeA(bufA));
 324     if (GetCurrentDirectoryW(sizeof(bufW) / sizeof(bufW[0]), bufW))
 325         childPrintf(hFile, "CurrDirW=%s\n", encodeW(bufW));
 326     childPrintf(hFile, "\n");
 327
 328     if (option && strcmp(option, "console") == 0)
 329     {
 330         CONSOLE_SCREEN_BUFFER_INFO      sbi;
 331         HANDLE hConIn  = GetStdHandle(STD_INPUT_HANDLE);
 332         HANDLE hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
 333         DWORD modeIn, modeOut;
 334
 335         childPrintf(hFile, "[Console]\n");
 336         if (GetConsoleScreenBufferInfo(hConOut, &sbi))
 337         {
 338             childPrintf(hFile, "SizeX=%d\nSizeY=%d\nCursorX=%d\nCursorY=%d\nAttributes=%d\n",
 339                         sbi.dwSize.X, sbi.dwSize.Y, sbi.dwCursorPosition.X, sbi.dwCursorPosition.Y, sbi.wAttributes);
 340             childPrintf(hFile, "winLeft=%d\nwinTop=%d\nwinRight=%d\nwinBottom=%d\n",
 341                         sbi.srWindow.Left, sbi.srWindow.Top, sbi.srWindow.Right, sbi.srWindow.Bottom);
 342             childPrintf(hFile, "maxWinWidth=%d\nmaxWinHeight=%d\n",
 343                         sbi.dwMaximumWindowSize.X, sbi.dwMaximumWindowSize.Y);
 344         }
 345         childPrintf(hFile, "InputCP=%d\nOutputCP=%d\n",
 346                     GetConsoleCP(), GetConsoleOutputCP());
 347         if (GetConsoleMode(hConIn, &modeIn))
 348             childPrintf(hFile, "InputMode=%ld\n", modeIn);
 349         if (GetConsoleMode(hConOut, &modeOut))
 350             childPrintf(hFile, "OutputMode=%ld\n", modeOut);
 351
 352         /* now that we have written all relevant information, let's change it */
 353         SetLastError(0xdeadbeef);
 354         ret = SetConsoleCP(1252);
 355         if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 356         {
 357             win_skip("Setting the codepage is not implemented");
 358         }
 359         else
 360         {
 361             ok(ret, "Setting CP\n");
 362             ok(SetConsoleOutputCP(1252), "Setting SB CP\n");
 363         }
 364
 365         ret = SetConsoleMode(hConIn, modeIn ^ 1);
 366         ok( ret, "Setting mode (%d)\n", GetLastError());
 367         ret = SetConsoleMode(hConOut, modeOut ^ 1);
 368         ok( ret, "Setting mode (%d)\n", GetLastError());
 369         sbi.dwCursorPosition.X ^= 1;
 370         sbi.dwCursorPosition.Y ^= 1;
 371         ret = SetConsoleCursorPosition(hConOut, sbi.dwCursorPosition);
 372         ok( ret, "Setting cursor position (%d)\n", GetLastError());
 373     }
 374     if (option && strcmp(option, "stdhandle") == 0)
 375     {
 376         HANDLE hStdIn  = GetStdHandle(STD_INPUT_HANDLE);
 377         HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
 378
 379         if (hStdIn != INVALID_HANDLE_VALUE || hStdOut != INVALID_HANDLE_VALUE)
 380         {
 381             char buf[1024];
 382             DWORD r, w;
 383
 384             ok(ReadFile(hStdIn, buf, sizeof(buf), &r, NULL) && r > 0, "Reading message from input pipe\n");
 385             childPrintf(hFile, "[StdHandle]\nmsg=%s\n\n", encodeA(buf));
 386             ok(WriteFile(hStdOut, buf, r, &w, NULL) && w == r, "Writing message to output pipe\n");
 387         }
 388     }
 389
 390     if (option && strcmp(option, "exit_code") == 0)
 391     {
 392         childPrintf(hFile, "[ExitCode]\nvalue=%d\n\n", 123);
 393         CloseHandle(hFile);
 394         ExitProcess(123);
 395     }
 396
 397     CloseHandle(hFile);
 398 }
 399
 400 static char* getChildString(const char* sect, const char* key)
 401 {
 402     char        buf[1024+4*MAX_LISTED_ENV_VAR];
 403     char*       ret;
 404
 405     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), resfile);
 406     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
 407     assert(!(strlen(buf) & 1));
 408     ret = decodeA(buf);
 409     return ret;
 410 }
 411
 412 static WCHAR* getChildStringW(const char* sect, const char* key)
 413 {
 414     char        buf[1024+4*MAX_LISTED_ENV_VAR];
 415     WCHAR*       ret;
 416
 417     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), resfile);
 418     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
 419     assert(!(strlen(buf) & 1));
 420     ret = decodeW(buf);
 421     return ret;
 422 }
 423
 424 /* FIXME: this may be moved to the wtmain.c file, because it may be needed by
 425  * others... (windows uses stricmp while Un*x uses strcasecmp...)
 426  */
 427 static int wtstrcasecmp(const char* p1, const char* p2)
 428 {
 429     char c1, c2;
 430
 431     c1 = c2 = '@';
 432     while (c1 == c2 && c1)
 433     {
 434         c1 = *p1++; c2 = *p2++;
 435         if (c1 != c2)
 436         {
 437             c1 = toupper(c1); c2 = toupper(c2);
 438         }
 439     }
 440     return c1 - c2;
 441 }
 442
 443 static int strCmp(const char* s1, const char* s2, BOOL sensitive)
 444 {
 445     if (!s1 && !s2) return 0;
 446     if (!s2) return -1;
 447     if (!s1) return 1;
 448     return (sensitive) ? strcmp(s1, s2) : wtstrcasecmp(s1, s2);
 449 }
 450
 451 static void ok_child_string( int line, const char *sect, const char *key,
 452                              const char *expect, int sensitive )
 453 {
 454     char* result = getChildString( sect, key );
 455     ok_(__FILE__, line)( strCmp(result, expect, sensitive) == 0, "%s:%s expected '%s', got '%s'\n",
 456                          sect, key, expect ? expect : "(null)", result );
 457 }
 458
 459 static void ok_child_stringWA( int line, const char *sect, const char *key,
 460                              const char *expect, int sensitive )
 461 {
 462     WCHAR* expectW;
 463     CHAR* resultA;
 464     DWORD len;
 465     WCHAR* result = getChildStringW( sect, key );
 466
 467     len = MultiByteToWideChar( CP_ACP, 0, expect, -1, NULL, 0);
 468     expectW = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 469     MultiByteToWideChar( CP_ACP, 0, expect, -1, expectW, len);
 470
 471     len = WideCharToMultiByte( CP_ACP, 0, result, -1, NULL, 0, NULL, NULL);
 472     resultA = HeapAlloc(GetProcessHeap(),0,len*sizeof(CHAR));
 473     WideCharToMultiByte( CP_ACP, 0, result, -1, resultA, len, NULL, NULL);
 474
 475     if (sensitive)
 476         ok_(__FILE__, line)( lstrcmpW(result, expectW) == 0, "%s:%s expected '%s', got '%s'\n",
 477                          sect, key, expect ? expect : "(null)", resultA );
 478     else
 479         ok_(__FILE__, line)( lstrcmpiW(result, expectW) == 0, "%s:%s expected '%s', got '%s'\n",
 480                          sect, key, expect ? expect : "(null)", resultA );
 481     HeapFree(GetProcessHeap(),0,expectW);
 482     HeapFree(GetProcessHeap(),0,resultA);
 483 }
 484
 485 #define okChildString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 1 )
 486 #define okChildIString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 0 )
 487 #define okChildStringWA(sect, key, expect) ok_child_stringWA(__LINE__, (sect), (key), (expect), 1 )
 488
 489 /* using !expect ensures that the test will fail if the sect/key isn't present
 490  * in result file
 491  */
 492 #define okChildInt(sect, key, expect) \
 493     do { \
 494         UINT result = GetPrivateProfileIntA((sect), (key), !(expect), resfile); \
 495         ok(result == expect, "%s:%s expected %d, but got %d\n", (sect), (key), (int)(expect), result); \
 496    } while (0)
 497
 498 static void test_Startup(void)
 499 {
 500     char                buffer[MAX_PATH];
 501     PROCESS_INFORMATION info;
 502     STARTUPINFOA        startup,si;
 503     static CHAR title[]   = "I'm the title string",
 504                 desktop[] = "winsta0\\default",
 505                 empty[]   = "";
 506
 507     /* let's start simplistic */
 508     memset(&startup, 0, sizeof(startup));
 509     startup.cb = sizeof(startup);
 510     startup.dwFlags = STARTF_USESHOWWINDOW;
 511     startup.wShowWindow = SW_SHOWNORMAL;
 512
 513     get_file_name(resfile);
 514     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 515     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 516     /* wait for child to terminate */
 517     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 518     /* child process has changed result file, so let profile functions know about it */
 519     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 520
 521     GetStartupInfoA(&si);
 522     okChildInt("StartupInfoA", "cb", startup.cb);
 523     okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
 524     okChildInt("StartupInfoA", "dwX", startup.dwX);
 525     okChildInt("StartupInfoA", "dwY", startup.dwY);
 526     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 527     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 528     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 529     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 530     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 531     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 532     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 533     release_memory();
 534     assert(DeleteFileA(resfile) != 0);
 535
 536     /* not so simplistic now */
 537     memset(&startup, 0, sizeof(startup));
 538     startup.cb = sizeof(startup);
 539     startup.dwFlags = STARTF_USESHOWWINDOW;
 540     startup.wShowWindow = SW_SHOWNORMAL;
 541     startup.lpTitle = title;
 542     startup.lpDesktop = desktop;
 543     startup.dwXCountChars = 0x12121212;
 544     startup.dwYCountChars = 0x23232323;
 545     startup.dwX = 0x34343434;
 546     startup.dwY = 0x45454545;
 547     startup.dwXSize = 0x56565656;
 548     startup.dwYSize = 0x67676767;
 549     startup.dwFillAttribute = 0xA55A;
 550
 551     get_file_name(resfile);
 552     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 553     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 554     /* wait for child to terminate */
 555     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 556     /* child process has changed result file, so let profile functions know about it */
 557     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 558
 559     okChildInt("StartupInfoA", "cb", startup.cb);
 560     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
 561     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
 562     okChildInt("StartupInfoA", "dwX", startup.dwX);
 563     okChildInt("StartupInfoA", "dwY", startup.dwY);
 564     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 565     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 566     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 567     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 568     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 569     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 570     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 571     release_memory();
 572     assert(DeleteFileA(resfile) != 0);
 573
 574     /* not so simplistic now */
 575     memset(&startup, 0, sizeof(startup));
 576     startup.cb = sizeof(startup);
 577     startup.dwFlags = STARTF_USESHOWWINDOW;
 578     startup.wShowWindow = SW_SHOWNORMAL;
 579     startup.lpTitle = title;
 580     startup.lpDesktop = NULL;
 581     startup.dwXCountChars = 0x12121212;
 582     startup.dwYCountChars = 0x23232323;
 583     startup.dwX = 0x34343434;
 584     startup.dwY = 0x45454545;
 585     startup.dwXSize = 0x56565656;
 586     startup.dwYSize = 0x67676767;
 587     startup.dwFillAttribute = 0xA55A;
 588
 589     get_file_name(resfile);
 590     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 591     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 592     /* wait for child to terminate */
 593     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 594     /* child process has changed result file, so let profile functions know about it */
 595     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 596
 597     okChildInt("StartupInfoA", "cb", startup.cb);
 598     okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
 599     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
 600     okChildInt("StartupInfoA", "dwX", startup.dwX);
 601     okChildInt("StartupInfoA", "dwY", startup.dwY);
 602     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 603     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 604     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 605     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 606     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 607     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 608     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 609     release_memory();
 610     assert(DeleteFileA(resfile) != 0);
 611
 612     /* not so simplistic now */
 613     memset(&startup, 0, sizeof(startup));
 614     startup.cb = sizeof(startup);
 615     startup.dwFlags = STARTF_USESHOWWINDOW;
 616     startup.wShowWindow = SW_SHOWNORMAL;
 617     startup.lpTitle = title;
 618     startup.lpDesktop = empty;
 619     startup.dwXCountChars = 0x12121212;
 620     startup.dwYCountChars = 0x23232323;
 621     startup.dwX = 0x34343434;
 622     startup.dwY = 0x45454545;
 623     startup.dwXSize = 0x56565656;
 624     startup.dwYSize = 0x67676767;
 625     startup.dwFillAttribute = 0xA55A;
 626
 627     get_file_name(resfile);
 628     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 629     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 630     /* wait for child to terminate */
 631     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 632     /* child process has changed result file, so let profile functions know about it */
 633     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 634
 635     okChildInt("StartupInfoA", "cb", startup.cb);
 636     todo_wine okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
 637     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
 638     okChildInt("StartupInfoA", "dwX", startup.dwX);
 639     okChildInt("StartupInfoA", "dwY", startup.dwY);
 640     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 641     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 642     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 643     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 644     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 645     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 646     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 647     release_memory();
 648     assert(DeleteFileA(resfile) != 0);
 649
 650     /* not so simplistic now */
 651     memset(&startup, 0, sizeof(startup));
 652     startup.cb = sizeof(startup);
 653     startup.dwFlags = STARTF_USESHOWWINDOW;
 654     startup.wShowWindow = SW_SHOWNORMAL;
 655     startup.lpTitle = NULL;
 656     startup.lpDesktop = desktop;
 657     startup.dwXCountChars = 0x12121212;
 658     startup.dwYCountChars = 0x23232323;
 659     startup.dwX = 0x34343434;
 660     startup.dwY = 0x45454545;
 661     startup.dwXSize = 0x56565656;
 662     startup.dwYSize = 0x67676767;
 663     startup.dwFillAttribute = 0xA55A;
 664
 665     get_file_name(resfile);
 666     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 667     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 668     /* wait for child to terminate */
 669     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 670     /* child process has changed result file, so let profile functions know about it */
 671     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 672
 673     okChildInt("StartupInfoA", "cb", startup.cb);
 674     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
 675     ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
 676         "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
 677     okChildInt("StartupInfoA", "dwX", startup.dwX);
 678     okChildInt("StartupInfoA", "dwY", startup.dwY);
 679     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 680     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 681     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 682     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 683     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 684     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 685     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 686     release_memory();
 687     assert(DeleteFileA(resfile) != 0);
 688
 689     /* not so simplistic now */
 690     memset(&startup, 0, sizeof(startup));
 691     startup.cb = sizeof(startup);
 692     startup.dwFlags = STARTF_USESHOWWINDOW;
 693     startup.wShowWindow = SW_SHOWNORMAL;
 694     startup.lpTitle = empty;
 695     startup.lpDesktop = desktop;
 696     startup.dwXCountChars = 0x12121212;
 697     startup.dwYCountChars = 0x23232323;
 698     startup.dwX = 0x34343434;
 699     startup.dwY = 0x45454545;
 700     startup.dwXSize = 0x56565656;
 701     startup.dwYSize = 0x67676767;
 702     startup.dwFillAttribute = 0xA55A;
 703
 704     get_file_name(resfile);
 705     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 706     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 707     /* wait for child to terminate */
 708     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 709     /* child process has changed result file, so let profile functions know about it */
 710     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 711
 712     okChildInt("StartupInfoA", "cb", startup.cb);
 713     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
 714     todo_wine okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
 715     okChildInt("StartupInfoA", "dwX", startup.dwX);
 716     okChildInt("StartupInfoA", "dwY", startup.dwY);
 717     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 718     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 719     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 720     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 721     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 722     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 723     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 724     release_memory();
 725     assert(DeleteFileA(resfile) != 0);
 726
 727     /* not so simplistic now */
 728     memset(&startup, 0, sizeof(startup));
 729     startup.cb = sizeof(startup);
 730     startup.dwFlags = STARTF_USESHOWWINDOW;
 731     startup.wShowWindow = SW_SHOWNORMAL;
 732     startup.lpTitle = empty;
 733     startup.lpDesktop = empty;
 734     startup.dwXCountChars = 0x12121212;
 735     startup.dwYCountChars = 0x23232323;
 736     startup.dwX = 0x34343434;
 737     startup.dwY = 0x45454545;
 738     startup.dwXSize = 0x56565656;
 739     startup.dwYSize = 0x67676767;
 740     startup.dwFillAttribute = 0xA55A;
 741
 742     get_file_name(resfile);
 743     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 744     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 745     /* wait for child to terminate */
 746     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 747     /* child process has changed result file, so let profile functions know about it */
 748     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 749
 750     okChildInt("StartupInfoA", "cb", startup.cb);
 751     todo_wine okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
 752     todo_wine okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
 753     okChildInt("StartupInfoA", "dwX", startup.dwX);
 754     okChildInt("StartupInfoA", "dwY", startup.dwY);
 755     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
 756     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
 757     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
 758     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
 759     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
 760     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
 761     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
 762     release_memory();
 763     assert(DeleteFileA(resfile) != 0);
 764
 765     /* TODO: test for A/W and W/A and W/W */
 766 }
 767
 768 static void test_CommandLine(void)
 769 {
 770     char                buffer[MAX_PATH], fullpath[MAX_PATH], *lpFilePart, *p;
 771     char                buffer2[MAX_PATH];
 772     PROCESS_INFORMATION info;
 773     STARTUPINFOA        startup;
 774     DWORD               len;
 775     BOOL                ret;
 776
 777     memset(&startup, 0, sizeof(startup));
 778     startup.cb = sizeof(startup);
 779     startup.dwFlags = STARTF_USESHOWWINDOW;
 780     startup.wShowWindow = SW_SHOWNORMAL;
 781
 782     /* the basics */
 783     get_file_name(resfile);
 784     sprintf(buffer, "%s tests/process.c %s \"C:\\Program Files\\my nice app.exe\"", selfname, resfile);
 785     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 786     /* wait for child to terminate */
 787     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 788     /* child process has changed result file, so let profile functions know about it */
 789     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 790
 791     okChildInt("Arguments", "argcA", 4);
 792     okChildString("Arguments", "argvA3", "C:\\Program Files\\my nice app.exe");
 793     okChildString("Arguments", "argvA4", NULL);
 794     okChildString("Arguments", "CommandLineA", buffer);
 795     release_memory();
 796     assert(DeleteFileA(resfile) != 0);
 797
 798     memset(&startup, 0, sizeof(startup));
 799     startup.cb = sizeof(startup);
 800     startup.dwFlags = STARTF_USESHOWWINDOW;
 801     startup.wShowWindow = SW_SHOWNORMAL;
 802
 803     /* from Frangois */
 804     get_file_name(resfile);
 805     sprintf(buffer, "%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", selfname, resfile);
 806     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 807     /* wait for child to terminate */
 808     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 809     /* child process has changed result file, so let profile functions know about it */
 810     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 811
 812     okChildInt("Arguments", "argcA", 6);
 813     okChildString("Arguments", "argvA3", "a\"b\\");
 814     okChildString("Arguments", "argvA4", "c\"");
 815     okChildString("Arguments", "argvA5", "d");
 816     okChildString("Arguments", "argvA6", NULL);
 817     okChildString("Arguments", "CommandLineA", buffer);
 818     release_memory();
 819     assert(DeleteFileA(resfile) != 0);
 820
 821     /* Test for Bug1330 to show that XP doesn't change '/' to '\\' in argv[0]*/
 822     get_file_name(resfile);
 823     /* Use exename to avoid buffer containing things like 'C:' */
 824     sprintf(buffer, "./%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", exename, resfile);
 825     SetLastError(0xdeadbeef);
 826     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
 827     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
 828     /* wait for child to terminate */
 829     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 830     /* child process has changed result file, so let profile functions know about it */
 831     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 832     sprintf(buffer, "./%s", exename);
 833     okChildString("Arguments", "argvA0", buffer);
 834     release_memory();
 835     assert(DeleteFileA(resfile) != 0);
 836
 837     get_file_name(resfile);
 838     /* Use exename to avoid buffer containing things like 'C:' */
 839     sprintf(buffer, ".\\%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", exename, resfile);
 840     SetLastError(0xdeadbeef);
 841     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
 842     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
 843     /* wait for child to terminate */
 844     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 845     /* child process has changed result file, so let profile functions know about it */
 846     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 847     sprintf(buffer, ".\\%s", exename);
 848     okChildString("Arguments", "argvA0", buffer);
 849     release_memory();
 850     assert(DeleteFileA(resfile) != 0);
 851
 852     get_file_name(resfile);
 853     len = GetFullPathNameA(selfname, MAX_PATH, fullpath, &lpFilePart);
 854     assert ( lpFilePart != 0);
 855     *(lpFilePart -1 ) = 0;
 856     p = strrchr(fullpath, '\\');
 857     /* Use exename to avoid buffer containing things like 'C:' */
 858     if (p) sprintf(buffer, "..%s/%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", p, exename, resfile);
 859     else sprintf(buffer, "./%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", exename, resfile);
 860     SetLastError(0xdeadbeef);
 861     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
 862     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
 863     /* wait for child to terminate */
 864     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 865     /* child process has changed result file, so let profile functions know about it */
 866     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 867     if (p) sprintf(buffer, "..%s/%s", p, exename);
 868     else sprintf(buffer, "./%s", exename);
 869     okChildString("Arguments", "argvA0", buffer);
 870     release_memory();
 871     assert(DeleteFileA(resfile) != 0);
 872
 873     /* Using AppName */
 874     get_file_name(resfile);
 875     len = GetFullPathNameA(selfname, MAX_PATH, fullpath, &lpFilePart);
 876     assert ( lpFilePart != 0);
 877     *(lpFilePart -1 ) = 0;
 878     p = strrchr(fullpath, '\\');
 879     /* Use exename to avoid buffer containing things like 'C:' */
 880     if (p) sprintf(buffer, "..%s/%s", p, exename);
 881     else sprintf(buffer, "./%s", exename);
 882     sprintf(buffer2, "dummy tests/process.c %s \"a\\\"b\\\\\" c\\\" d", resfile);
 883     SetLastError(0xdeadbeef);
 884     ret = CreateProcessA(buffer, buffer2, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
 885     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
 886     /* wait for child to terminate */
 887     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 888     /* child process has changed result file, so let profile functions know about it */
 889     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 890     sprintf(buffer, "tests/process.c %s", resfile);
 891     okChildString("Arguments", "argvA0", "dummy");
 892     okChildString("Arguments", "CommandLineA", buffer2);
 893     okChildStringWA("Arguments", "CommandLineW", buffer2);
 894     release_memory();
 895     assert(DeleteFileA(resfile) != 0);
 896 }
 897
 898 static void test_Directory(void)
 899 {
 900     char                buffer[MAX_PATH];
 901     PROCESS_INFORMATION info;
 902     STARTUPINFOA        startup;
 903     char windir[MAX_PATH];
 904     static CHAR cmdline[] = "winver.exe";
 905
 906     memset(&startup, 0, sizeof(startup));
 907     startup.cb = sizeof(startup);
 908     startup.dwFlags = STARTF_USESHOWWINDOW;
 909     startup.wShowWindow = SW_SHOWNORMAL;
 910
 911     /* the basics */
 912     get_file_name(resfile);
 913     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
 914     GetWindowsDirectoryA( windir, sizeof(windir) );
 915     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, windir, &startup, &info), "CreateProcess\n");
 916     /* wait for child to terminate */
 917     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 918     /* child process has changed result file, so let profile functions know about it */
 919     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
 920
 921     okChildIString("Misc", "CurrDirA", windir);
 922     release_memory();
 923     assert(DeleteFileA(resfile) != 0);
 924
 925     /* search PATH for the exe if directory is NULL */
 926     ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 927     ok(TerminateProcess(info.hProcess, 0), "Child process termination\n");
 928
 929     /* if any directory is provided, don't search PATH, error on bad directory */
 930     SetLastError(0xdeadbeef);
 931     memset(&info, 0, sizeof(info));
 932     ok(!CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L,
 933                        NULL, "non\\existent\\directory", &startup, &info), "CreateProcess\n");
 934     ok(GetLastError() == ERROR_DIRECTORY, "Expected ERROR_DIRECTORY, got %d\n", GetLastError());
 935     ok(!TerminateProcess(info.hProcess, 0), "Child process should not exist\n");
 936 }
 937
 938 static BOOL is_str_env_drive_dir(const char* str)
 939 {
 940     return str[0] == '=' && str[1] >= 'A' && str[1] <= 'Z' && str[2] == ':' &&
 941         str[3] == '=' && str[4] == str[1];
 942 }
 943
 944 /* compared expected child's environment (in gesA) from actual
 945  * environment our child got
 946  */
 947 static void cmpEnvironment(const char* gesA)
 948 {
 949     int                 i, clen;
 950     const char*         ptrA;
 951     char*               res;
 952     char                key[32];
 953     BOOL                found;
 954
 955     clen = GetPrivateProfileIntA("EnvironmentA", "len", 0, resfile);
 956
 957     /* now look each parent env in child */
 958     if ((ptrA = gesA) != NULL)
 959     {
 960         while (*ptrA)
 961         {
 962             for (i = 0; i < clen; i++)
 963             {
 964                 sprintf(key, "env%d", i);
 965                 res = getChildString("EnvironmentA", key);
 966                 if (strncmp(ptrA, res, MAX_LISTED_ENV_VAR - 1) == 0)
 967                     break;
 968             }
 969             found = i < clen;
 970             ok(found, "Parent-env string %s isn't in child process\n", ptrA);
 971
 972             ptrA += strlen(ptrA) + 1;
 973             release_memory();
 974         }
 975     }
 976     /* and each child env in parent */
 977     for (i = 0; i < clen; i++)
 978     {
 979         sprintf(key, "env%d", i);
 980         res = getChildString("EnvironmentA", key);
 981         if ((ptrA = gesA) != NULL)
 982         {
 983             while (*ptrA)
 984             {
 985                 if (strncmp(res, ptrA, MAX_LISTED_ENV_VAR - 1) == 0)
 986                     break;
 987                 ptrA += strlen(ptrA) + 1;
 988             }
 989             if (!*ptrA) ptrA = NULL;
 990         }
 991
 992         if (!is_str_env_drive_dir(res))
 993         {
 994             found = ptrA != NULL;
 995             ok(found, "Child-env string %s isn't in parent process\n", res);
 996         }
 997         /* else => should also test we get the right per drive default directory here... */
 998     }
 999 }
1000
1001 static void test_Environment(void)
1002 {
1003     char                buffer[MAX_PATH];
1004     PROCESS_INFORMATION info;
1005     STARTUPINFOA        startup;
1006     char*               child_env;
1007     int                 child_env_len;
1008     char*               ptr;
1009     char*               env;
1010     int                 slen;
1011
1012     memset(&startup, 0, sizeof(startup));
1013     startup.cb = sizeof(startup);
1014     startup.dwFlags = STARTF_USESHOWWINDOW;
1015     startup.wShowWindow = SW_SHOWNORMAL;
1016
1017     /* the basics */
1018     get_file_name(resfile);
1019     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1020     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
1021     /* wait for child to terminate */
1022     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1023     /* child process has changed result file, so let profile functions know about it */
1024     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1025
1026     cmpEnvironment(GetEnvironmentStringsA());
1027     release_memory();
1028     assert(DeleteFileA(resfile) != 0);
1029
1030     memset(&startup, 0, sizeof(startup));
1031     startup.cb = sizeof(startup);
1032     startup.dwFlags = STARTF_USESHOWWINDOW;
1033     startup.wShowWindow = SW_SHOWNORMAL;
1034
1035     /* the basics */
1036     get_file_name(resfile);
1037     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1038
1039     child_env_len = 0;
1040     ptr = GetEnvironmentStringsA();
1041     while(*ptr)
1042     {
1043         slen = strlen(ptr)+1;
1044         child_env_len += slen;
1045         ptr += slen;
1046     }
1047     /* Add space for additional environment variables */
1048     child_env_len += 256;
1049     child_env = HeapAlloc(GetProcessHeap(), 0, child_env_len);
1050
1051     ptr = child_env;
1052     sprintf(ptr, "=%c:=%s", 'C', "C:\\FOO\\BAR");
1053     ptr += strlen(ptr) + 1;
1054     strcpy(ptr, "PATH=C:\\WINDOWS;C:\\WINDOWS\\SYSTEM;C:\\MY\\OWN\\DIR");
1055     ptr += strlen(ptr) + 1;
1056     strcpy(ptr, "FOO=BAR");
1057     ptr += strlen(ptr) + 1;
1058     strcpy(ptr, "BAR=FOOBAR");
1059     ptr += strlen(ptr) + 1;
1060     /* copy all existing variables except:
1061      * - WINELOADER
1062      * - PATH (already set above)
1063      * - the directory definitions (=[A-Z]:=)
1064      */
1065     for (env = GetEnvironmentStringsA(); *env; env += strlen(env) + 1)
1066     {
1067         if (strncmp(env, "PATH=", 5) != 0 &&
1068             strncmp(env, "WINELOADER=", 11) != 0 &&
1069             !is_str_env_drive_dir(env))
1070         {
1071             strcpy(ptr, env);
1072             ptr += strlen(ptr) + 1;
1073         }
1074     }
1075     *ptr = '\0';
1076     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, child_env, NULL, &startup, &info), "CreateProcess\n");
1077     /* wait for child to terminate */
1078     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1079     /* child process has changed result file, so let profile functions know about it */
1080     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1081
1082     cmpEnvironment(child_env);
1083
1084     HeapFree(GetProcessHeap(), 0, child_env);
1085     release_memory();
1086     assert(DeleteFileA(resfile) != 0);
1087 }
1088
1089 static  void    test_SuspendFlag(void)
1090 {
1091     char                buffer[MAX_PATH];
1092     PROCESS_INFORMATION info;
1093     STARTUPINFOA       startup, us;
1094     DWORD               exit_status;
1095
1096     /* let's start simplistic */
1097     memset(&startup, 0, sizeof(startup));
1098     startup.cb = sizeof(startup);
1099     startup.dwFlags = STARTF_USESHOWWINDOW;
1100     startup.wShowWindow = SW_SHOWNORMAL;
1101
1102     get_file_name(resfile);
1103     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1104     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &startup, &info), "CreateProcess\n");
1105
1106     ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1107     Sleep(8000);
1108     ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1109     ok(ResumeThread(info.hThread) == 1, "Resuming thread\n");
1110
1111     /* wait for child to terminate */
1112     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1113     /* child process has changed result file, so let profile functions know about it */
1114     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1115
1116     GetStartupInfoA(&us);
1117
1118     okChildInt("StartupInfoA", "cb", startup.cb);
1119     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1120     ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1121         "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1122     okChildInt("StartupInfoA", "dwX", startup.dwX);
1123     okChildInt("StartupInfoA", "dwY", startup.dwY);
1124     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1125     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1126     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1127     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1128     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1129     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1130     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1131     release_memory();
1132     assert(DeleteFileA(resfile) != 0);
1133 }
1134
1135 static  void    test_DebuggingFlag(void)
1136 {
1137     char                buffer[MAX_PATH];
1138     PROCESS_INFORMATION info;
1139     STARTUPINFOA       startup, us;
1140     DEBUG_EVENT         de;
1141     unsigned            dbg = 0;
1142
1143     /* let's start simplistic */
1144     memset(&startup, 0, sizeof(startup));
1145     startup.cb = sizeof(startup);
1146     startup.dwFlags = STARTF_USESHOWWINDOW;
1147     startup.wShowWindow = SW_SHOWNORMAL;
1148
1149     get_file_name(resfile);
1150     sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1151     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1152
1153     /* get all startup events up to the entry point break exception */
1154     do
1155     {
1156         ok(WaitForDebugEvent(&de, INFINITE), "reading debug event\n");
1157         ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
1158         if (de.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) dbg++;
1159     } while (de.dwDebugEventCode != EXIT_PROCESS_DEBUG_EVENT);
1160
1161     ok(dbg, "I have seen a debug event\n");
1162     /* wait for child to terminate */
1163     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1164     /* child process has changed result file, so let profile functions know about it */
1165     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1166
1167     GetStartupInfoA(&us);
1168
1169     okChildInt("StartupInfoA", "cb", startup.cb);
1170     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1171     ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1172         "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1173     okChildInt("StartupInfoA", "dwX", startup.dwX);
1174     okChildInt("StartupInfoA", "dwY", startup.dwY);
1175     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1176     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1177     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1178     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1179     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1180     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1181     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1182     release_memory();
1183     assert(DeleteFileA(resfile) != 0);
1184 }
1185
1186 static BOOL is_console(HANDLE h)
1187 {
1188     return h != INVALID_HANDLE_VALUE && ((ULONG_PTR)h & 3) == 3;
1189 }
1190
1191 static void test_Console(void)
1192 {
1193     char                buffer[MAX_PATH];
1194     PROCESS_INFORMATION info;
1195     STARTUPINFOA       startup, us;
1196     SECURITY_ATTRIBUTES sa;
1197     CONSOLE_SCREEN_BUFFER_INFO  sbi, sbiC;
1198     DWORD               modeIn, modeOut, modeInC, modeOutC;
1199     DWORD               cpIn, cpOut, cpInC, cpOutC;
1200     DWORD               w;
1201     HANDLE              hChildIn, hChildInInh, hChildOut, hChildOutInh, hParentIn, hParentOut;
1202     const char*         msg = "This is a std-handle inheritance test.";
1203     unsigned            msg_len;
1204     BOOL                run_tests = TRUE;
1205
1206     memset(&startup, 0, sizeof(startup));
1207     startup.cb = sizeof(startup);
1208     startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1209     startup.wShowWindow = SW_SHOWNORMAL;
1210
1211     sa.nLength = sizeof(sa);
1212     sa.lpSecurityDescriptor = NULL;
1213     sa.bInheritHandle = TRUE;
1214
1215     startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1216     startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1217
1218     /* first, we need to be sure we're attached to a console */
1219     if (!is_console(startup.hStdInput) || !is_console(startup.hStdOutput))
1220     {
1221         /* we're not attached to a console, let's do it */
1222         AllocConsole();
1223         startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1224         startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1225     }
1226     /* now verify everything's ok */
1227     ok(startup.hStdInput != INVALID_HANDLE_VALUE, "Opening ConIn\n");
1228     ok(startup.hStdOutput != INVALID_HANDLE_VALUE, "Opening ConOut\n");
1229     startup.hStdError = startup.hStdOutput;
1230
1231     ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbi), "Getting sb info\n");
1232     ok(GetConsoleMode(startup.hStdInput, &modeIn) &&
1233        GetConsoleMode(startup.hStdOutput, &modeOut), "Getting console modes\n");
1234     cpIn = GetConsoleCP();
1235     cpOut = GetConsoleOutputCP();
1236
1237     get_file_name(resfile);
1238     sprintf(buffer, "%s tests/process.c %s console", selfname, resfile);
1239     ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1240
1241     /* wait for child to terminate */
1242     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1243     /* child process has changed result file, so let profile functions know about it */
1244     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1245
1246     /* now get the modification the child has made, and resets parents expected values */
1247     ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbiC), "Getting sb info\n");
1248     ok(GetConsoleMode(startup.hStdInput, &modeInC) &&
1249        GetConsoleMode(startup.hStdOutput, &modeOutC), "Getting console modes\n");
1250
1251     SetConsoleMode(startup.hStdInput, modeIn);
1252     SetConsoleMode(startup.hStdOutput, modeOut);
1253
1254     cpInC = GetConsoleCP();
1255     cpOutC = GetConsoleOutputCP();
1256
1257     /* Try to set invalid CP */
1258     SetLastError(0xdeadbeef);
1259     ok(!SetConsoleCP(0), "Shouldn't succeed\n");
1260     ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1261        broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1262        "GetLastError: expecting %u got %u\n",
1263        ERROR_INVALID_PARAMETER, GetLastError());
1264     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1265         run_tests = FALSE;
1266
1267
1268     SetLastError(0xdeadbeef);
1269     ok(!SetConsoleOutputCP(0), "Shouldn't succeed\n");
1270     ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1271        broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1272        "GetLastError: expecting %u got %u\n",
1273        ERROR_INVALID_PARAMETER, GetLastError());
1274
1275     SetConsoleCP(cpIn);
1276     SetConsoleOutputCP(cpOut);
1277
1278     GetStartupInfoA(&us);
1279
1280     okChildInt("StartupInfoA", "cb", startup.cb);
1281     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1282     ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1283         "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1284     okChildInt("StartupInfoA", "dwX", startup.dwX);
1285     okChildInt("StartupInfoA", "dwY", startup.dwY);
1286     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1287     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1288     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1289     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1290     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1291     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1292     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1293
1294     /* check child correctly inherited the console */
1295     okChildInt("StartupInfoA", "hStdInput", (DWORD)startup.hStdInput);
1296     okChildInt("StartupInfoA", "hStdOutput", (DWORD)startup.hStdOutput);
1297     okChildInt("StartupInfoA", "hStdError", (DWORD)startup.hStdError);
1298     okChildInt("Console", "SizeX", (DWORD)sbi.dwSize.X);
1299     okChildInt("Console", "SizeY", (DWORD)sbi.dwSize.Y);
1300     okChildInt("Console", "CursorX", (DWORD)sbi.dwCursorPosition.X);
1301     okChildInt("Console", "CursorY", (DWORD)sbi.dwCursorPosition.Y);
1302     okChildInt("Console", "Attributes", sbi.wAttributes);
1303     okChildInt("Console", "winLeft", (DWORD)sbi.srWindow.Left);
1304     okChildInt("Console", "winTop", (DWORD)sbi.srWindow.Top);
1305     okChildInt("Console", "winRight", (DWORD)sbi.srWindow.Right);
1306     okChildInt("Console", "winBottom", (DWORD)sbi.srWindow.Bottom);
1307     okChildInt("Console", "maxWinWidth", (DWORD)sbi.dwMaximumWindowSize.X);
1308     okChildInt("Console", "maxWinHeight", (DWORD)sbi.dwMaximumWindowSize.Y);
1309     okChildInt("Console", "InputCP", cpIn);
1310     okChildInt("Console", "OutputCP", cpOut);
1311     okChildInt("Console", "InputMode", modeIn);
1312     okChildInt("Console", "OutputMode", modeOut);
1313
1314     if (run_tests)
1315     {
1316         ok(cpInC == 1252, "Wrong console CP (expected 1252 got %d/%d)\n", cpInC, cpIn);
1317         ok(cpOutC == 1252, "Wrong console-SB CP (expected 1252 got %d/%d)\n", cpOutC, cpOut);
1318     }
1319     else
1320         win_skip("Setting the codepage is not implemented\n");
1321
1322     ok(modeInC == (modeIn ^ 1), "Wrong console mode\n");
1323     ok(modeOutC == (modeOut ^ 1), "Wrong console-SB mode\n");
1324     trace("cursor position(X): %d/%d\n",sbi.dwCursorPosition.X, sbiC.dwCursorPosition.X);
1325     ok(sbiC.dwCursorPosition.Y == (sbi.dwCursorPosition.Y ^ 1), "Wrong cursor position\n");
1326
1327     release_memory();
1328     assert(DeleteFileA(resfile) != 0);
1329
1330     ok(CreatePipe(&hParentIn, &hChildOut, NULL, 0), "Creating parent-input pipe\n");
1331     ok(DuplicateHandle(GetCurrentProcess(), hChildOut, GetCurrentProcess(),
1332                        &hChildOutInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1333        "Duplicating as inheritable child-output pipe\n");
1334     CloseHandle(hChildOut);
1335
1336     ok(CreatePipe(&hChildIn, &hParentOut, NULL, 0), "Creating parent-output pipe\n");
1337     ok(DuplicateHandle(GetCurrentProcess(), hChildIn, GetCurrentProcess(),
1338                        &hChildInInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1339        "Duplicating as inheritable child-input pipe\n");
1340     CloseHandle(hChildIn);
1341
1342     memset(&startup, 0, sizeof(startup));
1343     startup.cb = sizeof(startup);
1344     startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1345     startup.wShowWindow = SW_SHOWNORMAL;
1346     startup.hStdInput = hChildInInh;
1347     startup.hStdOutput = hChildOutInh;
1348     startup.hStdError = hChildOutInh;
1349
1350     get_file_name(resfile);
1351     sprintf(buffer, "%s tests/process.c %s stdhandle", selfname, resfile);
1352     ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1353     ok(CloseHandle(hChildInInh), "Closing handle\n");
1354     ok(CloseHandle(hChildOutInh), "Closing handle\n");
1355
1356     msg_len = strlen(msg) + 1;
1357     ok(WriteFile(hParentOut, msg, msg_len, &w, NULL), "Writing to child\n");
1358     ok(w == msg_len, "Should have written %u bytes, actually wrote %u\n", msg_len, w);
1359     memset(buffer, 0, sizeof(buffer));
1360     ok(ReadFile(hParentIn, buffer, sizeof(buffer), &w, NULL), "Reading from child\n");
1361     ok(strcmp(buffer, msg) == 0, "Should have received '%s'\n", msg);
1362
1363     /* wait for child to terminate */
1364     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1365     /* child process has changed result file, so let profile functions know about it */
1366     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1367
1368     okChildString("StdHandle", "msg", msg);
1369
1370     release_memory();
1371     assert(DeleteFileA(resfile) != 0);
1372 }
1373
1374 static  void    test_ExitCode(void)
1375 {
1376     char                buffer[MAX_PATH];
1377     PROCESS_INFORMATION info;
1378     STARTUPINFOA        startup;
1379     DWORD               code;
1380
1381     /* let's start simplistic */
1382     memset(&startup, 0, sizeof(startup));
1383     startup.cb = sizeof(startup);
1384     startup.dwFlags = STARTF_USESHOWWINDOW;
1385     startup.wShowWindow = SW_SHOWNORMAL;
1386
1387     get_file_name(resfile);
1388     sprintf(buffer, "%s tests/process.c %s exit_code", selfname, resfile);
1389     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1390
1391     /* wait for child to terminate */
1392     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1393     /* child process has changed result file, so let profile functions know about it */
1394     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1395
1396     ok(GetExitCodeProcess(info.hProcess, &code), "Getting exit code\n");
1397     okChildInt("ExitCode", "value", code);
1398
1399     release_memory();
1400     assert(DeleteFileA(resfile) != 0);
1401 }
1402
1403 static void test_OpenProcess(void)
1404 {
1405     HANDLE hproc;
1406     void *addr1;
1407     MEMORY_BASIC_INFORMATION info;
1408     SIZE_T dummy, read_bytes;
1409
1410     /* not exported in all windows versions */
1411     if ((!pVirtualAllocEx) || (!pVirtualFreeEx)) {
1412         skip("VirtualAllocEx not found\n");
1413         return;
1414     }
1415
1416     /* without PROCESS_VM_OPERATION */
1417     hproc = OpenProcess(PROCESS_ALL_ACCESS & ~PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1418     ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1419
1420     SetLastError(0xdeadbeef);
1421     addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1422     ok(!addr1, "VirtualAllocEx should fail\n");
1423     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1424     {   /* Win9x */
1425         CloseHandle(hproc);
1426         skip("VirtualAllocEx not implemented\n");
1427         return;
1428     }
1429     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1430
1431     read_bytes = 0xdeadbeef;
1432     SetLastError(0xdeadbeef);
1433     ok(ReadProcessMemory(hproc, test_OpenProcess, &dummy, sizeof(dummy), &read_bytes),
1434        "ReadProcessMemory error %d\n", GetLastError());
1435     ok(read_bytes == sizeof(dummy), "wrong read bytes %ld\n", read_bytes);
1436
1437     CloseHandle(hproc);
1438
1439     hproc = OpenProcess(PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1440     ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1441
1442     addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1443     ok(addr1 != NULL, "VirtualAllocEx error %d\n", GetLastError());
1444
1445     /* without PROCESS_QUERY_INFORMATION */
1446     SetLastError(0xdeadbeef);
1447     ok(!VirtualQueryEx(hproc, addr1, &info, sizeof(info)),
1448        "VirtualQueryEx without PROCESS_QUERY_INFORMATION rights should fail\n");
1449     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1450
1451     /* without PROCESS_VM_READ */
1452     read_bytes = 0xdeadbeef;
1453     SetLastError(0xdeadbeef);
1454     ok(!ReadProcessMemory(hproc, addr1, &dummy, sizeof(dummy), &read_bytes),
1455        "ReadProcessMemory without PROCESS_VM_READ rights should fail\n");
1456     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1457     ok(read_bytes == 0, "wrong read bytes %ld\n", read_bytes);
1458
1459     CloseHandle(hproc);
1460
1461     hproc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1462
1463     memset(&info, 0xcc, sizeof(info));
1464     ok(VirtualQueryEx(hproc, addr1, &info, sizeof(info)) == sizeof(info),
1465        "VirtualQueryEx error %d\n", GetLastError());
1466
1467     ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
1468     ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
1469     ok(info.AllocationProtect == PAGE_NOACCESS, "%x != PAGE_NOACCESS\n", info.AllocationProtect);
1470     ok(info.RegionSize == 0x10000, "%lx != 0x10000\n", info.RegionSize);
1471     ok(info.State == MEM_RESERVE, "%x != MEM_RESERVE\n", info.State);
1472     /* NT reports Protect == 0 for a not committed memory block */
1473     ok(info.Protect == 0 /* NT */ ||
1474        info.Protect == PAGE_NOACCESS, /* Win9x */
1475         "%x != PAGE_NOACCESS\n", info.Protect);
1476     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
1477
1478     SetLastError(0xdeadbeef);
1479     ok(!pVirtualFreeEx(hproc, addr1, 0, MEM_RELEASE),
1480        "VirtualFreeEx without PROCESS_VM_OPERATION rights should fail\n");
1481     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1482
1483     CloseHandle(hproc);
1484
1485     ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
1486 }
1487
1488 static void test_GetProcessVersion(void)
1489 {
1490     static char cmdline[] = "winver.exe";
1491     PROCESS_INFORMATION pi;
1492     STARTUPINFOA si;
1493     DWORD ret;
1494
1495     SetLastError(0xdeadbeef);
1496     ret = GetProcessVersion(0);
1497     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1498
1499     SetLastError(0xdeadbeef);
1500     ret = GetProcessVersion(GetCurrentProcessId());
1501     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1502
1503     memset(&si, 0, sizeof(si));
1504     si.cb = sizeof(si);
1505     si.dwFlags = STARTF_USESHOWWINDOW;
1506     si.wShowWindow = SW_HIDE;
1507     ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
1508     SetLastError(0xdeadbeef);
1509     ok(ret, "CreateProcess error %u\n", GetLastError());
1510
1511     SetLastError(0xdeadbeef);
1512     ret = GetProcessVersion(pi.dwProcessId);
1513     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1514
1515     SetLastError(0xdeadbeef);
1516     ret = TerminateProcess(pi.hProcess, 0);
1517     ok(ret, "TerminateProcess error %u\n", GetLastError());
1518
1519     CloseHandle(pi.hProcess);
1520     CloseHandle(pi.hThread);
1521 }
1522
1523 START_TEST(process)
1524 {
1525     int b = init();
1526     ok(b, "Basic init of CreateProcess test\n");
1527     if (!b) return;
1528
1529     if (myARGC >= 3)
1530     {
1531         doChild(myARGV[2], (myARGC == 3) ? NULL : myARGV[3]);
1532         return;
1533     }
1534     test_Startup();
1535     test_CommandLine();
1536     test_Directory();
1537     test_Environment();
1538     test_SuspendFlag();
1539     test_DebuggingFlag();
1540     test_Console();
1541     test_ExitCode();
1542     test_OpenProcess();
1543     test_GetProcessVersion();
1544     /* things that can be tested:
1545      *  lookup:         check the way program to be executed is searched
1546      *  handles:        check the handle inheritance stuff (+sec options)
1547      *  console:        check if console creation parameters work
1548      */
1549 }