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