8aadf2a6e5f3b99e2a155d2ec6b68abdc448c4a6
[reactos.git] / rostests / winetests / kernel32 / 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 }