huwcampbell.com
Reactos
1/*
2 * Copyright 2009 Dan Kegel
3 * Copyright 2010 Jacek Caban for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20//#include <windows.h>
21#include <stdio.h>
22
23#include <wine/test.h>
24#include <winnls.h>
25
26static char workdir[MAX_PATH];
27static DWORD workdir_len;
28static char drive[2];
29static const DWORD drive_len = ARRAY_SIZE(drive);
30static char path[MAX_PATH];
31static DWORD path_len;
32static char shortpath[MAX_PATH];
33static DWORD shortpath_len;
34
35/* Convert to DOS line endings, and substitute escaped whitespace chars with real ones */
36static const char* convert_input_data(const char *data, DWORD size, DWORD *new_size)
37{
38 static const char escaped_space[] = {'@','s','p','a','c','e','@'};
39 static const char escaped_tab[] = {'@','t','a','b','@'};
40 DWORD i, eol_count = 0;
41 char *ptr, *new_data;
42
43 for (i = 0; i < size; i++)
44 if (data[i] == '\n') eol_count++;
45
46 ptr = new_data = HeapAlloc(GetProcessHeap(), 0, size + eol_count + 1);
47
48 for (i = 0; i < size; i++) {
49 switch (data[i]) {
50 case '\n':
51 if (data[i-1] != '\r')
52 *ptr++ = '\r';
53 *ptr++ = '\n';
54 break;
55 case '@':
56 if (data + i + sizeof(escaped_space) - 1 < data + size
57 && !memcmp(data + i, escaped_space, sizeof(escaped_space))) {
58 *ptr++ = ' ';
59 i += sizeof(escaped_space) - 1;
60 } else if (data + i + sizeof(escaped_tab) - 1 < data + size
61 && !memcmp(data + i, escaped_tab, sizeof(escaped_tab))) {
62 *ptr++ = '\t';
63 i += sizeof(escaped_tab) - 1;
64 } else {
65 *ptr++ = data[i];
66 }
67 break;
68 default:
69 *ptr++ = data[i];
70 }
71 }
72 *ptr = '\0';
73
74#ifdef __REACTOS__
75 *new_size = lstrlenA(new_data);
76#else
77 *new_size = strlen(new_data);
78#endif
79 return new_data;
80}
81
82static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
83{
84 SECURITY_ATTRIBUTES sa = {sizeof(sa), 0, TRUE};
85 char command[] = "test.cmd";
86 STARTUPINFOA si = {sizeof(si)};
87 PROCESS_INFORMATION pi;
88 HANDLE file,fileerr;
89 DWORD size;
90 BOOL bres;
91
92 file = CreateFileA("test.cmd", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
93 FILE_ATTRIBUTE_NORMAL, NULL);
94 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
95 if(file == INVALID_HANDLE_VALUE)
96 return FALSE;
97
98 bres = WriteFile(file, cmd_data, cmd_size, &size, NULL);
99 CloseHandle(file);
100 ok(bres, "Could not write to file: %u\n", GetLastError());
101 if(!bres)
102 return FALSE;
103
104 file = CreateFileA("test.out", GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, &sa, CREATE_ALWAYS,
105 FILE_ATTRIBUTE_NORMAL, NULL);
106 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
107 if(file == INVALID_HANDLE_VALUE)
108 return FALSE;
109
110 fileerr = CreateFileA("test.err", GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, &sa, CREATE_ALWAYS,
111 FILE_ATTRIBUTE_NORMAL, NULL);
112 ok(fileerr != INVALID_HANDLE_VALUE, "CreateFile stderr failed\n");
113 if(fileerr == INVALID_HANDLE_VALUE)
114 return FALSE;
115
116 si.dwFlags = STARTF_USESTDHANDLES;
117 si.hStdOutput = file;
118 si.hStdError = fileerr;
119 bres = CreateProcessA(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
120 ok(bres, "CreateProcess failed: %u\n", GetLastError());
121 if(!bres) {
122 DeleteFileA("test.out");
123 return FALSE;
124 }
125
126 WaitForSingleObject(pi.hProcess, INFINITE);
127 CloseHandle(pi.hThread);
128 CloseHandle(pi.hProcess);
129 CloseHandle(file);
130 CloseHandle(fileerr);
131 DeleteFileA("test.cmd");
132 return TRUE;
133}
134
135static DWORD map_file(const char *file_name, const char **ret)
136{
137 HANDLE file, map;
138 DWORD size;
139
140 file = CreateFileA(file_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
141 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError());
142 if(file == INVALID_HANDLE_VALUE)
143 return 0;
144
145 size = GetFileSize(file, NULL);
146
147 map = CreateFileMappingA(file, NULL, PAGE_READONLY, 0, 0, NULL);
148 CloseHandle(file);
149 ok(map != NULL, "CreateFileMappingA(%s) failed: %u\n", file_name, GetLastError());
150 if(!map)
151 return 0;
152
153 *ret = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
154 ok(*ret != NULL, "MapViewOfFile failed: %u\n", GetLastError());
155 CloseHandle(map);
156 if(!*ret)
157 return 0;
158
159 return size;
160}
161
162static const char *compare_line(const char *out_line, const char *out_end, const char *exp_line,
163 const char *exp_end)
164{
165 const char *out_ptr = out_line, *exp_ptr = exp_line;
166 const char *err = NULL;
167
168 static const char pwd_cmd[] = {'@','p','w','d','@'};
169 static const char drive_cmd[] = {'@','d','r','i','v','e','@'};
170 static const char path_cmd[] = {'@','p','a','t','h','@'};
171 static const char shortpath_cmd[] = {'@','s','h','o','r','t','p','a','t','h','@'};
172 static const char space_cmd[] = {'@','s','p','a','c','e','@'};
173 static const char spaces_cmd[] = {'@','s','p','a','c','e','s','@'};
174 static const char tab_cmd[] = {'@','t','a','b','@'};
175 static const char or_broken_cmd[] = {'@','o','r','_','b','r','o','k','e','n','@'};
176
177 while(exp_ptr < exp_end) {
178 if(*exp_ptr == '@') {
179 if(exp_ptr+sizeof(pwd_cmd) <= exp_end
180 && !memcmp(exp_ptr, pwd_cmd, sizeof(pwd_cmd))) {
181 exp_ptr += sizeof(pwd_cmd);
182 if(out_end-out_ptr < workdir_len
183 || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, out_ptr, workdir_len,
184 workdir, workdir_len) != CSTR_EQUAL)) {
185 err = out_ptr;
186 }else {
187 out_ptr += workdir_len;
188 continue;
189 }
190 } else if(exp_ptr+sizeof(drive_cmd) <= exp_end
191 && !memcmp(exp_ptr, drive_cmd, sizeof(drive_cmd))) {
192 exp_ptr += sizeof(drive_cmd);
193 if(out_end-out_ptr < drive_len
194 || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
195 out_ptr, drive_len, drive, drive_len) != CSTR_EQUAL)) {
196 err = out_ptr;
197 }else {
198 out_ptr += drive_len;
199 continue;
200 }
201 } else if(exp_ptr+sizeof(path_cmd) <= exp_end
202 && !memcmp(exp_ptr, path_cmd, sizeof(path_cmd))) {
203 exp_ptr += sizeof(path_cmd);
204 if(out_end-out_ptr < path_len
205 || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
206 out_ptr, path_len, path, path_len) != CSTR_EQUAL)) {
207 err = out_ptr;
208 }else {
209 out_ptr += path_len;
210 continue;
211 }
212 } else if(exp_ptr+sizeof(shortpath_cmd) <= exp_end
213 && !memcmp(exp_ptr, shortpath_cmd, sizeof(shortpath_cmd))) {
214 exp_ptr += sizeof(shortpath_cmd);
215 if(out_end-out_ptr < shortpath_len
216 || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
217 out_ptr, shortpath_len, shortpath, shortpath_len) != CSTR_EQUAL)) {
218 err = out_ptr;
219 }else {
220 out_ptr += shortpath_len;
221 continue;
222 }
223 }else if(exp_ptr+sizeof(space_cmd) <= exp_end
224 && !memcmp(exp_ptr, space_cmd, sizeof(space_cmd))) {
225 exp_ptr += sizeof(space_cmd);
226 if(out_ptr < out_end && *out_ptr == ' ') {
227 out_ptr++;
228 continue;
229 } else {
230 err = out_end;
231 }
232 }else if(exp_ptr+sizeof(spaces_cmd) <= exp_end
233 && !memcmp(exp_ptr, spaces_cmd, sizeof(spaces_cmd))) {
234 exp_ptr += sizeof(spaces_cmd);
235 if(out_ptr < out_end && *out_ptr == ' ') {
236 while (out_ptr < out_end && *out_ptr == ' ') out_ptr++;
237 continue;
238 } else {
239 err = out_end;
240 }
241 }else if(exp_ptr+sizeof(tab_cmd) <= exp_end
242 && !memcmp(exp_ptr, tab_cmd, sizeof(tab_cmd))) {
243 exp_ptr += sizeof(tab_cmd);
244 if(out_ptr < out_end && *out_ptr == '\t') {
245 out_ptr++;
246 continue;
247 } else {
248 err = out_end;
249 }
250 }else if(exp_ptr+sizeof(or_broken_cmd) <= exp_end
251 && !memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd))) {
252 if(out_ptr == out_end)
253 return NULL;
254 else
255 err = out_ptr;
256 }else if(out_ptr == out_end || *out_ptr != *exp_ptr)
257 err = out_ptr;
258 }else if(out_ptr == out_end || *out_ptr != *exp_ptr) {
259 err = out_ptr;
260 }
261
262 if(err) {
263 if(!broken(1))
264 return err;
265
266 while(exp_ptr+sizeof(or_broken_cmd) <= exp_end && memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd)))
267 exp_ptr++;
268 exp_ptr += sizeof(or_broken_cmd);
269 if (exp_ptr > exp_end) return err;
270 out_ptr = out_line;
271 err = NULL;
272 continue;
273 }
274
275 exp_ptr++;
276 out_ptr++;
277 }
278
279 if(exp_ptr != exp_end)
280 return out_ptr;
281 else if(out_ptr != out_end)
282 return exp_end;
283
284 return NULL;
285}
286
287static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
288{
289 const char *out_ptr = out_data, *exp_ptr = exp_data, *out_nl, *exp_nl, *err = NULL;
290 DWORD line = 0;
291 static const char todo_wine_cmd[] = {'@','t','o','d','o','_','w','i','n','e','@'};
292 static const char resync_cmd[] = {'-','-','-'};
293 BOOL is_todo_wine, is_out_resync = FALSE, is_exp_resync = FALSE;
294
295 while(out_ptr < out_data+out_size && exp_ptr < exp_data+exp_size) {
296 line++;
297
298 for(exp_nl = exp_ptr; exp_nl < exp_data+exp_size && *exp_nl != '\r' && *exp_nl != '\n'; exp_nl++);
299 for(out_nl = out_ptr; out_nl < out_data+out_size && *out_nl != '\r' && *out_nl != '\n'; out_nl++);
300
301 is_todo_wine = (exp_ptr+sizeof(todo_wine_cmd) <= exp_nl &&
302 !memcmp(exp_ptr, todo_wine_cmd, sizeof(todo_wine_cmd)));
303 if (is_todo_wine)
304 exp_ptr += sizeof(todo_wine_cmd);
305
306 todo_wine_if(is_todo_wine)
307 {
308 is_exp_resync=(exp_ptr+sizeof(resync_cmd) <= exp_nl &&
309 !memcmp(exp_ptr, resync_cmd, sizeof(resync_cmd)));
310 is_out_resync=(out_ptr+sizeof(resync_cmd) <= out_nl &&
311 !memcmp(out_ptr, resync_cmd, sizeof(resync_cmd)));
312
313 err = compare_line(out_ptr, out_nl, exp_ptr, exp_nl);
314 if(err == out_nl)
315 ok(0, "unexpected end of line %d (got '%.*s', wanted '%.*s')\n",
316 line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
317 else if(err == exp_nl)
318 ok(0, "excess characters on line %d (got '%.*s', wanted '%.*s')\n",
319 line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
320 else if (!err && is_todo_wine && is_out_resync && is_exp_resync)
321 /* Consider that the todo_wine was to deal with extra lines,
322 * not for the resync line itself
323 */
324 err = NULL;
325 else
326 ok(!err, "unexpected char 0x%x position %d in line %d (got '%.*s', wanted '%.*s')\n",
327 (err ? *err : 0), (err ? (int)(err-out_ptr) : -1), line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
328 }
329
330 if (is_exp_resync && err && is_todo_wine)
331 {
332 exp_ptr -= sizeof(todo_wine_cmd);
333 /* If we rewind to the beginning of the line, don't increment line number */
334 line--;
335 }
336 else if (!is_exp_resync || !err ||
337 (is_exp_resync && is_out_resync && err))
338 {
339 exp_ptr = exp_nl+1;
340 if(exp_nl+1 < exp_data+exp_size && exp_nl[0] == '\r' && exp_nl[1] == '\n')
341 exp_ptr++;
342 }
343
344 if (!is_out_resync || !err)
345 {
346 out_ptr = out_nl+1;
347 if(out_nl+1 < out_data+out_size && out_nl[0] == '\r' && out_nl[1] == '\n')
348 out_ptr++;
349 }
350 }
351
352 ok(exp_ptr >= exp_data+exp_size, "unexpected end of output in line %d, missing %s\n", line, exp_ptr);
353 ok(out_ptr >= out_data+out_size, "too long output, got additional %s\n", out_ptr);
354}
355
356static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
357{
358 const char *out_data, *actual_cmd_data;
359 DWORD out_size, actual_cmd_size;
360
361 actual_cmd_data = convert_input_data(cmd_data, cmd_size, &actual_cmd_size);
362 if(!actual_cmd_size || !actual_cmd_data)
363 goto cleanup;
364
365 if(!run_cmd(actual_cmd_data, actual_cmd_size))
366 goto cleanup;
367
368 out_size = map_file("test.out", &out_data);
369 if(out_size) {
370 test_output(out_data, out_size, exp_data, exp_size);
371 UnmapViewOfFile(out_data);
372 }
373 DeleteFileA("test.out");
374 DeleteFileA("test.err");
375
376cleanup:
377 HeapFree(GetProcessHeap(), 0, (LPVOID)actual_cmd_data);
378}
379
380static void run_from_file(const char *file_name)
381{
382 char out_name[MAX_PATH];
383 const char *test_data, *out_data;
384 DWORD test_size, out_size;
385
386 test_size = map_file(file_name, &test_data);
387 if(!test_size) {
388 ok(0, "Could not map file %s: %u\n", file_name, GetLastError());
389 return;
390 }
391
392 sprintf(out_name, "%s.exp", file_name);
393 out_size = map_file(out_name, &out_data);
394 if(!out_size) {
395 ok(0, "Could not map file %s: %u\n", out_name, GetLastError());
396 UnmapViewOfFile(test_data);
397 return;
398 }
399
400 run_test(test_data, test_size, out_data, out_size);
401
402 UnmapViewOfFile(test_data);
403 UnmapViewOfFile(out_data);
404}
405
406static DWORD load_resource(const char *name, const char *type, const char **ret)
407{
408 const char *res;
409 HRSRC src;
410 DWORD size;
411
412 src = FindResourceA(NULL, name, type);
413 ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError());
414 if(!src)
415 return 0;
416
417 res = LoadResource(NULL, src);
418 size = SizeofResource(NULL, src);
419 while(size && !res[size-1])
420 size--;
421
422 *ret = res;
423 return size;
424}
425
426static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
427{
428 const char *cmd_data, *out_data;
429 DWORD cmd_size, out_size;
430 char res_name[100];
431
432 trace("running %s test...\n", name);
433
434 cmd_size = load_resource(name, type, &cmd_data);
435 if(!cmd_size)
436 return TRUE;
437
438 sprintf(res_name, "%s.exp", name);
439 out_size = load_resource(res_name, "TESTOUT", &out_data);
440 if(!out_size)
441 return TRUE;
442
443 run_test(cmd_data, cmd_size, out_data, out_size);
444 return TRUE;
445}
446
447static int cmd_available(void)
448{
449 STARTUPINFOA si;
450 PROCESS_INFORMATION pi;
451 char cmd[] = "cmd /c exit 0";
452
453 memset(&si, 0, sizeof(si));
454 si.cb = sizeof(si);
455 if (CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
456 CloseHandle(pi.hThread);
457 CloseHandle(pi.hProcess);
458 return TRUE;
459 }
460 return FALSE;
461}
462
463START_TEST(reactos)
464{
465 int argc;
466 char **argv;
467
468 if (!cmd_available()) {
469 win_skip("cmd not installed, skipping cmd tests\n");
470 return;
471 }
472
473 workdir_len = GetCurrentDirectoryA(sizeof(workdir), workdir);
474 drive[0] = workdir[0];
475 drive[1] = workdir[1]; /* Should be ':' */
476 memcpy(path, workdir + drive_len, (workdir_len - drive_len) * sizeof(drive[0]));
477
478 /* Only add trailing backslash to 'path' for non-root directory */
479 if (workdir_len - drive_len > 1) {
480 path[workdir_len - drive_len] = '\\';
481 path_len = workdir_len - drive_len + 1;
482 } else {
483 path_len = 1; /* \ */
484 }
485 shortpath_len = GetShortPathNameA(path, shortpath, ARRAY_SIZE(shortpath));
486
487 argc = winetest_get_mainargs(&argv);
488 if(argc > 2)
489 run_from_file(argv[2]);
490 else
491 EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0);
492}