?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32/tests: Add a missing newline.
[wine/hacks.git] / dlls / kernel32 / tests / process.c
blob321053f731676f3bad9eae8b2ba8c53b7ca39760
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 SetLastError(0xdeadbeef);
352 ret = SetConsoleCP(1252);
353 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
354 {
355 win_skip("Setting the codepage is not implemented");
356 }
357 else
358 {
359 ok(ret, "Setting CP\n");
360 ok(SetConsoleOutputCP(1252), "Setting SB CP\n");
361 }
362
363 ret = SetConsoleMode(hConIn, modeIn ^ 1);
364 ok( ret, "Setting mode (%d)\n", GetLastError());
365 ret = SetConsoleMode(hConOut, modeOut ^ 1);
366 ok( ret, "Setting mode (%d)\n", GetLastError());
367 sbi.dwCursorPosition.X ^= 1;
368 sbi.dwCursorPosition.Y ^= 1;
369 ret = SetConsoleCursorPosition(hConOut, sbi.dwCursorPosition);
370 ok( ret, "Setting cursor position (%d)\n", GetLastError());
371 }
372 if (option && strcmp(option, "stdhandle") == 0)
373 {
374 HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
375 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
376
377 if (hStdIn != INVALID_HANDLE_VALUE || hStdOut != INVALID_HANDLE_VALUE)
378 {
379 char buf[1024];
380 DWORD r, w;
381
382 ok(ReadFile(hStdIn, buf, sizeof(buf), &r, NULL) && r > 0, "Reading message from input pipe\n");
383 childPrintf(hFile, "[StdHandle]\nmsg=%s\n\n", encodeA(buf));
384 ok(WriteFile(hStdOut, buf, r, &w, NULL) && w == r, "Writing message to output pipe\n");
385 }
386 }
387
388 if (option && strcmp(option, "exit_code") == 0)
389 {
390 childPrintf(hFile, "[ExitCode]\nvalue=%d\n\n", 123);
391 CloseHandle(hFile);
392 ExitProcess(123);
393 }
394
395 CloseHandle(hFile);
396 }
397
398 static char* getChildString(const char* sect, const char* key)
399 {
400 char buf[1024+4*MAX_LISTED_ENV_VAR];
401 char* ret;
402
403 GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), resfile);
404 if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
405 assert(!(strlen(buf) & 1));
406 ret = decodeA(buf);
407 return ret;
408 }
409
410 /* FIXME: this may be moved to the wtmain.c file, because it may be needed by
411 * others... (windows uses stricmp while Un*x uses strcasecmp...)
412 */
413 static int wtstrcasecmp(const char* p1, const char* p2)
414 {
415 char c1, c2;
416
417 c1 = c2 = '@';
418 while (c1 == c2 && c1)
419 {
420 c1 = *p1++; c2 = *p2++;
421 if (c1 != c2)
422 {
423 c1 = toupper(c1); c2 = toupper(c2);
424 }
425 }
426 return c1 - c2;
427 }
428
429 static int strCmp(const char* s1, const char* s2, BOOL sensitive)
430 {
431 if (!s1 && !s2) return 0;
432 if (!s2) return -1;
433 if (!s1) return 1;
434 return (sensitive) ? strcmp(s1, s2) : wtstrcasecmp(s1, s2);
435 }
436
437 static void ok_child_string( int line, const char *sect, const char *key,
438 const char *expect, int sensitive )
439 {
440 char* result = getChildString( sect, key );
441 ok_(__FILE__, line)( strCmp(result, expect, sensitive) == 0, "%s:%s expected '%s', got '%s'\n",
442 sect, key, expect ? expect : "(null)", result );
443 }
444
445 #define okChildString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 1 )
446 #define okChildIString(sect, key, expect) ok_child_string(__LINE__, (sect), (key), (expect), 0 )
447
448 /* using !expect ensures that the test will fail if the sect/key isn't present
449 * in result file
450 */
451 #define okChildInt(sect, key, expect) \
452 do { \
453 UINT result = GetPrivateProfileIntA((sect), (key), !(expect), resfile); \
454 ok(result == expect, "%s:%s expected %d, but got %d\n", (sect), (key), (int)(expect), result); \
455 } while (0)
456
457 static void test_Startup(void)
458 {
459 char buffer[MAX_PATH];
460 PROCESS_INFORMATION info;
461 STARTUPINFOA startup,si;
462 static CHAR title[] = "I'm the title string",
463 desktop[] = "I'm the desktop string",
464 empty[] = "";
465
466 /* let's start simplistic */
467 memset(&startup, 0, sizeof(startup));
468 startup.cb = sizeof(startup);
469 startup.dwFlags = STARTF_USESHOWWINDOW;
470 startup.wShowWindow = SW_SHOWNORMAL;
471
472 get_file_name(resfile);
473 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
474 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
475 /* wait for child to terminate */
476 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
477 /* child process has changed result file, so let profile functions know about it */
478 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
479
480 GetStartupInfoA(&si);
481 okChildInt("StartupInfoA", "cb", startup.cb);
482 okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
483 okChildInt("StartupInfoA", "dwX", startup.dwX);
484 okChildInt("StartupInfoA", "dwY", startup.dwY);
485 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
486 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
487 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
488 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
489 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
490 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
491 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
492 release_memory();
493 assert(DeleteFileA(resfile) != 0);
494
495 /* not so simplistic now */
496 memset(&startup, 0, sizeof(startup));
497 startup.cb = sizeof(startup);
498 startup.dwFlags = STARTF_USESHOWWINDOW;
499 startup.wShowWindow = SW_SHOWNORMAL;
500 startup.lpTitle = title;
501 startup.lpDesktop = desktop;
502 startup.dwXCountChars = 0x12121212;
503 startup.dwYCountChars = 0x23232323;
504 startup.dwX = 0x34343434;
505 startup.dwY = 0x45454545;
506 startup.dwXSize = 0x56565656;
507 startup.dwYSize = 0x67676767;
508 startup.dwFillAttribute = 0xA55A;
509
510 get_file_name(resfile);
511 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
512 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
513 /* wait for child to terminate */
514 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
515 /* child process has changed result file, so let profile functions know about it */
516 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
517
518 okChildInt("StartupInfoA", "cb", startup.cb);
519 okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
520 okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
521 okChildInt("StartupInfoA", "dwX", startup.dwX);
522 okChildInt("StartupInfoA", "dwY", startup.dwY);
523 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
524 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
525 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
526 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
527 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
528 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
529 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
530 release_memory();
531 assert(DeleteFileA(resfile) != 0);
532
533 /* not so simplistic now */
534 memset(&startup, 0, sizeof(startup));
535 startup.cb = sizeof(startup);
536 startup.dwFlags = STARTF_USESHOWWINDOW;
537 startup.wShowWindow = SW_SHOWNORMAL;
538 startup.lpTitle = title;
539 startup.lpDesktop = NULL;
540 startup.dwXCountChars = 0x12121212;
541 startup.dwYCountChars = 0x23232323;
542 startup.dwX = 0x34343434;
543 startup.dwY = 0x45454545;
544 startup.dwXSize = 0x56565656;
545 startup.dwYSize = 0x67676767;
546 startup.dwFillAttribute = 0xA55A;
547
548 get_file_name(resfile);
549 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
550 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
551 /* wait for child to terminate */
552 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
553 /* child process has changed result file, so let profile functions know about it */
554 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
555
556 okChildInt("StartupInfoA", "cb", startup.cb);
557 okChildString("StartupInfoA", "lpDesktop", si.lpDesktop);
558 okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
559 okChildInt("StartupInfoA", "dwX", startup.dwX);
560 okChildInt("StartupInfoA", "dwY", startup.dwY);
561 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
562 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
563 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
564 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
565 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
566 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
567 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
568 release_memory();
569 assert(DeleteFileA(resfile) != 0);
570
571 /* not so simplistic now */
572 memset(&startup, 0, sizeof(startup));
573 startup.cb = sizeof(startup);
574 startup.dwFlags = STARTF_USESHOWWINDOW;
575 startup.wShowWindow = SW_SHOWNORMAL;
576 startup.lpTitle = title;
577 startup.lpDesktop = empty;
578 startup.dwXCountChars = 0x12121212;
579 startup.dwYCountChars = 0x23232323;
580 startup.dwX = 0x34343434;
581 startup.dwY = 0x45454545;
582 startup.dwXSize = 0x56565656;
583 startup.dwYSize = 0x67676767;
584 startup.dwFillAttribute = 0xA55A;
585
586 get_file_name(resfile);
587 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
588 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
589 /* wait for child to terminate */
590 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
591 /* child process has changed result file, so let profile functions know about it */
592 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
593
594 okChildInt("StartupInfoA", "cb", startup.cb);
595 todo_wine okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
596 okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
597 okChildInt("StartupInfoA", "dwX", startup.dwX);
598 okChildInt("StartupInfoA", "dwY", startup.dwY);
599 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
600 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
601 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
602 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
603 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
604 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
605 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
606 release_memory();
607 assert(DeleteFileA(resfile) != 0);
608
609 /* not so simplistic now */
610 memset(&startup, 0, sizeof(startup));
611 startup.cb = sizeof(startup);
612 startup.dwFlags = STARTF_USESHOWWINDOW;
613 startup.wShowWindow = SW_SHOWNORMAL;
614 startup.lpTitle = NULL;
615 startup.lpDesktop = desktop;
616 startup.dwXCountChars = 0x12121212;
617 startup.dwYCountChars = 0x23232323;
618 startup.dwX = 0x34343434;
619 startup.dwY = 0x45454545;
620 startup.dwXSize = 0x56565656;
621 startup.dwYSize = 0x67676767;
622 startup.dwFillAttribute = 0xA55A;
623
624 get_file_name(resfile);
625 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
626 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
627 /* wait for child to terminate */
628 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
629 /* child process has changed result file, so let profile functions know about it */
630 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
631
632 okChildInt("StartupInfoA", "cb", startup.cb);
633 okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
634 ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
635 "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
636 okChildInt("StartupInfoA", "dwX", startup.dwX);
637 okChildInt("StartupInfoA", "dwY", startup.dwY);
638 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
639 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
640 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
641 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
642 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
643 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
644 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
645 release_memory();
646 assert(DeleteFileA(resfile) != 0);
647
648 /* not so simplistic now */
649 memset(&startup, 0, sizeof(startup));
650 startup.cb = sizeof(startup);
651 startup.dwFlags = STARTF_USESHOWWINDOW;
652 startup.wShowWindow = SW_SHOWNORMAL;
653 startup.lpTitle = empty;
654 startup.lpDesktop = desktop;
655 startup.dwXCountChars = 0x12121212;
656 startup.dwYCountChars = 0x23232323;
657 startup.dwX = 0x34343434;
658 startup.dwY = 0x45454545;
659 startup.dwXSize = 0x56565656;
660 startup.dwYSize = 0x67676767;
661 startup.dwFillAttribute = 0xA55A;
662
663 get_file_name(resfile);
664 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
665 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
666 /* wait for child to terminate */
667 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
668 /* child process has changed result file, so let profile functions know about it */
669 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
670
671 okChildInt("StartupInfoA", "cb", startup.cb);
672 okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
673 todo_wine okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
674 okChildInt("StartupInfoA", "dwX", startup.dwX);
675 okChildInt("StartupInfoA", "dwY", startup.dwY);
676 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
677 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
678 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
679 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
680 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
681 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
682 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
683 release_memory();
684 assert(DeleteFileA(resfile) != 0);
685
686 /* not so simplistic now */
687 memset(&startup, 0, sizeof(startup));
688 startup.cb = sizeof(startup);
689 startup.dwFlags = STARTF_USESHOWWINDOW;
690 startup.wShowWindow = SW_SHOWNORMAL;
691 startup.lpTitle = empty;
692 startup.lpDesktop = empty;
693 startup.dwXCountChars = 0x12121212;
694 startup.dwYCountChars = 0x23232323;
695 startup.dwX = 0x34343434;
696 startup.dwY = 0x45454545;
697 startup.dwXSize = 0x56565656;
698 startup.dwYSize = 0x67676767;
699 startup.dwFillAttribute = 0xA55A;
700
701 get_file_name(resfile);
702 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
703 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
704 /* wait for child to terminate */
705 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
706 /* child process has changed result file, so let profile functions know about it */
707 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
708
709 okChildInt("StartupInfoA", "cb", startup.cb);
710 todo_wine okChildString("StartupInfoA", "lpDesktop", startup.lpDesktop);
711 todo_wine okChildString("StartupInfoA", "lpTitle", startup.lpTitle);
712 okChildInt("StartupInfoA", "dwX", startup.dwX);
713 okChildInt("StartupInfoA", "dwY", startup.dwY);
714 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
715 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
716 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
717 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
718 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
719 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
720 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
721 release_memory();
722 assert(DeleteFileA(resfile) != 0);
723
724 /* TODO: test for A/W and W/A and W/W */
725 }
726
727 static void test_CommandLine(void)
728 {
729 char buffer[MAX_PATH], fullpath[MAX_PATH], *lpFilePart, *p;
730 PROCESS_INFORMATION info;
731 STARTUPINFOA startup;
732 DWORD len;
733 BOOL ret;
734
735 memset(&startup, 0, sizeof(startup));
736 startup.cb = sizeof(startup);
737 startup.dwFlags = STARTF_USESHOWWINDOW;
738 startup.wShowWindow = SW_SHOWNORMAL;
739
740 /* the basics */
741 get_file_name(resfile);
742 sprintf(buffer, "%s tests/process.c %s \"C:\\Program Files\\my nice app.exe\"", selfname, resfile);
743 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
744 /* wait for child to terminate */
745 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
746 /* child process has changed result file, so let profile functions know about it */
747 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
748
749 okChildInt("Arguments", "argcA", 4);
750 okChildString("Arguments", "argvA3", "C:\\Program Files\\my nice app.exe");
751 okChildString("Arguments", "argvA4", NULL);
752 okChildString("Arguments", "CommandLineA", buffer);
753 release_memory();
754 assert(DeleteFileA(resfile) != 0);
755
756 memset(&startup, 0, sizeof(startup));
757 startup.cb = sizeof(startup);
758 startup.dwFlags = STARTF_USESHOWWINDOW;
759 startup.wShowWindow = SW_SHOWNORMAL;
760
761 /* from Frangois */
762 get_file_name(resfile);
763 sprintf(buffer, "%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", selfname, resfile);
764 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
765 /* wait for child to terminate */
766 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
767 /* child process has changed result file, so let profile functions know about it */
768 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
769
770 okChildInt("Arguments", "argcA", 6);
771 okChildString("Arguments", "argvA3", "a\"b\\");
772 okChildString("Arguments", "argvA4", "c\"");
773 okChildString("Arguments", "argvA5", "d");
774 okChildString("Arguments", "argvA6", NULL);
775 okChildString("Arguments", "CommandLineA", buffer);
776 release_memory();
777 assert(DeleteFileA(resfile) != 0);
778
779 /* Test for Bug1330 to show that XP doesn't change '/' to '\\' in argv[0]*/
780 get_file_name(resfile);
781 /* Use exename to avoid buffer containing things like 'C:' */
782 sprintf(buffer, "./%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", exename, resfile);
783 SetLastError(0xdeadbeef);
784 ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
785 ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
786 /* wait for child to terminate */
787 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
788 /* child process has changed result file, so let profile functions know about it */
789 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
790 sprintf(buffer, "./%s", exename);
791 okChildString("Arguments", "argvA0", buffer);
792 release_memory();
793 assert(DeleteFileA(resfile) != 0);
794
795 get_file_name(resfile);
796 /* Use exename to avoid buffer containing things like 'C:' */
797 sprintf(buffer, ".\\%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", exename, resfile);
798 SetLastError(0xdeadbeef);
799 ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
800 ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
801 /* wait for child to terminate */
802 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
803 /* child process has changed result file, so let profile functions know about it */
804 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
805 sprintf(buffer, ".\\%s", exename);
806 okChildString("Arguments", "argvA0", buffer);
807 release_memory();
808 assert(DeleteFileA(resfile) != 0);
809
810 get_file_name(resfile);
811 len = GetFullPathNameA(selfname, MAX_PATH, fullpath, &lpFilePart);
812 assert ( lpFilePart != 0);
813 *(lpFilePart -1 ) = 0;
814 p = strrchr(fullpath, '\\');
815 assert (p);
816 /* Use exename to avoid buffer containing things like 'C:' */
817 sprintf(buffer, "..%s/%s tests/process.c %s \"a\\\"b\\\\\" c\\\" d", p, exename, resfile);
818 SetLastError(0xdeadbeef);
819 ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info);
820 ok(ret, "CreateProcess (%s) failed : %d\n", buffer, GetLastError());
821 /* wait for child to terminate */
822 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
823 /* child process has changed result file, so let profile functions know about it */
824 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
825 sprintf(buffer, "..%s/%s", p, exename);
826 okChildString("Arguments", "argvA0", buffer);
827 release_memory();
828 assert(DeleteFileA(resfile) != 0);
829
830 }
831
832 static void test_Directory(void)
833 {
834 char buffer[MAX_PATH];
835 PROCESS_INFORMATION info;
836 STARTUPINFOA startup;
837 char windir[MAX_PATH];
838 static CHAR cmdline[] = "winver.exe";
839
840 memset(&startup, 0, sizeof(startup));
841 startup.cb = sizeof(startup);
842 startup.dwFlags = STARTF_USESHOWWINDOW;
843 startup.wShowWindow = SW_SHOWNORMAL;
844
845 /* the basics */
846 get_file_name(resfile);
847 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
848 GetWindowsDirectoryA( windir, sizeof(windir) );
849 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, windir, &startup, &info), "CreateProcess\n");
850 /* wait for child to terminate */
851 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
852 /* child process has changed result file, so let profile functions know about it */
853 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
854
855 okChildIString("Misc", "CurrDirA", windir);
856 release_memory();
857 assert(DeleteFileA(resfile) != 0);
858
859 /* search PATH for the exe if directory is NULL */
860 ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
861 ok(TerminateProcess(info.hProcess, 0), "Child process termination\n");
862
863 /* if any directory is provided, don't search PATH, error on bad directory */
864 SetLastError(0xdeadbeef);
865 memset(&info, 0, sizeof(info));
866 ok(!CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L,
867 NULL, "non\\existent\\directory", &startup, &info), "CreateProcess\n");
868 ok(GetLastError() == ERROR_DIRECTORY, "Expected ERROR_DIRECTORY, got %d\n", GetLastError());
869 ok(!TerminateProcess(info.hProcess, 0), "Child process should not exist\n");
870 }
871
872 static BOOL is_str_env_drive_dir(const char* str)
873 {
874 return str[0] == '=' && str[1] >= 'A' && str[1] <= 'Z' && str[2] == ':' &&
875 str[3] == '=' && str[4] == str[1];
876 }
877
878 /* compared expected child's environment (in gesA) from actual
879 * environment our child got
880 */
881 static void cmpEnvironment(const char* gesA)
882 {
883 int i, clen;
884 const char* ptrA;
885 char* res;
886 char key[32];
887 BOOL found;
888
889 clen = GetPrivateProfileIntA("EnvironmentA", "len", 0, resfile);
890
891 /* now look each parent env in child */
892 if ((ptrA = gesA) != NULL)
893 {
894 while (*ptrA)
895 {
896 for (i = 0; i < clen; i++)
897 {
898 sprintf(key, "env%d", i);
899 res = getChildString("EnvironmentA", key);
900 if (strncmp(ptrA, res, MAX_LISTED_ENV_VAR - 1) == 0)
901 break;
902 }
903 found = i < clen;
904 ok(found, "Parent-env string %s isn't in child process\n", ptrA);
905
906 ptrA += strlen(ptrA) + 1;
907 release_memory();
908 }
909 }
910 /* and each child env in parent */
911 for (i = 0; i < clen; i++)
912 {
913 sprintf(key, "env%d", i);
914 res = getChildString("EnvironmentA", key);
915 if ((ptrA = gesA) != NULL)
916 {
917 while (*ptrA)
918 {
919 if (strncmp(res, ptrA, MAX_LISTED_ENV_VAR - 1) == 0)
920 break;
921 ptrA += strlen(ptrA) + 1;
922 }
923 if (!*ptrA) ptrA = NULL;
924 }
925
926 if (!is_str_env_drive_dir(res))
927 {
928 found = ptrA != NULL;
929 ok(found, "Child-env string %s isn't in parent process\n", res);
930 }
931 /* else => should also test we get the right per drive default directory here... */
932 }
933 }
934
935 static void test_Environment(void)
936 {
937 char buffer[MAX_PATH];
938 PROCESS_INFORMATION info;
939 STARTUPINFOA startup;
940 char* child_env;
941 int child_env_len;
942 char* ptr;
943 char* env;
944 int slen;
945
946 memset(&startup, 0, sizeof(startup));
947 startup.cb = sizeof(startup);
948 startup.dwFlags = STARTF_USESHOWWINDOW;
949 startup.wShowWindow = SW_SHOWNORMAL;
950
951 /* the basics */
952 get_file_name(resfile);
953 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
954 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
955 /* wait for child to terminate */
956 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
957 /* child process has changed result file, so let profile functions know about it */
958 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
959
960 cmpEnvironment(GetEnvironmentStringsA());
961 release_memory();
962 assert(DeleteFileA(resfile) != 0);
963
964 memset(&startup, 0, sizeof(startup));
965 startup.cb = sizeof(startup);
966 startup.dwFlags = STARTF_USESHOWWINDOW;
967 startup.wShowWindow = SW_SHOWNORMAL;
968
969 /* the basics */
970 get_file_name(resfile);
971 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
972
973 child_env_len = 0;
974 ptr = GetEnvironmentStringsA();
975 while(*ptr)
976 {
977 slen = strlen(ptr)+1;
978 child_env_len += slen;
979 ptr += slen;
980 }
981 /* Add space for additional environment variables */
982 child_env_len += 256;
983 child_env = HeapAlloc(GetProcessHeap(), 0, child_env_len);
984
985 ptr = child_env;
986 sprintf(ptr, "=%c:=%s", 'C', "C:\\FOO\\BAR");
987 ptr += strlen(ptr) + 1;
988 strcpy(ptr, "PATH=C:\\WINDOWS;C:\\WINDOWS\\SYSTEM;C:\\MY\\OWN\\DIR");
989 ptr += strlen(ptr) + 1;
990 strcpy(ptr, "FOO=BAR");
991 ptr += strlen(ptr) + 1;
992 strcpy(ptr, "BAR=FOOBAR");
993 ptr += strlen(ptr) + 1;
994 /* copy all existing variables except:
995 * - WINELOADER
996 * - PATH (already set above)
997 * - the directory definitions (=[A-Z]:=)
998 */
999 for (env = GetEnvironmentStringsA(); *env; env += strlen(env) + 1)
1000 {
1001 if (strncmp(env, "PATH=", 5) != 0 &&
1002 strncmp(env, "WINELOADER=", 11) != 0 &&
1003 !is_str_env_drive_dir(env))
1004 {
1005 strcpy(ptr, env);
1006 ptr += strlen(ptr) + 1;
1007 }
1008 }
1009 *ptr = '\0';
1010 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0L, child_env, NULL, &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 cmpEnvironment(child_env);
1017
1018 HeapFree(GetProcessHeap(), 0, child_env);
1019 release_memory();
1020 assert(DeleteFileA(resfile) != 0);
1021 }
1022
1023 static void test_SuspendFlag(void)
1024 {
1025 char buffer[MAX_PATH];
1026 PROCESS_INFORMATION info;
1027 STARTUPINFOA startup, us;
1028 DWORD exit_status;
1029
1030 /* let's start simplistic */
1031 memset(&startup, 0, sizeof(startup));
1032 startup.cb = sizeof(startup);
1033 startup.dwFlags = STARTF_USESHOWWINDOW;
1034 startup.wShowWindow = SW_SHOWNORMAL;
1035
1036 get_file_name(resfile);
1037 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1038 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &startup, &info), "CreateProcess\n");
1039
1040 ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1041 Sleep(8000);
1042 ok(GetExitCodeThread(info.hThread, &exit_status) && exit_status == STILL_ACTIVE, "thread still running\n");
1043 ok(ResumeThread(info.hThread) == 1, "Resuming thread\n");
1044
1045 /* wait for child to terminate */
1046 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1047 /* child process has changed result file, so let profile functions know about it */
1048 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1049
1050 GetStartupInfoA(&us);
1051
1052 okChildInt("StartupInfoA", "cb", startup.cb);
1053 okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1054 ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1055 "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1056 okChildInt("StartupInfoA", "dwX", startup.dwX);
1057 okChildInt("StartupInfoA", "dwY", startup.dwY);
1058 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1059 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1060 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1061 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1062 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1063 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1064 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1065 release_memory();
1066 assert(DeleteFileA(resfile) != 0);
1067 }
1068
1069 static void test_DebuggingFlag(void)
1070 {
1071 char buffer[MAX_PATH];
1072 PROCESS_INFORMATION info;
1073 STARTUPINFOA startup, us;
1074 DEBUG_EVENT de;
1075 unsigned dbg = 0;
1076
1077 /* let's start simplistic */
1078 memset(&startup, 0, sizeof(startup));
1079 startup.cb = sizeof(startup);
1080 startup.dwFlags = STARTF_USESHOWWINDOW;
1081 startup.wShowWindow = SW_SHOWNORMAL;
1082
1083 get_file_name(resfile);
1084 sprintf(buffer, "%s tests/process.c %s", selfname, resfile);
1085 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1086
1087 /* get all startup events up to the entry point break exception */
1088 do
1089 {
1090 ok(WaitForDebugEvent(&de, INFINITE), "reading debug event\n");
1091 ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
1092 if (de.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) dbg++;
1093 } while (de.dwDebugEventCode != EXIT_PROCESS_DEBUG_EVENT);
1094
1095 ok(dbg, "I have seen a debug event\n");
1096 /* wait for child to terminate */
1097 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1098 /* child process has changed result file, so let profile functions know about it */
1099 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1100
1101 GetStartupInfoA(&us);
1102
1103 okChildInt("StartupInfoA", "cb", startup.cb);
1104 okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1105 ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1106 "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1107 okChildInt("StartupInfoA", "dwX", startup.dwX);
1108 okChildInt("StartupInfoA", "dwY", startup.dwY);
1109 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1110 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1111 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1112 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1113 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1114 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1115 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1116 release_memory();
1117 assert(DeleteFileA(resfile) != 0);
1118 }
1119
1120 static BOOL is_console(HANDLE h)
1121 {
1122 return h != INVALID_HANDLE_VALUE && ((ULONG_PTR)h & 3) == 3;
1123 }
1124
1125 static void test_Console(void)
1126 {
1127 char buffer[MAX_PATH];
1128 PROCESS_INFORMATION info;
1129 STARTUPINFOA startup, us;
1130 SECURITY_ATTRIBUTES sa;
1131 CONSOLE_SCREEN_BUFFER_INFO sbi, sbiC;
1132 DWORD modeIn, modeOut, modeInC, modeOutC;
1133 DWORD cpIn, cpOut, cpInC, cpOutC;
1134 DWORD w;
1135 HANDLE hChildIn, hChildInInh, hChildOut, hChildOutInh, hParentIn, hParentOut;
1136 const char* msg = "This is a std-handle inheritance test.";
1137 unsigned msg_len;
1138 BOOL run_tests = TRUE;
1139
1140 memset(&startup, 0, sizeof(startup));
1141 startup.cb = sizeof(startup);
1142 startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1143 startup.wShowWindow = SW_SHOWNORMAL;
1144
1145 sa.nLength = sizeof(sa);
1146 sa.lpSecurityDescriptor = NULL;
1147 sa.bInheritHandle = TRUE;
1148
1149 startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1150 startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1151
1152 /* first, we need to be sure we're attached to a console */
1153 if (!is_console(startup.hStdInput) || !is_console(startup.hStdOutput))
1154 {
1155 /* we're not attached to a console, let's do it */
1156 AllocConsole();
1157 startup.hStdInput = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1158 startup.hStdOutput = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, &sa, OPEN_EXISTING, 0, 0);
1159 }
1160 /* now verify everything's ok */
1161 ok(startup.hStdInput != INVALID_HANDLE_VALUE, "Opening ConIn\n");
1162 ok(startup.hStdOutput != INVALID_HANDLE_VALUE, "Opening ConOut\n");
1163 startup.hStdError = startup.hStdOutput;
1164
1165 ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbi), "Getting sb info\n");
1166 ok(GetConsoleMode(startup.hStdInput, &modeIn) &&
1167 GetConsoleMode(startup.hStdOutput, &modeOut), "Getting console modes\n");
1168 cpIn = GetConsoleCP();
1169 cpOut = GetConsoleOutputCP();
1170
1171 get_file_name(resfile);
1172 sprintf(buffer, "%s tests/process.c %s console", selfname, resfile);
1173 ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1174
1175 /* wait for child to terminate */
1176 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1177 /* child process has changed result file, so let profile functions know about it */
1178 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1179
1180 /* now get the modification the child has made, and resets parents expected values */
1181 ok(GetConsoleScreenBufferInfo(startup.hStdOutput, &sbiC), "Getting sb info\n");
1182 ok(GetConsoleMode(startup.hStdInput, &modeInC) &&
1183 GetConsoleMode(startup.hStdOutput, &modeOutC), "Getting console modes\n");
1184
1185 SetConsoleMode(startup.hStdInput, modeIn);
1186 SetConsoleMode(startup.hStdOutput, modeOut);
1187
1188 cpInC = GetConsoleCP();
1189 cpOutC = GetConsoleOutputCP();
1190
1191 /* Try to set invalid CP */
1192 SetLastError(0xdeadbeef);
1193 ok(!SetConsoleCP(0), "Shouldn't succeed\n");
1194 ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1195 broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1196 "GetLastError: expecting %u got %u\n",
1197 ERROR_INVALID_PARAMETER, GetLastError());
1198 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1199 run_tests = FALSE;
1200
1201
1202 SetLastError(0xdeadbeef);
1203 ok(!SetConsoleOutputCP(0), "Shouldn't succeed\n");
1204 ok(GetLastError()==ERROR_INVALID_PARAMETER ||
1205 broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
1206 "GetLastError: expecting %u got %u\n",
1207 ERROR_INVALID_PARAMETER, GetLastError());
1208
1209 SetConsoleCP(cpIn);
1210 SetConsoleOutputCP(cpOut);
1211
1212 GetStartupInfoA(&us);
1213
1214 okChildInt("StartupInfoA", "cb", startup.cb);
1215 okChildString("StartupInfoA", "lpDesktop", us.lpDesktop);
1216 ok (startup.lpTitle == NULL || !strcmp(startup.lpTitle, selfname),
1217 "StartupInfoA:lpTitle expected '%s' or null, got '%s'\n", selfname, startup.lpTitle);
1218 okChildInt("StartupInfoA", "dwX", startup.dwX);
1219 okChildInt("StartupInfoA", "dwY", startup.dwY);
1220 okChildInt("StartupInfoA", "dwXSize", startup.dwXSize);
1221 okChildInt("StartupInfoA", "dwYSize", startup.dwYSize);
1222 okChildInt("StartupInfoA", "dwXCountChars", startup.dwXCountChars);
1223 okChildInt("StartupInfoA", "dwYCountChars", startup.dwYCountChars);
1224 okChildInt("StartupInfoA", "dwFillAttribute", startup.dwFillAttribute);
1225 okChildInt("StartupInfoA", "dwFlags", startup.dwFlags);
1226 okChildInt("StartupInfoA", "wShowWindow", startup.wShowWindow);
1227
1228 /* check child correctly inherited the console */
1229 okChildInt("StartupInfoA", "hStdInput", (DWORD)startup.hStdInput);
1230 okChildInt("StartupInfoA", "hStdOutput", (DWORD)startup.hStdOutput);
1231 okChildInt("StartupInfoA", "hStdError", (DWORD)startup.hStdError);
1232 okChildInt("Console", "SizeX", (DWORD)sbi.dwSize.X);
1233 okChildInt("Console", "SizeY", (DWORD)sbi.dwSize.Y);
1234 okChildInt("Console", "CursorX", (DWORD)sbi.dwCursorPosition.X);
1235 okChildInt("Console", "CursorY", (DWORD)sbi.dwCursorPosition.Y);
1236 okChildInt("Console", "Attributes", sbi.wAttributes);
1237 okChildInt("Console", "winLeft", (DWORD)sbi.srWindow.Left);
1238 okChildInt("Console", "winTop", (DWORD)sbi.srWindow.Top);
1239 okChildInt("Console", "winRight", (DWORD)sbi.srWindow.Right);
1240 okChildInt("Console", "winBottom", (DWORD)sbi.srWindow.Bottom);
1241 okChildInt("Console", "maxWinWidth", (DWORD)sbi.dwMaximumWindowSize.X);
1242 okChildInt("Console", "maxWinHeight", (DWORD)sbi.dwMaximumWindowSize.Y);
1243 okChildInt("Console", "InputCP", cpIn);
1244 okChildInt("Console", "OutputCP", cpOut);
1245 okChildInt("Console", "InputMode", modeIn);
1246 okChildInt("Console", "OutputMode", modeOut);
1247
1248 if (run_tests)
1249 {
1250 ok(cpInC == 1252, "Wrong console CP (expected 1252 got %d/%d)\n", cpInC, cpIn);
1251 ok(cpOutC == 1252, "Wrong console-SB CP (expected 1252 got %d/%d)\n", cpOutC, cpOut);
1252 }
1253 else
1254 win_skip("Setting the codepage is not implemented\n");
1255
1256 ok(modeInC == (modeIn ^ 1), "Wrong console mode\n");
1257 ok(modeOutC == (modeOut ^ 1), "Wrong console-SB mode\n");
1258 trace("cursor position(X): %d/%d\n",sbi.dwCursorPosition.X, sbiC.dwCursorPosition.X);
1259 ok(sbiC.dwCursorPosition.Y == (sbi.dwCursorPosition.Y ^ 1), "Wrong cursor position\n");
1260
1261 release_memory();
1262 assert(DeleteFileA(resfile) != 0);
1263
1264 ok(CreatePipe(&hParentIn, &hChildOut, NULL, 0), "Creating parent-input pipe\n");
1265 ok(DuplicateHandle(GetCurrentProcess(), hChildOut, GetCurrentProcess(),
1266 &hChildOutInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1267 "Duplicating as inheritable child-output pipe\n");
1268 CloseHandle(hChildOut);
1269
1270 ok(CreatePipe(&hChildIn, &hParentOut, NULL, 0), "Creating parent-output pipe\n");
1271 ok(DuplicateHandle(GetCurrentProcess(), hChildIn, GetCurrentProcess(),
1272 &hChildInInh, 0, TRUE, DUPLICATE_SAME_ACCESS),
1273 "Duplicating as inheritable child-input pipe\n");
1274 CloseHandle(hChildIn);
1275
1276 memset(&startup, 0, sizeof(startup));
1277 startup.cb = sizeof(startup);
1278 startup.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
1279 startup.wShowWindow = SW_SHOWNORMAL;
1280 startup.hStdInput = hChildInInh;
1281 startup.hStdOutput = hChildOutInh;
1282 startup.hStdError = hChildOutInh;
1283
1284 get_file_name(resfile);
1285 sprintf(buffer, "%s tests/process.c %s stdhandle", selfname, resfile);
1286 ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &startup, &info), "CreateProcess\n");
1287 ok(CloseHandle(hChildInInh), "Closing handle\n");
1288 ok(CloseHandle(hChildOutInh), "Closing handle\n");
1289
1290 msg_len = strlen(msg) + 1;
1291 ok(WriteFile(hParentOut, msg, msg_len, &w, NULL), "Writing to child\n");
1292 ok(w == msg_len, "Should have written %u bytes, actually wrote %u\n", msg_len, w);
1293 memset(buffer, 0, sizeof(buffer));
1294 ok(ReadFile(hParentIn, buffer, sizeof(buffer), &w, NULL), "Reading from child\n");
1295 ok(strcmp(buffer, msg) == 0, "Should have received '%s'\n", msg);
1296
1297 /* wait for child to terminate */
1298 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1299 /* child process has changed result file, so let profile functions know about it */
1300 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1301
1302 okChildString("StdHandle", "msg", msg);
1303
1304 release_memory();
1305 assert(DeleteFileA(resfile) != 0);
1306 }
1307
1308 static void test_ExitCode(void)
1309 {
1310 char buffer[MAX_PATH];
1311 PROCESS_INFORMATION info;
1312 STARTUPINFOA startup;
1313 DWORD code;
1314
1315 /* let's start simplistic */
1316 memset(&startup, 0, sizeof(startup));
1317 startup.cb = sizeof(startup);
1318 startup.dwFlags = STARTF_USESHOWWINDOW;
1319 startup.wShowWindow = SW_SHOWNORMAL;
1320
1321 get_file_name(resfile);
1322 sprintf(buffer, "%s tests/process.c %s exit_code", selfname, resfile);
1323 ok(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
1324
1325 /* wait for child to terminate */
1326 ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
1327 /* child process has changed result file, so let profile functions know about it */
1328 WritePrivateProfileStringA(NULL, NULL, NULL, resfile);
1329
1330 ok(GetExitCodeProcess(info.hProcess, &code), "Getting exit code\n");
1331 okChildInt("ExitCode", "value", code);
1332
1333 release_memory();
1334 assert(DeleteFileA(resfile) != 0);
1335 }
1336
1337 static void test_OpenProcess(void)
1338 {
1339 HANDLE hproc;
1340 void *addr1;
1341 MEMORY_BASIC_INFORMATION info;
1342 SIZE_T dummy, read_bytes;
1343
1344 /* not exported in all windows versions */
1345 if ((!pVirtualAllocEx) || (!pVirtualFreeEx)) {
1346 skip("VirtualAllocEx not found\n");
1347 return;
1348 }
1349
1350 /* without PROCESS_VM_OPERATION */
1351 hproc = OpenProcess(PROCESS_ALL_ACCESS & ~PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1352 ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1353
1354 SetLastError(0xdeadbeef);
1355 addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1356 ok(!addr1, "VirtualAllocEx should fail\n");
1357 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1358 { /* Win9x */
1359 CloseHandle(hproc);
1360 skip("VirtualAllocEx not implemented\n");
1361 return;
1362 }
1363 ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1364
1365 read_bytes = 0xdeadbeef;
1366 SetLastError(0xdeadbeef);
1367 ok(ReadProcessMemory(hproc, test_OpenProcess, &dummy, sizeof(dummy), &read_bytes),
1368 "ReadProcessMemory error %d\n", GetLastError());
1369 ok(read_bytes == sizeof(dummy), "wrong read bytes %ld\n", read_bytes);
1370
1371 CloseHandle(hproc);
1372
1373 hproc = OpenProcess(PROCESS_VM_OPERATION, FALSE, GetCurrentProcessId());
1374 ok(hproc != NULL, "OpenProcess error %d\n", GetLastError());
1375
1376 addr1 = pVirtualAllocEx(hproc, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
1377 ok(addr1 != NULL, "VirtualAllocEx error %d\n", GetLastError());
1378
1379 /* without PROCESS_QUERY_INFORMATION */
1380 SetLastError(0xdeadbeef);
1381 ok(!VirtualQueryEx(hproc, addr1, &info, sizeof(info)),
1382 "VirtualQueryEx without PROCESS_QUERY_INFORMATION rights should fail\n");
1383 ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1384
1385 /* without PROCESS_VM_READ */
1386 read_bytes = 0xdeadbeef;
1387 SetLastError(0xdeadbeef);
1388 ok(!ReadProcessMemory(hproc, addr1, &dummy, sizeof(dummy), &read_bytes),
1389 "ReadProcessMemory without PROCESS_VM_READ rights should fail\n");
1390 ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1391 ok(read_bytes == 0, "wrong read bytes %ld\n", read_bytes);
1392
1393 CloseHandle(hproc);
1394
1395 hproc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1396
1397 memset(&info, 0xcc, sizeof(info));
1398 ok(VirtualQueryEx(hproc, addr1, &info, sizeof(info)) == sizeof(info),
1399 "VirtualQueryEx error %d\n", GetLastError());
1400
1401 ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
1402 ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
1403 ok(info.AllocationProtect == PAGE_NOACCESS, "%x != PAGE_NOACCESS\n", info.AllocationProtect);
1404 ok(info.RegionSize == 0x10000, "%lx != 0x10000\n", info.RegionSize);
1405 ok(info.State == MEM_RESERVE, "%x != MEM_RESERVE\n", info.State);
1406 /* NT reports Protect == 0 for a not committed memory block */
1407 ok(info.Protect == 0 /* NT */ ||
1408 info.Protect == PAGE_NOACCESS, /* Win9x */
1409 "%x != PAGE_NOACCESS\n", info.Protect);
1410 ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
1411
1412 SetLastError(0xdeadbeef);
1413 ok(!pVirtualFreeEx(hproc, addr1, 0, MEM_RELEASE),
1414 "VirtualFreeEx without PROCESS_VM_OPERATION rights should fail\n");
1415 ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %d\n", GetLastError());
1416
1417 CloseHandle(hproc);
1418
1419 ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
1420 }
1421
1422 START_TEST(process)
1423 {
1424 int b = init();
1425 ok(b, "Basic init of CreateProcess test\n");
1426 if (!b) return;
1427
1428 if (myARGC >= 3)
1429 {
1430 doChild(myARGV[2], (myARGC == 3) ? NULL : myARGV[3]);
1431 return;
1432 }
1433 test_Startup();
1434 test_CommandLine();
1435 test_Directory();
1436 test_Environment();
1437 test_SuspendFlag();
1438 test_DebuggingFlag();
1439 test_Console();
1440 test_ExitCode();
1441 test_OpenProcess();
1442 /* things that can be tested:
1443 * lookup: check the way program to be executed is searched
1444 * handles: check the handle inheritance stuff (+sec options)
1445 * console: check if console creation parameters work
1446 */
1447 }
useful hacks and other patches not (yet) suitable for mainline