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