Assorted spelling fixes and wording tweaks.
[wine] / dlls / kernel32 / tests / process.c
1 /*
2  * Unit test suite for process functions
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 #define expect_eq_d(expected, actual) \
39     do { \
40       int value = (actual); \
41       ok((expected) == value, "Expected " #actual " to be %d (" #expected ") is %d\n", \
42           (expected), value); \
43     } while (0)
44 #define expect_eq_s(expected, actual) \
45     do { \
46       LPCSTR value = (actual); \
47       ok(lstrcmpA((expected), value) == 0, "Expected " #actual " to be L\"%s\" (" #expected ") is L\"%s\"\n", \
48           expected, value); \
49     } while (0)
50 #define expect_eq_ws_i(expected, actual) \
51     do { \
52       LPCWSTR value = (actual); \
53       ok(lstrcmpiW((expected), value) == 0, "Expected " #actual " to be L\"%s\" (" #expected ") is L\"%s\"\n", \
54           wine_dbgstr_w(expected), wine_dbgstr_w(value)); \
55     } while (0)
56
57 static HINSTANCE hkernel32;
58 static void   (WINAPI *pGetNativeSystemInfo)(LPSYSTEM_INFO);
59 static BOOL   (WINAPI *pGetSystemRegistryQuota)(PDWORD, PDWORD);
60 static BOOL   (WINAPI *pIsWow64Process)(HANDLE,PBOOL);
61 static LPVOID (WINAPI *pVirtualAllocEx)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD);
62 static BOOL   (WINAPI *pVirtualFreeEx)(HANDLE, LPVOID, SIZE_T, DWORD);
63 static BOOL   (WINAPI *pQueryFullProcessImageNameA)(HANDLE hProcess, DWORD dwFlags, LPSTR lpExeName, PDWORD lpdwSize);
64 static BOOL   (WINAPI *pQueryFullProcessImageNameW)(HANDLE hProcess, DWORD dwFlags, LPWSTR lpExeName, PDWORD lpdwSize);
65 static DWORD  (WINAPI *pK32GetProcessImageFileNameA)(HANDLE,LPSTR,DWORD);
66
67 /* ############################### */
68 static char     base[MAX_PATH];
69 static char     selfname[MAX_PATH];
70 static char*    exename;
71 static char     resfile[MAX_PATH];
72
73 static int      myARGC;
74 static char**   myARGV;
75
76 /* As some environment variables get very long on Unix, we only test for
77  * the first 127 bytes.
78  * Note that increasing this value past 256 may exceed the buffer size
79  * limitations of the *Profile functions (at least on Wine).
80  */
81 #define MAX_LISTED_ENV_VAR      128
82
83 /* ---------------- portable memory allocation thingie */
84
85 static char     memory[1024*256];
86 static char*    memory_index = memory;
87
88 static char*    grab_memory(size_t len)
89 {
90     char*       ret = memory_index;
91     /* align on dword */
92     len = (len + 3) & ~3;
93     memory_index += len;
94     assert(memory_index <= memory + sizeof(memory));
95     return ret;
96 }
97
98 static void     release_memory(void)
99 {
100     memory_index = memory;
101 }
102
103 /* ---------------- simplistic tool to encode/decode strings (to hide \ " ' and such) */
104
105 static const char* encodeA(const char* str)
106 {
107     char*       ptr;
108     size_t      len,i;
109
110     if (!str) return "";
111     len = strlen(str) + 1;
112     ptr = grab_memory(len * 2 + 1);
113     for (i = 0; i < len; i++)
114         sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]);
115     ptr[2 * len] = '\0';
116     return ptr;
117 }
118
119 static const char* encodeW(const WCHAR* str)
120 {
121     char*       ptr;
122     size_t      len,i;
123
124     if (!str) return "";
125     len = lstrlenW(str) + 1;
126     ptr = grab_memory(len * 4 + 1);
127     assert(ptr);
128     for (i = 0; i < len; i++)
129         sprintf(&ptr[i * 4], "%04x", (unsigned int)(unsigned short)str[i]);
130     ptr[4 * len] = '\0';
131     return ptr;
132 }
133
134 static unsigned decode_char(char c)
135 {
136     if (c >= '0' && c <= '9') return c - '0';
137     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
138     assert(c >= 'A' && c <= 'F');
139     return c - 'A' + 10;
140 }
141
142 static char*    decodeA(const char* str)
143 {
144     char*       ptr;
145     size_t      len,i;
146
147     len = strlen(str) / 2;
148     if (!len--) return NULL;
149     ptr = grab_memory(len + 1);
150     for (i = 0; i < len; i++)
151         ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]);
152     ptr[len] = '\0';
153     return ptr;
154 }
155
156 /* This will be needed to decode Unicode strings saved by the child process
157  * when we test Unicode functions.
158  */
159 static WCHAR*   decodeW(const char* str)
160 {
161     size_t      len;
162     WCHAR*      ptr;
163     int         i;
164
165     len = strlen(str) / 4;
166     if (!len--) return NULL;
167     ptr = (WCHAR*)grab_memory(len * 2 + 1);
168     for (i = 0; i < len; i++)
169         ptr[i] = (decode_char(str[4 * i]) << 12) |
170             (decode_char(str[4 * i + 1]) << 8) |
171             (decode_char(str[4 * i + 2]) << 4) |
172             (decode_char(str[4 * i + 3]) << 0);
173     ptr[len] = '\0';
174     return ptr;
175 }
176
177 /******************************************************************
178  *              init
179  *
180  * generates basic information like:
181  *      base:           absolute path to curr dir
182  *      selfname:       the way to reinvoke ourselves
183  *      exename:        executable without the path
184  * function-pointers, which are not implemented in all windows versions
185  */
186 static int     init(void)
187 {
188     char *p;
189
190     myARGC = winetest_get_mainargs( &myARGV );
191     if (!GetCurrentDirectoryA(sizeof(base), base)) return 0;
192     strcpy(selfname, myARGV[0]);
193
194     /* Strip the path of selfname */
195     if ((p = strrchr(selfname, '\\')) != NULL) exename = p + 1;
196     else exename = selfname;
197
198     if ((p = strrchr(exename, '/')) != NULL) exename = p + 1;
199
200     hkernel32 = GetModuleHandleA("kernel32");
201     pGetNativeSystemInfo = (void *) GetProcAddress(hkernel32, "GetNativeSystemInfo");
202     pGetSystemRegistryQuota = (void *) GetProcAddress(hkernel32, "GetSystemRegistryQuota");
203     pIsWow64Process = (void *) GetProcAddress(hkernel32, "IsWow64Process");
204     pVirtualAllocEx = (void *) GetProcAddress(hkernel32, "VirtualAllocEx");
205     pVirtualFreeEx = (void *) GetProcAddress(hkernel32, "VirtualFreeEx");
206     pQueryFullProcessImageNameA = (void *) GetProcAddress(hkernel32, "QueryFullProcessImageNameA");
207     pQueryFullProcessImageNameW = (void *) GetProcAddress(hkernel32, "QueryFullProcessImageNameW");
208     pK32GetProcessImageFileNameA = (void *) GetProcAddress(hkernel32, "K32GetProcessImageFileNameA");
209     return 1;
210 }
211
212 /******************************************************************
213  *              get_file_name
214  *
215  * generates an absolute file_name for temporary file
216  *
217  */
218 static void     get_file_name(char* buf)
219 {
220     char        path[MAX_PATH];
221
222     buf[0] = '\0';
223     GetTempPathA(sizeof(path), path);
224     GetTempFileNameA(path, "wt", 0, buf);
225 }
226
227 /******************************************************************
228  *              static void     childPrintf
229  *
230  */
231 static void     childPrintf(HANDLE h, const char* fmt, ...)
232 {
233     va_list     valist;
234     char        buffer[1024+4*MAX_LISTED_ENV_VAR];
235     DWORD       w;
236
237     va_start(valist, fmt);
238     vsprintf(buffer, fmt, valist);
239     va_end(valist);
240     WriteFile(h, buffer, strlen(buffer), &w, NULL);
241 }
242
243
244 /******************************************************************
245  *              doChild
246  *
247  * output most of the information in the child process
248  */
249 static void     doChild(const char* file, const char* option)
250 {
251     STARTUPINFOA        siA;
252     STARTUPINFOW        siW;
253     int                 i;
254     char                *ptrA, *ptrA_save;
255     WCHAR               *ptrW, *ptrW_save;
256     char                bufA[MAX_PATH];
257     WCHAR               bufW[MAX_PATH];
258     HANDLE              hFile = CreateFileA(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
259     BOOL ret;
260
261     if (hFile == INVALID_HANDLE_VALUE) return;
262
263     /* output of startup info (Ansi) */
264     GetStartupInfoA(&siA);
265     childPrintf(hFile,
266                 "[StartupInfoA]\ncb=%08ld\nlpDesktop=%s\nlpTitle=%s\n"
267                 "dwX=%lu\ndwY=%lu\ndwXSize=%lu\ndwYSize=%lu\n"
268                 "dwXCountChars=%lu\ndwYCountChars=%lu\ndwFillAttribute=%lu\n"
269                 "dwFlags=%lu\nwShowWindow=%u\n"
270                 "hStdInput=%lu\nhStdOutput=%lu\nhStdError=%lu\n\n",
271                 siA.cb, encodeA(siA.lpDesktop), encodeA(siA.lpTitle),
272                 siA.dwX, siA.dwY, siA.dwXSize, siA.dwYSize,
273                 siA.dwXCountChars, siA.dwYCountChars, siA.dwFillAttribute,
274                 siA.dwFlags, siA.wShowWindow,
275                 (DWORD_PTR)siA.hStdInput, (DWORD_PTR)siA.hStdOutput, (DWORD_PTR)siA.hStdError);
276
277     /* since GetStartupInfoW is only implemented in win2k,
278      * zero out before calling so we can notice the difference
279      */
280     memset(&siW, 0, sizeof(siW));
281     GetStartupInfoW(&siW);
282     childPrintf(hFile,
283                 "[StartupInfoW]\ncb=%08ld\nlpDesktop=%s\nlpTitle=%s\n"
284                 "dwX=%lu\ndwY=%lu\ndwXSize=%lu\ndwYSize=%lu\n"
285                 "dwXCountChars=%lu\ndwYCountChars=%lu\ndwFillAttribute=%lu\n"
286                 "dwFlags=%lu\nwShowWindow=%u\n"
287                 "hStdInput=%lu\nhStdOutput=%lu\nhStdError=%lu\n\n",
288                 siW.cb, encodeW(siW.lpDesktop), encodeW(siW.lpTitle),
289                 siW.dwX, siW.dwY, siW.dwXSize, siW.dwYSize,
290                 siW.dwXCountChars, siW.dwYCountChars, siW.dwFillAttribute,
291                 siW.dwFlags, siW.wShowWindow,
292                 (DWORD_PTR)siW.hStdInput, (DWORD_PTR)siW.hStdOutput, (DWORD_PTR)siW.hStdError);
293
294     /* Arguments */
295     childPrintf(hFile, "[Arguments]\nargcA=%d\n", myARGC);
296     for (i = 0; i < myARGC; i++)
297     {
298         childPrintf(hFile, "argvA%d=%s\n", i, encodeA(myARGV[i]));
299     }
300     childPrintf(hFile, "CommandLineA=%s\n", encodeA(GetCommandLineA()));
301
302 #if 0
303     int                 argcW;
304     WCHAR**             argvW;
305
306     /* this is part of shell32... and should be tested there */
307     argvW = CommandLineToArgvW(GetCommandLineW(), &argcW);
308     for (i = 0; i < argcW; i++)
309     {
310         childPrintf(hFile, "argvW%d=%s\n", i, encodeW(argvW[i]));
311     }
312 #endif
313     childPrintf(hFile, "CommandLineW=%s\n\n", encodeW(GetCommandLineW()));
314
315     /* output of environment (Ansi) */
316     ptrA_save = ptrA = GetEnvironmentStringsA();
317     if (ptrA)
318     {
319         char    env_var[MAX_LISTED_ENV_VAR];
320
321         childPrintf(hFile, "[EnvironmentA]\n");
322         i = 0;
323         while (*ptrA)
324         {
325             lstrcpynA(env_var, ptrA, MAX_LISTED_ENV_VAR);
326             childPrintf(hFile, "env%d=%s\n", i, encodeA(env_var));
327             i++;
328             ptrA += strlen(ptrA) + 1;
329         }
330         childPrintf(hFile, "len=%d\n\n", i);
331         FreeEnvironmentStringsA(ptrA_save);
332     }
333
334     /* output of environment (Unicode) */
335     ptrW_save = ptrW = GetEnvironmentStringsW();
336     if (ptrW)
337     {
338         WCHAR   env_var[MAX_LISTED_ENV_VAR];
339
340         childPrintf(hFile, "[EnvironmentW]\n");
341         i = 0;
342         while (*ptrW)
343         {
344             lstrcpynW(env_var, ptrW, MAX_LISTED_ENV_VAR - 1);
345             env_var[MAX_LISTED_ENV_VAR - 1] = '\0';
346             childPrintf(hFile, "env%d=%s\n", i, encodeW(env_var));
347             i++;
348             ptrW += lstrlenW(ptrW) + 1;
349         }
350         childPrintf(hFile, "len=%d\n\n", i);
351         FreeEnvironmentStringsW(ptrW_save);
352     }
353
354     childPrintf(hFile, "[Misc]\n");
355     if (GetCurrentDirectoryA(sizeof(bufA), bufA))
356         childPrintf(hFile, "CurrDirA=%s\n", encodeA(bufA));
357     if (GetCurrentDirectoryW(sizeof(bufW) / sizeof(bufW[0]), bufW))
358         childPrintf(hFile, "CurrDirW=%s\n", encodeW(bufW));
359     childPrintf(hFile, "\n");
360
361     if (option && strcmp(option, "console") == 0)
362     {
363         CONSOLE_SCREEN_BUFFER_INFO      sbi;
364         HANDLE hConIn  = GetStdHandle(STD_INPUT_HANDLE);
365         HANDLE hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
366         DWORD modeIn, modeOut;
367
368         childPrintf(hFile, "[Console]\n");
369         if (GetConsoleScreenBufferInfo(hConOut, &sbi))
370         {
371             childPrintf(hFile, "SizeX=%d\nSizeY=%d\nCursorX=%d\nCursorY=%d\nAttributes=%d\n",
372                         sbi.dwSize.X, sbi.dwSize.Y, sbi.dwCursorPosition.X, sbi.dwCursorPosition.Y, sbi.wAttributes);
373             childPrintf(hFile, "winLeft=%d\nwinTop=%d\nwinRight=%d\nwinBottom=%d\n",
374                         sbi.srWindow.Left, sbi.srWindow.Top, sbi.srWindow.Right, sbi.srWindow.Bottom);
375             childPrintf(hFile, "maxWinWidth=%d\nmaxWinHeight=%d\n",
376                         sbi.dwMaximumWindowSize.X, sbi.dwMaximumWindowSize.Y);
377         }
378         childPrintf(hFile, "InputCP=%d\nOutputCP=%d\n",
379                     GetConsoleCP(), GetConsoleOutputCP());
380         if (GetConsoleMode(hConIn, &modeIn))
381             childPrintf(hFile, "InputMode=%ld\n", modeIn);
382         if (GetConsoleMode(hConOut, &modeOut))
383             childPrintf(hFile, "OutputMode=%ld\n", modeOut);
384
385         /* now that we have written all relevant information, let's change it */
386         SetLastError(0xdeadbeef);
387         ret = SetConsoleCP(1252);
388         if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
389         {
390             win_skip("Setting the codepage is not implemented\n");
391         }
392         else
393         {
394             ok(ret, "Setting CP\n");
395             ok(SetConsoleOutputCP(1252), "Setting SB CP\n");
396         }
397
398         ret = SetConsoleMode(hConIn, modeIn ^ 1);
399         ok( ret, "Setting mode (%d)\n", GetLastError());
400         ret = SetConsoleMode(hConOut, modeOut ^ 1);
401         ok( ret, "Setting mode (%d)\n", GetLastError());
402         sbi.dwCursorPosition.X ^= 1;
403         sbi.dwCursorPosition.Y ^= 1;
404         ret = SetConsoleCursorPosition(hConOut, sbi.dwCursorPosition);
405         ok( ret, "Setting cursor position (%d)\n", GetLastError());
406     }
407     if (option && strcmp(option, "stdhandle") == 0)
408     {
409         HANDLE hStdIn  = GetStdHandle(STD_INPUT_HANDLE);
410         HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
411
412         if (hStdIn != INVALID_HANDLE_VALUE || hStdOut != INVALID_HANDLE_VALUE)
413         {
414             char buf[1024];
415             DWORD r, w;
416
417             ok(ReadFile(hStdIn, buf, sizeof(buf), &r, NULL) && r > 0, "Reading message from input pipe\n");
418             childPrintf(hFile, "[StdHandle]\nmsg=%s\n\n", encodeA(buf));
419             ok(WriteFile(hStdOut, buf, r, &w, NULL) && w == r, "Writing message to output pipe\n");
420         }
421     }
422
423     if (option && strcmp(option, "exit_code") == 0)
424     {
425         childPrintf(hFile, "[ExitCode]\nvalue=%d\n\n", 123);
426         CloseHandle(hFile);
427         ExitProcess(123);
428     }
429
430     CloseHandle(hFile);
431 }
432
433 static char* getChildString(const char* sect, const char* key)
434 {
435     char        buf[1024+4*MAX_LISTED_ENV_VAR];
436     char*       ret;
437
438     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), resfile);
439     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
440     assert(!(strlen(buf) & 1));
441     ret = decodeA(buf);
442     return ret;
443 }
444
445 static WCHAR* getChildStringW(const char* sect, const char* key)
446 {
447     char        buf[1024+4*MAX_LISTED_ENV_VAR];
448     WCHAR*       ret;
449
450     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), resfile);
451     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
452     assert(!(strlen(buf) & 1));
453     ret = decodeW(buf);
454     return ret;
455 }
456
457 /* FIXME: this may be moved to the wtmain.c file, because it may be needed by
458  * others... (windows uses stricmp while Un*x uses strcasecmp...)
459  */
460 static int wtstrcasecmp(const char* p1, const char* p2)
461 {
462     char c1, c2;
463
464     c1 = c2 = '@';
465     while (c1 == c2 && c1)
466     {
467         c1 = *p1++; c2 = *p2++;
468         if (c1 != c2)
469         {
470             c1 = toupper(c1); c2 = toupper(c2);
471         }
472     }
473     return c1 - c2;
474 }
475
476 static int strCmp(const char* s1, const char* s2, BOOL sensitive)
477 {
478     if (!s1 && !s2) return 0;
479     if (!s2) return -1;
480     if (!s1) return 1;
481     return (sensitive) ? strcmp(s1, s2) : wtstrcasecmp(s1, s2);
482 }
483
484 static void ok_child_string( int line, const char *sect, const char *key,
485                              const char *expect, int sensitive )
486 {
487     char* result = getChildString( sect, key );
488     ok_(__FILE__, line)( strCmp(result, expect, sensitive) == 0, "%s:%s expected '%s', got '%s'\n",
489                          sect, key, expect ? expect : "(null)", result );
490 }
491
492 static void ok_child_stringWA( int line, const char *sect, const char *key,
493                              const char *expect, int sensitive )
494 {
495     WCHAR* expectW;
496     CHAR* resultA;
497     DWORD len;
498     WCHAR* result = getChildStringW( sect, key );
499
500     len = MultiByteToWideChar( CP_ACP, 0, expect, -1, NULL, 0);
501     expectW = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
502     MultiByteToWideChar( CP_ACP, 0, expect, -1, expectW, len);
503
504     len = WideCharToMultiByte( CP_ACP, 0, result, -1, NULL, 0, NULL, NULL);
505     resultA = HeapAlloc(GetProcessHeap(),0,len*sizeof(CHAR));
506     WideCharToMultiByte( CP_ACP, 0, result, -1, resultA, len, NULL, NULL);
507
508     if (sensitive)
509         ok_(__FILE__, line)( lstrcmpW(result, expectW) == 0, "%s:%s expected '%s', got '%s'\n",
510                          sect, key, expect ? expect : "(null)", resultA );
511     else
512         ok_(__FILE__, line)( lstrcmpiW(result, expectW) == 0, "%s:%s expected '%s', got '%s'\n",
513                          sect, key, expect ? expect : "(null)", resultA );
514     HeapFree(GetProcessHeap(),0,expectW);
515     HeapFree(GetProcessHeap(),0,resultA);
516 }
517
518 #define okChildString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 1 )
519 #define okChildIString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 0 )
520 #define okChildStringWA(sect, key, expect) ok_child_stringWA(__LINE__, (sect), (key), (expect), 1 )
521
522 /* using !expect ensures that the test will fail if the sect/key isn't present
523  * in result file
524  */
525 #define okChildInt(sect, key, expect) \
526     do { \
527         UINT result = GetPrivateProfileIntA((sect), (key), !(expect), resfile); \
528         ok(result == expect, "%s:%s expected %u, but got %u\n", (sect), (key), (UINT)(expect), result); \
529    } while (0)
530
531 static void test_Startup(void)
532 {
533     char                buffer[MAX_PATH];
534     PROCESS_INFORMATION info;
535     STARTUPINFOA        startup,si;
536     char *result;
537     static CHAR title[]   = "I'm the title string",
538                 desktop[] = "winsta0\\default",
539                 empty[]   = "";
540
541     /* let's start simplistic */
542     memset(&startup, 0, sizeof(startup));
543     startup.cb = sizeof(startup);
544     startup.dwFlags = STARTF_USESHOWWINDOW;
545     startup.wShowWindow = SW_SHOWNORMAL;
546
547     get_file_name(resfile);
548     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
549     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
550     /* wait for child to terminate */
551     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
552     /* child process has changed result file, so let profile functions know about it */
553     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
554
555     GetStartupInfoA(&si);
556     okChildInt("StartupInfoA", "cb", startup.cb);
557     okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
558     okChildInt("StartupInfoA", "dwX", startup.dwX);
559     okChildInt("StartupInfoA", "dwY", startup.dwY);
560     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
561     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
562     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
563     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
564     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
565     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
566     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
567     release_memory();
568     assert(DeleteFileA(resfile) != 0);
569
570     /* not so simplistic now */
571     memset(&startup, 0, sizeof(startup));
572     startup.cb = sizeof(startup);
573     startup.dwFlags = STARTF_USESHOWWINDOW;
574     startup.wShowWindow = SW_SHOWNORMAL;
575     startup.lpTitle = title;
576     startup.lpDesktop = desktop;
577     startup.dwXCountChars = 0x12121212;
578     startup.dwYCountChars = 0x23232323;
579     startup.dwX = 0x34343434;
580     startup.dwY = 0x45454545;
581     startup.dwXSize = 0x56565656;
582     startup.dwYSize = 0x67676767;
583     startup.dwFillAttribute = 0xA55A;
584
585     get_file_name(resfile);
586     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
587     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
588     /* wait for child to terminate */
589     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
590     /* child process has changed result file, so let profile functions know about it */
591     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
592
593     okChildInt("StartupInfoA", "cb", startup.cb);
594     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
595     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
596     okChildInt("StartupInfoA", "dwX", startup.dwX);
597     okChildInt("StartupInfoA", "dwY", startup.dwY);
598     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
599     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
600     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
601     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
602     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
603     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
604     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
605     release_memory();
606     assert(DeleteFileA(resfile) != 0);
607
608     /* not so simplistic now */
609     memset(&startup, 0, sizeof(startup));
610     startup.cb = sizeof(startup);
611     startup.dwFlags = STARTF_USESHOWWINDOW;
612     startup.wShowWindow = SW_SHOWNORMAL;
613     startup.lpTitle = title;
614     startup.lpDesktop = NULL;
615     startup.dwXCountChars = 0x12121212;
616     startup.dwYCountChars = 0x23232323;
617     startup.dwX = 0x34343434;
618     startup.dwY = 0x45454545;
619     startup.dwXSize = 0x56565656;
620     startup.dwYSize = 0x67676767;
621     startup.dwFillAttribute = 0xA55A;
622
623     get_file_name(resfile);
624     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
625     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
626     /* wait for child to terminate */
627     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
628     /* child process has changed result file, so let profile functions know about it */
629     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
630
631     okChildInt("StartupInfoA", "cb", startup.cb);
632     okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
633     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
634     okChildInt("StartupInfoA", "dwX", startup.dwX);
635     okChildInt("StartupInfoA", "dwY", startup.dwY);
636     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
637     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
638     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
639     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
640     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
641     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
642     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
643     release_memory();
644     assert(DeleteFileA(resfile) != 0);
645
646     /* not so simplistic now */
647     memset(&startup, 0, sizeof(startup));
648     startup.cb = sizeof(startup);
649     startup.dwFlags = STARTF_USESHOWWINDOW;
650     startup.wShowWindow = SW_SHOWNORMAL;
651     startup.lpTitle = title;
652     startup.lpDesktop = empty;
653     startup.dwXCountChars = 0x12121212;
654     startup.dwYCountChars = 0x23232323;
655     startup.dwX = 0x34343434;
656     startup.dwY = 0x45454545;
657     startup.dwXSize = 0x56565656;
658     startup.dwYSize = 0x67676767;
659     startup.dwFillAttribute = 0xA55A;
660
661     get_file_name(resfile);
662     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
663     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
664     /* wait for child to terminate */
665     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
666     /* child process has changed result file, so let profile functions know about it */
667     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
668
669     okChildInt("StartupInfoA", "cb", startup.cb);
670     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
671     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
672     okChildInt("StartupInfoA", "dwX", startup.dwX);
673     okChildInt("StartupInfoA", "dwY", startup.dwY);
674     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
675     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
676     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
677     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
678     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
679     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
680     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
681     release_memory();
682     assert(DeleteFileA(resfile) != 0);
683
684     /* not so simplistic now */
685     memset(&startup, 0, sizeof(startup));
686     startup.cb = sizeof(startup);
687     startup.dwFlags = STARTF_USESHOWWINDOW;
688     startup.wShowWindow = SW_SHOWNORMAL;
689     startup.lpTitle = NULL;
690     startup.lpDesktop = desktop;
691     startup.dwXCountChars = 0x12121212;
692     startup.dwYCountChars = 0x23232323;
693     startup.dwX = 0x34343434;
694     startup.dwY = 0x45454545;
695     startup.dwXSize = 0x56565656;
696     startup.dwYSize = 0x67676767;
697     startup.dwFillAttribute = 0xA55A;
698
699     get_file_name(resfile);
700     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
701     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
702     /* wait for child to terminate */
703     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
704     /* child process has changed result file, so let profile functions know about it */
705     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
706
707     okChildInt("StartupInfoA", "cb", startup.cb);
708     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
709     result = getChildString( "StartupInfoA", "lpTitle" );
710     ok( broken(!result) || (result && !strCmp( result, selfname, 0 )),
711         "expected '%s' or null, got '%s'\n", selfname, result );
712     okChildInt("StartupInfoA", "dwX", startup.dwX);
713     okChildInt("StartupInfoA", "dwY", startup.dwY);
714     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
715     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
716     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
717     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
718     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
719     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
720     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
721     release_memory();
722     assert(DeleteFileA(resfile) != 0);
723
724     /* not so simplistic now */
725     memset(&startup, 0, sizeof(startup));
726     startup.cb = sizeof(startup);
727     startup.dwFlags = STARTF_USESHOWWINDOW;
728     startup.wShowWindow = SW_SHOWNORMAL;
729     startup.lpTitle = empty;
730     startup.lpDesktop = desktop;
731     startup.dwXCountChars = 0x12121212;
732     startup.dwYCountChars = 0x23232323;
733     startup.dwX = 0x34343434;
734     startup.dwY = 0x45454545;
735     startup.dwXSize = 0x56565656;
736     startup.dwYSize = 0x67676767;
737     startup.dwFillAttribute = 0xA55A;
738
739     get_file_name(resfile);
740     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
741     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
742     /* wait for child to terminate */
743     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
744     /* child process has changed result file, so let profile functions know about it */
745     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
746
747     okChildInt("StartupInfoA", "cb", startup.cb);
748     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
749     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
750     okChildInt("StartupInfoA", "dwX", startup.dwX);
751     okChildInt("StartupInfoA", "dwY", startup.dwY);
752     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
753     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
754     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
755     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
756     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
757     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
758     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
759     release_memory();
760     assert(DeleteFileA(resfile) != 0);
761
762     /* not so simplistic now */
763     memset(&startup, 0, sizeof(startup));
764     startup.cb = sizeof(startup);
765     startup.dwFlags = STARTF_USESHOWWINDOW;
766     startup.wShowWindow = SW_SHOWNORMAL;
767     startup.lpTitle = empty;
768     startup.lpDesktop = empty;
769     startup.dwXCountChars = 0x12121212;
770     startup.dwYCountChars = 0x23232323;
771     startup.dwX = 0x34343434;
772     startup.dwY = 0x45454545;
773     startup.dwXSize = 0x56565656;
774     startup.dwYSize = 0x67676767;
775     startup.dwFillAttribute = 0xA55A;
776
777     get_file_name(resfile);
778     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
779     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
780     /* wait for child to terminate */
781     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
782     /* child process has changed result file, so let profile functions know about it */
783     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
784
785     okChildInt("StartupInfoA", "cb", startup.cb);
786     okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
787     okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
788     okChildInt("StartupInfoA", "dwX", startup.dwX);
789     okChildInt("StartupInfoA", "dwY", startup.dwY);
790     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
791     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
792     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
793     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
794     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
795     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
796     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
797     release_memory();
798     assert(DeleteFileA(resfile) != 0);
799
800     /* TODO: test for A/W and W/A and W/W */
801 }
802
803 static void test_CommandLine(void)
804 {
805     char                buffer[MAX_PATH], fullpath[MAX_PATH], *lpFilePart, *p;
806     char                buffer2[MAX_PATH];
807     PROCESS_INFORMATION info;
808     STARTUPINFOA        startup;
809     BOOL                ret;
810
811     memset(&startup, 0, sizeof(startup));
812     startup.cb = sizeof(startup);
813     startup.dwFlags = STARTF_USESHOWWINDOW;
814     startup.wShowWindow = SW_SHOWNORMAL;
815
816     /* the basics */
817     get_file_name(resfile);
818     sprintf(buffer, "\"%s\" tests/process.c \"%s\" \"C:\\Program Files\\my nice app.exe\"", selfname, resfile);
819     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
820     /* wait for child to terminate */
821     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
822     /* child process has changed result file, so let profile functions know about it */
823     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
824
825     okChildInt("Arguments", "argcA", 4);
826     okChildString("Arguments", "argvA3", "C:\\Program Files\\my nice app.exe");
827     okChildString("Arguments", "argvA4", NULL);
828     okChildString("Arguments", "CommandLineA", buffer);
829     release_memory();
830     assert(DeleteFileA(resfile) != 0);
831
832     memset(&startup, 0, sizeof(startup));
833     startup.cb = sizeof(startup);
834     startup.dwFlags = STARTF_USESHOWWINDOW;
835     startup.wShowWindow = SW_SHOWNORMAL;
836
837     /* from François */
838     get_file_name(resfile);
839     sprintf(buffer, "\"%s\" tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", selfname, resfile);
840     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
841     /* wait for child to terminate */
842     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
843     /* child process has changed result file, so let profile functions know about it */
844     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
845
846     okChildInt("Arguments", "argcA", 6);
847     okChildString("Arguments", "argvA3", "a\"b\\");
848     okChildString("Arguments", "argvA4", "c\"");
849     okChildString("Arguments", "argvA5", "d");
850     okChildString("Arguments", "argvA6", NULL);
851     okChildString("Arguments", "CommandLineA", buffer);
852     release_memory();
853     assert(DeleteFileA(resfile) != 0);
854
855     /* Test for Bug1330 to show that XP doesn't change '/' to '\\' in argv[0]*/
856     get_file_name(resfile);
857     /* Use exename to avoid buffer containing things like 'C:' */
858     sprintf(buffer, "./%s tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", exename, resfile);
859     SetLastError(0xdeadbeef);
860     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
861     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
862     /* wait for child to terminate */
863     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
864     /* child process has changed result file, so let profile functions know about it */
865     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
866     sprintf(buffer, "./%s", exename);
867     okChildString("Arguments", "argvA0", buffer);
868     release_memory();
869     assert(DeleteFileA(resfile) != 0);
870
871     get_file_name(resfile);
872     /* Use exename to avoid buffer containing things like 'C:' */
873     sprintf(buffer, ".\\%s tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", exename, resfile);
874     SetLastError(0xdeadbeef);
875     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
876     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
877     /* wait for child to terminate */
878     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
879     /* child process has changed result file, so let profile functions know about it */
880     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
881     sprintf(buffer, ".\\%s", exename);
882     okChildString("Arguments", "argvA0", buffer);
883     release_memory();
884     assert(DeleteFileA(resfile) != 0);
885     
886     get_file_name(resfile);
887     GetFullPathNameA(selfname, MAX_PATH, fullpath, &lpFilePart);
888     assert ( lpFilePart != 0);
889     *(lpFilePart -1 ) = 0;
890     p = strrchr(fullpath, '\\');
891     /* Use exename to avoid buffer containing things like 'C:' */
892     if (p) sprintf(buffer, "..%s/%s tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", p, exename, resfile);
893     else sprintf(buffer, "./%s tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", exename, resfile);
894     SetLastError(0xdeadbeef);
895     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
896     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
897     /* wait for child to terminate */
898     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
899     /* child process has changed result file, so let profile functions know about it */
900     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
901     if (p) sprintf(buffer, "..%s/%s", p, exename);
902     else sprintf(buffer, "./%s", exename);
903     okChildString("Arguments", "argvA0", buffer);
904     release_memory();
905     assert(DeleteFileA(resfile) != 0);
906
907     /* Using AppName */
908     get_file_name(resfile);
909     GetFullPathNameA(selfname, MAX_PATH, fullpath, &lpFilePart);
910     assert ( lpFilePart != 0);
911     *(lpFilePart -1 ) = 0;
912     p = strrchr(fullpath, '\\');
913     /* Use exename to avoid buffer containing things like 'C:' */
914     if (p) sprintf(buffer, "..%s/%s", p, exename);
915     else sprintf(buffer, "./%s", exename);
916     sprintf(buffer2, "dummy tests/process.c \"%s\" \"a\\\"b\\\\\" c\\\" d", resfile);
917     SetLastError(0xdeadbeef);
918     ret = CreateProcessA(buffer, buffer2, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
919     ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
920     /* wait for child to terminate */
921     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
922     /* child process has changed result file, so let profile functions know about it */
923     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
924     sprintf(buffer, "tests/process.c %s", resfile);
925     okChildString("Arguments", "argvA0", "dummy");
926     okChildString("Arguments", "CommandLineA", buffer2);
927     okChildStringWA("Arguments", "CommandLineW", buffer2);
928     release_memory();
929     assert(DeleteFileA(resfile) != 0);
930
931     if (0) /* Test crashes on NT-based Windows. */
932     {
933         /* Test NULL application name and command line parameters. */
934         SetLastError(0xdeadbeef);
935         ret = CreateProcessA(NULL, NULL, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
936         ok(!ret, "CreateProcessA unexpectedly succeeded\n");
937         ok(GetLastError() == ERROR_INVALID_PARAMETER,
938            "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
939     }
940
941     buffer[0] = '\0';
942
943     /* Test empty application name parameter. */
944     SetLastError(0xdeadbeef);
945     ret = CreateProcessA(buffer, NULL, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
946     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
947     ok(GetLastError() == ERROR_PATH_NOT_FOUND ||
948        broken(GetLastError() == ERROR_FILE_NOT_FOUND) /* Win9x/WinME */ ||
949        broken(GetLastError() == ERROR_ACCESS_DENIED) /* Win98 */,
950        "Expected ERROR_PATH_NOT_FOUND, got %d\n", GetLastError());
951
952     buffer2[0] = '\0';
953
954     /* Test empty application name and command line parameters. */
955     SetLastError(0xdeadbeef);
956     ret = CreateProcessA(buffer, buffer2, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
957     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
958     ok(GetLastError() == ERROR_PATH_NOT_FOUND ||
959        broken(GetLastError() == ERROR_FILE_NOT_FOUND) /* Win9x/WinME */ ||
960        broken(GetLastError() == ERROR_ACCESS_DENIED) /* Win98 */,
961        "Expected ERROR_PATH_NOT_FOUND, got %d\n", GetLastError());
962
963     /* Test empty command line parameter. */
964     SetLastError(0xdeadbeef);
965     ret = CreateProcessA(NULL, buffer2, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
966     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
967     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
968        GetLastError() == ERROR_PATH_NOT_FOUND /* NT4 */ ||
969        GetLastError() == ERROR_BAD_PATHNAME /* Win98 */ ||
970        GetLastError() == ERROR_INVALID_PARAMETER /* Win7 */,
971        "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
972
973     strcpy(buffer, "doesnotexist.exe");
974     strcpy(buffer2, "does not exist.exe");
975
976     /* Test nonexistent application name. */
977     SetLastError(0xdeadbeef);
978     ret = CreateProcessA(buffer, NULL, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
979     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
980     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
981
982     SetLastError(0xdeadbeef);
983     ret = CreateProcessA(buffer2, NULL, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
984     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
985     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
986
987     /* Test nonexistent command line parameter. */
988     SetLastError(0xdeadbeef);
989     ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
990     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
991     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
992
993     SetLastError(0xdeadbeef);
994     ret = CreateProcessA(NULL, buffer2, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
995     ok(!ret, "CreateProcessA unexpectedly succeeded\n");
996     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
997 }
998
999 static void test_Directory(void)
1000 {
1001     char                buffer[MAX_PATH];
1002     PROCESS_INFORMATION info;
1003     STARTUPINFOA        startup;
1004     char windir[MAX_PATH];
1005     static CHAR cmdline[] = "winver.exe";
1006
1007     memset(&startup, 0, sizeof(startup));
1008     startup.cb = sizeof(startup);
1009     startup.dwFlags = STARTF_USESHOWWINDOW;
1010     startup.wShowWindow = SW_SHOWNORMAL;
1011
1012     /* the basics */
1013     get_file_name(resfile);
1014     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
1015     GetWindowsDirectoryA( windir, sizeof(windir) );
1016     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, windir, &startup, &info), "CreateProcess\n");
1017     /* wait for child to terminate */
1018     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1019     /* child process has changed result file, so let profile functions know about it */
1020     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1021
1022     okChildIString("Misc", "CurrDirA", windir);
1023     release_memory();
1024     assert(DeleteFileA(resfile) != 0);
1025
1026     /* search PATH for the exe if directory is NULL */
1027     ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
1028     ok(TerminateProcess(info.hProcess, 0), "Child process termination\n");
1029
1030     /* if any directory is provided, don't search PATH, error on bad directory */
1031     SetLastError(0xdeadbeef);
1032     memset(&info, 0, sizeof(info));
1033     ok(!CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L,
1034                        NULL, "non\\existent\\directory", &startup, &info), "CreateProcess\n");
1035     ok(GetLastError() == ERROR_DIRECTORY, "Expected ERROR_DIRECTORY, got %d\n", GetLastError());
1036     ok(!TerminateProcess(info.hProcess, 0), "Child process should not exist\n");
1037 }
1038
1039 static BOOL is_str_env_drive_dir(const char* str)
1040 {
1041     return str[0] == '=' && str[1] >= 'A' && str[1] <= 'Z' && str[2] == ':' &&
1042         str[3] == '=' && str[4] == str[1];
1043 }
1044
1045 /* compared expected child's environment (in gesA) from actual
1046  * environment our child got
1047  */
1048 static void cmpEnvironment(const char* gesA)
1049 {
1050     int                 i, clen;
1051     const char*         ptrA;
1052     char*               res;
1053     char                key[32];
1054     BOOL                found;
1055
1056     clen = GetPrivateProfileIntA("EnvironmentA", "len", 0, resfile);
1057     
1058     /* now look each parent env in child */
1059     if ((ptrA = gesA) != NULL)
1060     {
1061         while (*ptrA)
1062         {
1063             for (i = 0; i < clen; i++)
1064             {
1065                 sprintf(key, "env%d", i);
1066                 res = getChildString("EnvironmentA", key);
1067                 if (strncmp(ptrA, res, MAX_LISTED_ENV_VAR - 1) == 0)
1068                     break;
1069             }
1070             found = i < clen;
1071             ok(found, "Parent-env string %s isn't in child process\n", ptrA);
1072             
1073             ptrA += strlen(ptrA) + 1;
1074             release_memory();
1075         }
1076     }
1077     /* and each child env in parent */
1078     for (i = 0; i < clen; i++)
1079     {
1080         sprintf(key, "env%d", i);
1081         res = getChildString("EnvironmentA", key);
1082         if ((ptrA = gesA) != NULL)
1083         {
1084             while (*ptrA)
1085             {
1086                 if (strncmp(res, ptrA, MAX_LISTED_ENV_VAR - 1) == 0)
1087                     break;
1088                 ptrA += strlen(ptrA) + 1;
1089             }
1090             if (!*ptrA) ptrA = NULL;
1091         }
1092
1093         if (!is_str_env_drive_dir(res))
1094         {
1095             found = ptrA != NULL;
1096             ok(found, "Child-env string %s isn't in parent process\n", res);
1097         }
1098         /* else => should also test we get the right per drive default directory here... */
1099     }
1100 }
1101
1102 static void test_Environment(void)
1103 {
1104     char                buffer[MAX_PATH];
1105     PROCESS_INFORMATION info;
1106     STARTUPINFOA        startup;
1107     char                *child_env;
1108     int                 child_env_len;
1109     char                *ptr;
1110     char                *ptr2;
1111     char                *env;
1112     int                 slen;
1113
1114     memset(&startup, 0, sizeof(startup));
1115     startup.cb = sizeof(startup);
1116     startup.dwFlags = STARTF_USESHOWWINDOW;
1117     startup.wShowWindow = SW_SHOWNORMAL;
1118
1119     /* the basics */
1120     get_file_name(resfile);
1121     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
1122     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
1123     /* wait for child to terminate */
1124     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1125     /* child process has changed result file, so let profile functions know about it */
1126     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1127
1128     env = GetEnvironmentStringsA();
1129     cmpEnvironment(env);
1130     release_memory();
1131     assert(DeleteFileA(resfile) != 0);
1132
1133     memset(&startup, 0, sizeof(startup));
1134     startup.cb = sizeof(startup);
1135     startup.dwFlags = STARTF_USESHOWWINDOW;
1136     startup.wShowWindow = SW_SHOWNORMAL;
1137
1138     /* the basics */
1139     get_file_name(resfile);
1140     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
1141
1142     child_env_len = 0;
1143     ptr = env;
1144     while(*ptr)
1145     {
1146         slen = strlen(ptr)+1;
1147         child_env_len += slen;
1148         ptr += slen;
1149     }
1150     /* Add space for additional environment variables */
1151     child_env_len += 256;
1152     child_env = HeapAlloc(GetProcessHeap(), 0, child_env_len);
1153
1154     ptr = child_env;
1155     sprintf(ptr, "=%c:=%s", 'C', "C:\\FOO\\BAR");
1156     ptr += strlen(ptr) + 1;
1157     strcpy(ptr, "PATH=C:\\WINDOWS;C:\\WINDOWS\\SYSTEM;C:\\MY\\OWN\\DIR");
1158     ptr += strlen(ptr) + 1;
1159     strcpy(ptr, "FOO=BAR");
1160     ptr += strlen(ptr) + 1;
1161     strcpy(ptr, "BAR=FOOBAR");
1162     ptr += strlen(ptr) + 1;
1163     /* copy all existing variables except:
1164      * - WINELOADER
1165      * - PATH (already set above)
1166      * - the directory definitions (=[A-Z]:=)
1167      */
1168     for (ptr2 = env; *ptr2; ptr2 += strlen(ptr2) + 1)
1169     {
1170         if (strncmp(ptr2, "PATH=", 5) != 0 &&
1171             strncmp(ptr2, "WINELOADER=", 11) != 0 &&
1172             !is_str_env_drive_dir(ptr2))
1173         {
1174             strcpy(ptr, ptr2);
1175             ptr += strlen(ptr) + 1;
1176         }
1177     }
1178     *ptr = '\0';
1179     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, child_env, NULL, &startup, &info), "CreateProcess\n");
1180     /* wait for child to terminate */
1181     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1182     /* child process has changed result file, so let profile functions know about it */
1183     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1184
1185     cmpEnvironment(child_env);
1186
1187     HeapFree(GetProcessHeap(), 0, child_env);
1188     FreeEnvironmentStringsA(env);
1189     release_memory();
1190     assert(DeleteFileA(resfile) != 0);
1191 }
1192
1193 static  void    test_SuspendFlag(void)
1194 {
1195     char                buffer[MAX_PATH];
1196     PROCESS_INFORMATION info;
1197     STARTUPINFOA       startup, us;
1198     DWORD               exit_status;
1199     char *result;
1200
1201     /* let's start simplistic */
1202     memset(&startup, 0, sizeof(startup));
1203     startup.cb = sizeof(startup);
1204     startup.dwFlags = STARTF_USESHOWWINDOW;
1205     startup.wShowWindow = SW_SHOWNORMAL;
1206
1207     get_file_name(resfile);
1208     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
1209     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &startup, &info), "CreateProcess\n");
1210
1211     ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1212     Sleep(8000);
1213     ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1214     ok(ResumeThread(info.hThread) == 1, "Resuming thread\n");
1215
1216     /* wait for child to terminate */
1217     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1218     /* child process has changed result file, so let profile functions know about it */
1219     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1220
1221     GetStartupInfoA(&us);
1222
1223     okChildInt("StartupInfoA", "cb", startup.cb);
1224     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1225     result = getChildString( "StartupInfoA", "lpTitle" );
1226     ok( broken(!result) || (result && !strCmp( result, selfname, 0 )),
1227         "expected '%s' or null, got '%s'\n", selfname, result );
1228     okChildInt("StartupInfoA", "dwX", startup.dwX);
1229     okChildInt("StartupInfoA", "dwY", startup.dwY);
1230     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1231     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1232     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1233     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1234     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1235     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1236     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1237     release_memory();
1238     assert(DeleteFileA(resfile) != 0);
1239 }
1240
1241 static  void    test_DebuggingFlag(void)
1242 {
1243     char                buffer[MAX_PATH];
1244     void               *processbase = NULL;
1245     PROCESS_INFORMATION info;
1246     STARTUPINFOA       startup, us;
1247     DEBUG_EVENT         de;
1248     unsigned            dbg = 0;
1249     char *result;
1250
1251     /* let's start simplistic */
1252     memset(&startup, 0, sizeof(startup));
1253     startup.cb = sizeof(startup);
1254     startup.dwFlags = STARTF_USESHOWWINDOW;
1255     startup.wShowWindow = SW_SHOWNORMAL;
1256
1257     get_file_name(resfile);
1258     sprintf(buffer, "\"%s\" tests/process.c \"%s\"", selfname, resfile);
1259     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1260
1261     /* get all startup events up to the entry point break exception */
1262     do 
1263     {
1264         ok(WaitForDebugEvent(&de, INFINITE), "reading debug event\n");
1265         ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
1266         if (!dbg)
1267         {
1268             ok(de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT,
1269                "first event: %d\n", de.dwDebugEventCode);
1270             processbase = de.u.CreateProcessInfo.lpBaseOfImage;
1271         }
1272         if (de.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) dbg++;
1273         ok(de.dwDebugEventCode != LOAD_DLL_DEBUG_EVENT ||
1274            de.u.LoadDll.lpBaseOfDll != processbase, "got LOAD_DLL for main module\n");
1275     } while (de.dwDebugEventCode != EXIT_PROCESS_DEBUG_EVENT);
1276
1277     ok(dbg, "I have seen a debug event\n");
1278     /* wait for child to terminate */
1279     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1280     /* child process has changed result file, so let profile functions know about it */
1281     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1282
1283     GetStartupInfoA(&us);
1284
1285     okChildInt("StartupInfoA", "cb", startup.cb);
1286     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1287     result = getChildString( "StartupInfoA", "lpTitle" );
1288     ok( broken(!result) || (result && !strCmp( result, selfname, 0 )),
1289         "expected '%s' or null, got '%s'\n", selfname, result );
1290     okChildInt("StartupInfoA", "dwX", startup.dwX);
1291     okChildInt("StartupInfoA", "dwY", startup.dwY);
1292     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1293     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1294     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1295     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1296     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1297     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1298     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1299     release_memory();
1300     assert(DeleteFileA(resfile) != 0);
1301 }
1302
1303 static BOOL is_console(HANDLE h)
1304 {
1305     return h != INVALID_HANDLE_VALUE && ((ULONG_PTR)h & 3) == 3;
1306 }
1307
1308 static void test_Console(void)
1309 {
1310     char                buffer[MAX_PATH];
1311     PROCESS_INFORMATION info;
1312     STARTUPINFOA       startup, us;
1313     SECURITY_ATTRIBUTES sa;
1314     CONSOLE_SCREEN_BUFFER_INFO  sbi, sbiC;
1315     DWORD               modeIn, modeOut, modeInC, modeOutC;
1316     DWORD               cpIn, cpOut, cpInC, cpOutC;
1317     DWORD               w;
1318     HANDLE              hChildIn, hChildInInh, hChildOut, hChildOutInh, hParentIn, hParentOut;
1319     const char*         msg = "This is a std-handle inheritance test.";
1320     unsigned            msg_len;
1321     BOOL                run_tests = TRUE;
1322     char *result;
1323
1324     memset(&startup, 0, sizeof(startup));
1325     startup.cb = sizeof(startup);
1326     startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1327     startup.wShowWindow = SW_SHOWNORMAL;
1328
1329     sa.nLength = sizeof(sa);
1330     sa.lpSecurityDescriptor = NULL;
1331     sa.bInheritHandle = TRUE;
1332
1333     startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1334     startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1335
1336     /* first, we need to be sure we're attached to a console */
1337     if (!is_console(startup.hStdInput) || !is_console(startup.hStdOutput))
1338     {
1339         /* we're not attached to a console, let's do it */
1340         AllocConsole();
1341         startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1342         startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1343     }
1344     /* now verify everything's ok */
1345     ok(startup.hStdInput != INVALID_HANDLE_VALUE, "Opening ConIn\n");
1346     ok(startup.hStdOutput != INVALID_HANDLE_VALUE, "Opening ConOut\n");
1347     startup.hStdError = startup.hStdOutput;
1348
1349     ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbi), "Getting sb info\n");
1350     ok(GetConsoleMode(startup.hStdInput, &modeIn) && 
1351        GetConsoleMode(startup.hStdOutput, &modeOut), "Getting console modes\n");
1352     cpIn = GetConsoleCP();
1353     cpOut = GetConsoleOutputCP();
1354
1355     get_file_name(resfile);
1356     sprintf(buffer, "\"%s\" tests/process.c \"%s\" console", selfname, resfile);
1357     ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1358
1359     /* wait for child to terminate */
1360     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1361     /* child process has changed result file, so let profile functions know about it */
1362     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1363
1364     /* now get the modification the child has made, and resets parents expected values */
1365     ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbiC), "Getting sb info\n");
1366     ok(GetConsoleMode(startup.hStdInput, &modeInC) && 
1367        GetConsoleMode(startup.hStdOutput, &modeOutC), "Getting console modes\n");
1368
1369     SetConsoleMode(startup.hStdInput, modeIn);
1370     SetConsoleMode(startup.hStdOutput, modeOut);
1371
1372     cpInC = GetConsoleCP();
1373     cpOutC = GetConsoleOutputCP();
1374
1375     /* Try to set invalid CP */
1376     SetLastError(0xdeadbeef);
1377     ok(!SetConsoleCP(0), "Shouldn't succeed\n");
1378     ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1379        broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1380        "GetLastError: expecting %u got %u\n",
1381        ERROR_INVALID_PARAMETER, GetLastError());
1382     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1383         run_tests = FALSE;
1384
1385
1386     SetLastError(0xdeadbeef);
1387     ok(!SetConsoleOutputCP(0), "Shouldn't succeed\n");
1388     ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1389        broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1390        "GetLastError: expecting %u got %u\n",
1391        ERROR_INVALID_PARAMETER, GetLastError());
1392
1393     SetConsoleCP(cpIn);
1394     SetConsoleOutputCP(cpOut);
1395
1396     GetStartupInfoA(&us);
1397
1398     okChildInt("StartupInfoA", "cb", startup.cb);
1399     okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1400     result = getChildString( "StartupInfoA", "lpTitle" );
1401     ok( broken(!result) || (result && !strCmp( result, selfname, 0 )),
1402         "expected '%s' or null, got '%s'\n", selfname, result );
1403     okChildInt("StartupInfoA", "dwX", startup.dwX);
1404     okChildInt("StartupInfoA", "dwY", startup.dwY);
1405     okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1406     okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1407     okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1408     okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1409     okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1410     okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1411     okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1412
1413     /* check child correctly inherited the console */
1414     okChildInt("StartupInfoA", "hStdInput", (DWORD_PTR)startup.hStdInput);
1415     okChildInt("StartupInfoA", "hStdOutput", (DWORD_PTR)startup.hStdOutput);
1416     okChildInt("StartupInfoA", "hStdError", (DWORD_PTR)startup.hStdError);
1417     okChildInt("Console", "SizeX", (DWORD)sbi.dwSize.X);
1418     okChildInt("Console", "SizeY", (DWORD)sbi.dwSize.Y);
1419     okChildInt("Console", "CursorX", (DWORD)sbi.dwCursorPosition.X);
1420     okChildInt("Console", "CursorY", (DWORD)sbi.dwCursorPosition.Y);
1421     okChildInt("Console", "Attributes", sbi.wAttributes);
1422     okChildInt("Console", "winLeft", (DWORD)sbi.srWindow.Left);
1423     okChildInt("Console", "winTop", (DWORD)sbi.srWindow.Top);
1424     okChildInt("Console", "winRight", (DWORD)sbi.srWindow.Right);
1425     okChildInt("Console", "winBottom", (DWORD)sbi.srWindow.Bottom);
1426     okChildInt("Console", "maxWinWidth", (DWORD)sbi.dwMaximumWindowSize.X);
1427     okChildInt("Console", "maxWinHeight", (DWORD)sbi.dwMaximumWindowSize.Y);
1428     okChildInt("Console", "InputCP", cpIn);
1429     okChildInt("Console", "OutputCP", cpOut);
1430     okChildInt("Console", "InputMode", modeIn);
1431     okChildInt("Console", "OutputMode", modeOut);
1432
1433     if (run_tests)
1434     {
1435         ok(cpInC == 1252, "Wrong console CP (expected 1252 got %d/%d)\n", cpInC, cpIn);
1436         ok(cpOutC == 1252, "Wrong console-SB CP (expected 1252 got %d/%d)\n", cpOutC, cpOut);
1437     }
1438     else
1439         win_skip("Setting the codepage is not implemented\n");
1440
1441     ok(modeInC == (modeIn ^ 1), "Wrong console mode\n");
1442     ok(modeOutC == (modeOut ^ 1), "Wrong console-SB mode\n");
1443     trace("cursor position(X): %d/%d\n",sbi.dwCursorPosition.X, sbiC.dwCursorPosition.X);
1444     ok(sbiC.dwCursorPosition.Y == (sbi.dwCursorPosition.Y ^ 1), "Wrong cursor position\n");
1445
1446     release_memory();
1447     assert(DeleteFileA(resfile) != 0);
1448
1449     ok(CreatePipe(&hParentIn, &hChildOut, NULL, 0), "Creating parent-input pipe\n");
1450     ok(DuplicateHandle(GetCurrentProcess(), hChildOut, GetCurrentProcess(), 
1451                        &hChildOutInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1452        "Duplicating as inheritable child-output pipe\n");
1453     CloseHandle(hChildOut);
1454  
1455     ok(CreatePipe(&hChildIn, &hParentOut, NULL, 0), "Creating parent-output pipe\n");
1456     ok(DuplicateHandle(GetCurrentProcess(), hChildIn, GetCurrentProcess(), 
1457                        &hChildInInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1458        "Duplicating as inheritable child-input pipe\n");
1459     CloseHandle(hChildIn); 
1460     
1461     memset(&startup, 0, sizeof(startup));
1462     startup.cb = sizeof(startup);
1463     startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1464     startup.wShowWindow = SW_SHOWNORMAL;
1465     startup.hStdInput = hChildInInh;
1466     startup.hStdOutput = hChildOutInh;
1467     startup.hStdError = hChildOutInh;
1468
1469     get_file_name(resfile);
1470     sprintf(buffer, "\"%s\" tests/process.c \"%s\" stdhandle", selfname, resfile);
1471     ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1472     ok(CloseHandle(hChildInInh), "Closing handle\n");
1473     ok(CloseHandle(hChildOutInh), "Closing handle\n");
1474
1475     msg_len = strlen(msg) + 1;
1476     ok(WriteFile(hParentOut, msg, msg_len, &w, NULL), "Writing to child\n");
1477     ok(w == msg_len, "Should have written %u bytes, actually wrote %u\n", msg_len, w);
1478     memset(buffer, 0, sizeof(buffer));
1479     ok(ReadFile(hParentIn, buffer, sizeof(buffer), &w, NULL), "Reading from child\n");
1480     ok(strcmp(buffer, msg) == 0, "Should have received '%s'\n", msg);
1481
1482     /* wait for child to terminate */
1483     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1484     /* child process has changed result file, so let profile functions know about it */
1485     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1486
1487     okChildString("StdHandle", "msg", msg);
1488
1489     release_memory();
1490     assert(DeleteFileA(resfile) != 0);
1491 }
1492
1493 static  void    test_ExitCode(void)
1494 {
1495     char                buffer[MAX_PATH];
1496     PROCESS_INFORMATION info;
1497     STARTUPINFOA        startup;
1498     DWORD               code;
1499
1500     /* let's start simplistic */
1501     memset(&startup, 0, sizeof(startup));
1502     startup.cb = sizeof(startup);
1503     startup.dwFlags = STARTF_USESHOWWINDOW;
1504     startup.wShowWindow = SW_SHOWNORMAL;
1505
1506     get_file_name(resfile);
1507     sprintf(buffer, "\"%s\" tests/process.c \"%s\" exit_code", selfname, resfile);
1508     ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1509
1510     /* wait for child to terminate */
1511     ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1512     /* child process has changed result file, so let profile functions know about it */
1513     WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1514
1515     ok(GetExitCodeProcess(info.hProcess, &code), "Getting exit code\n");
1516     okChildInt("ExitCode", "value", code);
1517
1518     release_memory();
1519     assert(DeleteFileA(resfile) != 0);
1520 }
1521
1522 static void test_OpenProcess(void)
1523 {
1524     HANDLE hproc;
1525     void *addr1;
1526     MEMORY_BASIC_INFORMATION info;
1527     SIZE_T dummy, read_bytes;
1528     BOOL ret;
1529
1530     /* not exported in all windows versions */
1531     if ((!pVirtualAllocEx) || (!pVirtualFreeEx)) {
1532         win_skip("VirtualAllocEx not found\n");
1533         return;
1534     }
1535
1536     /* without PROCESS_VM_OPERATION */
1537     hproc = OpenProcess(PROCESS_ALL_ACCESS & ~PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1538     ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1539
1540     SetLastError(0xdeadbeef);
1541     addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1542     ok(!addr1, "VirtualAllocEx should fail\n");
1543     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1544     {   /* Win9x */
1545         CloseHandle(hproc);
1546         win_skip("VirtualAllocEx not implemented\n");
1547         return;
1548     }
1549     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1550
1551     read_bytes = 0xdeadbeef;
1552     SetLastError(0xdeadbeef);
1553     ret = ReadProcessMemory(hproc, test_OpenProcess, &dummy, sizeof(dummy), &read_bytes);
1554     ok(ret, "ReadProcessMemory error %d\n", GetLastError());
1555     ok(read_bytes == sizeof(dummy), "wrong read bytes %ld\n", read_bytes);
1556
1557     CloseHandle(hproc);
1558
1559     hproc = OpenProcess(PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1560     ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1561
1562     addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1563     ok(addr1 != NULL, "VirtualAllocEx error %d\n", GetLastError());
1564
1565     /* without PROCESS_QUERY_INFORMATION */
1566     SetLastError(0xdeadbeef);
1567     ok(!VirtualQueryEx(hproc, addr1, &info, sizeof(info)),
1568        "VirtualQueryEx without PROCESS_QUERY_INFORMATION rights should fail\n");
1569     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1570
1571     /* without PROCESS_VM_READ */
1572     read_bytes = 0xdeadbeef;
1573     SetLastError(0xdeadbeef);
1574     ok(!ReadProcessMemory(hproc, addr1, &dummy, sizeof(dummy), &read_bytes),
1575        "ReadProcessMemory without PROCESS_VM_READ rights should fail\n");
1576     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1577     ok(read_bytes == 0, "wrong read bytes %ld\n", read_bytes);
1578
1579     CloseHandle(hproc);
1580
1581     hproc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1582
1583     memset(&info, 0xcc, sizeof(info));
1584     read_bytes = VirtualQueryEx(hproc, addr1, &info, sizeof(info));
1585     ok(read_bytes == sizeof(info), "VirtualQueryEx error %d\n", GetLastError());
1586
1587     ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
1588     ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
1589     ok(info.AllocationProtect == PAGE_NOACCESS, "%x != PAGE_NOACCESS\n", info.AllocationProtect);
1590     ok(info.RegionSize == 0x10000, "%lx != 0x10000\n", info.RegionSize);
1591     ok(info.State == MEM_RESERVE, "%x != MEM_RESERVE\n", info.State);
1592     /* NT reports Protect == 0 for a not committed memory block */
1593     ok(info.Protect == 0 /* NT */ ||
1594        info.Protect == PAGE_NOACCESS, /* Win9x */
1595         "%x != PAGE_NOACCESS\n", info.Protect);
1596     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
1597
1598     SetLastError(0xdeadbeef);
1599     ok(!pVirtualFreeEx(hproc, addr1, 0, MEM_RELEASE),
1600        "VirtualFreeEx without PROCESS_VM_OPERATION rights should fail\n");
1601     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1602
1603     CloseHandle(hproc);
1604
1605     ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
1606 }
1607
1608 static void test_GetProcessVersion(void)
1609 {
1610     static char cmdline[] = "winver.exe";
1611     PROCESS_INFORMATION pi;
1612     STARTUPINFOA si;
1613     DWORD ret;
1614
1615     SetLastError(0xdeadbeef);
1616     ret = GetProcessVersion(0);
1617     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1618
1619     SetLastError(0xdeadbeef);
1620     ret = GetProcessVersion(GetCurrentProcessId());
1621     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1622
1623     memset(&si, 0, sizeof(si));
1624     si.cb = sizeof(si);
1625     si.dwFlags = STARTF_USESHOWWINDOW;
1626     si.wShowWindow = SW_HIDE;
1627     ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
1628     SetLastError(0xdeadbeef);
1629     ok(ret, "CreateProcess error %u\n", GetLastError());
1630
1631     SetLastError(0xdeadbeef);
1632     ret = GetProcessVersion(pi.dwProcessId);
1633     ok(ret, "GetProcessVersion error %u\n", GetLastError());
1634
1635     SetLastError(0xdeadbeef);
1636     ret = TerminateProcess(pi.hProcess, 0);
1637     ok(ret, "TerminateProcess error %u\n", GetLastError());
1638
1639     CloseHandle(pi.hProcess);
1640     CloseHandle(pi.hThread);
1641 }
1642
1643 static void test_GetProcessImageFileNameA(void)
1644 {
1645     DWORD rc;
1646     CHAR process[MAX_PATH];
1647     static const char harddisk[] = "\\Device\\HarddiskVolume";
1648
1649     if (!pK32GetProcessImageFileNameA)
1650     {
1651         win_skip("K32GetProcessImageFileNameA is unavailable\n");
1652         return;
1653     }
1654
1655     /* callers must guess the buffer size */
1656     SetLastError(0xdeadbeef);
1657     rc = pK32GetProcessImageFileNameA(GetCurrentProcess(), NULL, 0);
1658     ok(!rc && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1659        "K32GetProcessImageFileNameA(no buffer): returned %u, le=%u\n", rc, GetLastError());
1660
1661     *process = '\0';
1662     rc = pK32GetProcessImageFileNameA(GetCurrentProcess(), process, sizeof(process));
1663     expect_eq_d(rc, lstrlenA(process));
1664     if (strncmp(process, harddisk, lstrlenA(harddisk)))
1665     {
1666         todo_wine win_skip("%s is probably on a network share, skipping tests\n", process);
1667         return;
1668     }
1669
1670     if (!pQueryFullProcessImageNameA)
1671         win_skip("QueryFullProcessImageNameA unavailable (added in Windows Vista)\n");
1672     else
1673     {
1674         CHAR image[MAX_PATH];
1675         DWORD length;
1676
1677         length = sizeof(image);
1678         expect_eq_d(TRUE, pQueryFullProcessImageNameA(GetCurrentProcess(), PROCESS_NAME_NATIVE, image, &length));
1679         expect_eq_d(length, lstrlenA(image));
1680         ok(lstrcmpi(process, image) == 0, "expected '%s' to be equal to '%s'\n", process, image);
1681     }
1682 }
1683
1684 static void test_QueryFullProcessImageNameA(void)
1685 {
1686 #define INIT_STR "Just some words"
1687     DWORD length, size;
1688     CHAR buf[MAX_PATH], module[MAX_PATH];
1689
1690     if (!pQueryFullProcessImageNameA)
1691     {
1692         win_skip("QueryFullProcessImageNameA unavailable (added in Windows Vista)\n");
1693         return;
1694     }
1695
1696     *module = '\0';
1697     SetLastError(0); /* old Windows don't reset it on success */
1698     size = GetModuleFileNameA(NULL, module, sizeof(module));
1699     ok(size && GetLastError() != ERROR_INSUFFICIENT_BUFFER, "GetModuleFileName failed: %u le=%u\n", size, GetLastError());
1700
1701     /* get the buffer length without \0 terminator */
1702     length = sizeof(buf);
1703     expect_eq_d(TRUE, pQueryFullProcessImageNameA(GetCurrentProcess(), 0, buf, &length));
1704     expect_eq_d(length, lstrlenA(buf));
1705     ok((buf[0] == '\\' && buf[1] == '\\') ||
1706        lstrcmpi(buf, module) == 0, "expected %s to match %s\n", buf, module);
1707
1708     /*  when the buffer is too small
1709      *  - function fail with error ERROR_INSUFFICIENT_BUFFER
1710      *  - the size variable is not modified
1711      * tested with the biggest too small size
1712      */
1713     size = length;
1714     sprintf(buf,INIT_STR);
1715     expect_eq_d(FALSE, pQueryFullProcessImageNameA(GetCurrentProcess(), 0, buf, &size));
1716     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1717     expect_eq_d(length, size);
1718     expect_eq_s(INIT_STR, buf);
1719
1720     /* retest with smaller buffer size
1721      */
1722     size = 4;
1723     sprintf(buf,INIT_STR);
1724     expect_eq_d(FALSE, pQueryFullProcessImageNameA(GetCurrentProcess(), 0, buf, &size));
1725     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1726     expect_eq_d(4, size);
1727     expect_eq_s(INIT_STR, buf);
1728
1729     /* this is a difference between the ascii and the unicode version
1730      * the unicode version crashes when the size is big enough to hold
1731      * the result while the ascii version throws an error
1732      */
1733     size = 1024;
1734     expect_eq_d(FALSE, pQueryFullProcessImageNameA(GetCurrentProcess(), 0, NULL, &size));
1735     expect_eq_d(1024, size);
1736     expect_eq_d(ERROR_INVALID_PARAMETER, GetLastError());
1737 }
1738
1739 static void test_QueryFullProcessImageNameW(void)
1740 {
1741     HANDLE hSelf;
1742     WCHAR module_name[1024], device[1024];
1743     WCHAR deviceW[] = {'\\','D', 'e','v','i','c','e',0};
1744     WCHAR buf[1024];
1745     DWORD size, len;
1746
1747     if (!pQueryFullProcessImageNameW)
1748     {
1749         win_skip("QueryFullProcessImageNameW unavailable (added in Windows Vista)\n");
1750         return;
1751     }
1752
1753     ok(GetModuleFileNameW(NULL, module_name, 1024), "GetModuleFileNameW(NULL, ...) failed\n");
1754
1755     /* GetCurrentProcess pseudo-handle */
1756     size = sizeof(buf) / sizeof(buf[0]);
1757     expect_eq_d(TRUE, pQueryFullProcessImageNameW(GetCurrentProcess(), 0, buf, &size));
1758     expect_eq_d(lstrlenW(buf), size);
1759     expect_eq_ws_i(buf, module_name);
1760
1761     hSelf = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1762     /* Real handle */
1763     size = sizeof(buf) / sizeof(buf[0]);
1764     expect_eq_d(TRUE, pQueryFullProcessImageNameW(hSelf, 0, buf, &size));
1765     expect_eq_d(lstrlenW(buf), size);
1766     expect_eq_ws_i(buf, module_name);
1767
1768     /* Buffer too small */
1769     size = lstrlenW(module_name)/2;
1770     lstrcpyW(buf, deviceW);
1771     SetLastError(0xdeadbeef);
1772     expect_eq_d(FALSE, pQueryFullProcessImageNameW(hSelf, 0, buf, &size));
1773     expect_eq_d(lstrlenW(module_name)/2, size);  /* size not changed(!) */
1774     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1775     expect_eq_ws_i(deviceW, buf);  /* buffer not changed */
1776
1777     /* Too small - not space for NUL terminator */
1778     size = lstrlenW(module_name);
1779     SetLastError(0xdeadbeef);
1780     expect_eq_d(FALSE, pQueryFullProcessImageNameW(hSelf, 0, buf, &size));
1781     expect_eq_d(lstrlenW(module_name), size);  /* size not changed(!) */
1782     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1783
1784     /* NULL buffer */
1785     size = 0;
1786     expect_eq_d(FALSE, pQueryFullProcessImageNameW(hSelf, 0, NULL, &size));
1787     expect_eq_d(0, size);
1788     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1789
1790     /* Buffer too small */
1791     size = lstrlenW(module_name)/2;
1792     SetLastError(0xdeadbeef);
1793     lstrcpyW(buf, module_name);
1794     expect_eq_d(FALSE, pQueryFullProcessImageNameW(hSelf, 0, buf, &size));
1795     expect_eq_d(lstrlenW(module_name)/2, size);  /* size not changed(!) */
1796     expect_eq_d(ERROR_INSUFFICIENT_BUFFER, GetLastError());
1797     expect_eq_ws_i(module_name, buf);  /* buffer not changed */
1798
1799
1800     /* native path */
1801     size = sizeof(buf) / sizeof(buf[0]);
1802     expect_eq_d(TRUE, pQueryFullProcessImageNameW(hSelf, PROCESS_NAME_NATIVE, buf, &size));
1803     expect_eq_d(lstrlenW(buf), size);
1804     ok(buf[0] == '\\', "NT path should begin with '\\'\n");
1805     ok(memcmp(buf, deviceW, sizeof(WCHAR)*lstrlenW(deviceW)) == 0, "NT path should begin with \\Device\n");
1806
1807     module_name[2] = '\0';
1808     *device = '\0';
1809     size = QueryDosDeviceW(module_name, device, sizeof(device)/sizeof(device[0]));
1810     ok(size, "QueryDosDeviceW failed: le=%u\n", GetLastError());
1811     len = lstrlenW(device);
1812     ok(size >= len+2, "expected %d to be greater than %d+2 = strlen(%s)\n", size, len, wine_dbgstr_w(device));
1813
1814     if (size >= lstrlenW(buf))
1815     {
1816         ok(0, "expected %s\\ to match the start of %s\n", wine_dbgstr_w(device), wine_dbgstr_w(buf));
1817     }
1818     else
1819     {
1820         ok(buf[len] == '\\', "expected '%c' to be a '\\' in %s\n", buf[len], wine_dbgstr_w(module_name));
1821         buf[len] = '\0';
1822         ok(lstrcmpiW(device, buf) == 0, "expected %s to match %s\n", wine_dbgstr_w(device), wine_dbgstr_w(buf));
1823         ok(lstrcmpiW(module_name+3, buf+len+1) == 0, "expected '%s' to match '%s'\n", wine_dbgstr_w(module_name+3), wine_dbgstr_w(buf+len+1));
1824     }
1825
1826     CloseHandle(hSelf);
1827 }
1828
1829 static void test_Handles(void)
1830 {
1831     HANDLE handle = GetCurrentProcess();
1832     HANDLE h2, h3;
1833     BOOL ret;
1834     DWORD code;
1835
1836     ok( handle == (HANDLE)~(ULONG_PTR)0 ||
1837         handle == (HANDLE)(ULONG_PTR)0x7fffffff /* win9x */,
1838         "invalid current process handle %p\n", handle );
1839     ret = GetExitCodeProcess( handle, &code );
1840     ok( ret, "GetExitCodeProcess failed err %u\n", GetLastError() );
1841 #ifdef _WIN64
1842     /* truncated handle */
1843     SetLastError( 0xdeadbeef );
1844     handle = (HANDLE)((ULONG_PTR)handle & ~0u);
1845     ret = GetExitCodeProcess( handle, &code );
1846     ok( !ret, "GetExitCodeProcess succeeded for %p\n", handle );
1847     ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
1848     /* sign-extended handle */
1849     SetLastError( 0xdeadbeef );
1850     handle = (HANDLE)((LONG_PTR)(int)(ULONG_PTR)handle);
1851     ret = GetExitCodeProcess( handle, &code );
1852     ok( ret, "GetExitCodeProcess failed err %u\n", GetLastError() );
1853     /* invalid high-word */
1854     SetLastError( 0xdeadbeef );
1855     handle = (HANDLE)(((ULONG_PTR)handle & ~0u) + ((ULONG_PTR)1 << 32));
1856     ret = GetExitCodeProcess( handle, &code );
1857     ok( !ret, "GetExitCodeProcess succeeded for %p\n", handle );
1858     ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
1859 #endif
1860
1861     handle = GetStdHandle( STD_ERROR_HANDLE );
1862     ok( handle != 0, "handle %p\n", handle );
1863     DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(), &h3,
1864                      0, TRUE, DUPLICATE_SAME_ACCESS );
1865     SetStdHandle( STD_ERROR_HANDLE, h3 );
1866     CloseHandle( (HANDLE)STD_ERROR_HANDLE );
1867     h2 = GetStdHandle( STD_ERROR_HANDLE );
1868     ok( h2 == 0 ||
1869         broken( h2 == h3) || /* nt4, w2k */
1870         broken( h2 == INVALID_HANDLE_VALUE),  /* win9x */
1871         "wrong handle %p/%p\n", h2, h3 );
1872     SetStdHandle( STD_ERROR_HANDLE, handle );
1873 }
1874
1875 static void test_SystemInfo(void)
1876 {
1877     SYSTEM_INFO si, nsi;
1878     BOOL is_wow64;
1879
1880     if (!pGetNativeSystemInfo)
1881     {
1882         win_skip("GetNativeSystemInfo is not available\n");
1883         return;
1884     }
1885
1886     if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
1887
1888     GetSystemInfo(&si);
1889     pGetNativeSystemInfo(&nsi);
1890     if (is_wow64)
1891     {
1892         if (S(U(si)).wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
1893         {
1894             ok(S(U(nsi)).wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64,
1895                "Expected PROCESSOR_ARCHITECTURE_AMD64, got %d\n",
1896                S(U(nsi)).wProcessorArchitecture);
1897             ok(nsi.dwProcessorType == PROCESSOR_AMD_X8664,
1898                "Expected PROCESSOR_AMD_X8664, got %d\n",
1899                nsi.dwProcessorType);
1900         }
1901     }
1902     else
1903     {
1904         ok(S(U(si)).wProcessorArchitecture == S(U(nsi)).wProcessorArchitecture,
1905            "Expected no difference for wProcessorArchitecture, got %d and %d\n",
1906            S(U(si)).wProcessorArchitecture, S(U(nsi)).wProcessorArchitecture);
1907         ok(si.dwProcessorType == nsi.dwProcessorType,
1908            "Expected no difference for dwProcessorType, got %d and %d\n",
1909            si.dwProcessorType, nsi.dwProcessorType);
1910     }
1911 }
1912
1913 static void test_RegistryQuota(void)
1914 {
1915     BOOL ret;
1916     DWORD max_quota, used_quota;
1917
1918     if (!pGetSystemRegistryQuota)
1919     {
1920         win_skip("GetSystemRegistryQuota is not available\n");
1921         return;
1922     }
1923
1924     ret = pGetSystemRegistryQuota(NULL, NULL);
1925     ok(ret == TRUE,
1926        "Expected GetSystemRegistryQuota to return TRUE, got %d\n", ret);
1927
1928     ret = pGetSystemRegistryQuota(&max_quota, NULL);
1929     ok(ret == TRUE,
1930        "Expected GetSystemRegistryQuota to return TRUE, got %d\n", ret);
1931
1932     ret = pGetSystemRegistryQuota(NULL, &used_quota);
1933     ok(ret == TRUE,
1934        "Expected GetSystemRegistryQuota to return TRUE, got %d\n", ret);
1935
1936     ret = pGetSystemRegistryQuota(&max_quota, &used_quota);
1937     ok(ret == TRUE,
1938        "Expected GetSystemRegistryQuota to return TRUE, got %d\n", ret);
1939 }
1940
1941 START_TEST(process)
1942 {
1943     int b = init();
1944     ok(b, "Basic init of CreateProcess test\n");
1945     if (!b) return;
1946
1947     if (myARGC >= 3)
1948     {
1949         doChild(myARGV[2], (myARGC == 3) ? NULL : myARGV[3]);
1950         return;
1951     }
1952     test_Startup();
1953     test_CommandLine();
1954     test_Directory();
1955     test_Environment();
1956     test_SuspendFlag();
1957     test_DebuggingFlag();
1958     test_Console();
1959     test_ExitCode();
1960     test_OpenProcess();
1961     test_GetProcessVersion();
1962     test_GetProcessImageFileNameA();
1963     test_QueryFullProcessImageNameA();
1964     test_QueryFullProcessImageNameW();
1965     test_Handles();
1966     test_SystemInfo();
1967     test_RegistryQuota();
1968     /* things that can be tested:
1969      *  lookup:         check the way program to be executed is searched
1970      *  handles:        check the handle inheritance stuff (+sec options)
1971      *  console:        check if console creation parameters work
1972      */
1973 }