2 * Copyright 2009 Dan Kegel
3 * Copyright 2010 Jacek Caban for CodeWeavers
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.
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.
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
20 //#include <windows.h>
23 #include <wine/test.h>
26 static char workdir
[MAX_PATH
];
27 static DWORD workdir_len
;
29 static const DWORD drive_len
= sizeof(drive
)/sizeof(drive
[0]);
30 static char path
[MAX_PATH
];
31 static DWORD path_len
;
32 static char shortpath
[MAX_PATH
];
33 static DWORD shortpath_len
;
35 /* Convert to DOS line endings, and substitute escaped whitespace chars with real ones */
36 static const char* convert_input_data(const char *data
, DWORD size
, DWORD
*new_size
)
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;
43 for (i
= 0; i
< size
; i
++)
44 if (data
[i
] == '\n') eol_count
++;
46 ptr
= new_data
= HeapAlloc(GetProcessHeap(), 0, size
+ eol_count
+ 1);
48 for (i
= 0; i
< size
; i
++) {
51 if (data
[i
-1] != '\r')
56 if (data
+ i
+ sizeof(escaped_space
) - 1 < data
+ size
57 && !memcmp(data
+ i
, escaped_space
, sizeof(escaped_space
))) {
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
))) {
63 i
+= sizeof(escaped_tab
) - 1;
74 *new_size
= strlen(new_data
);
78 static BOOL
run_cmd(const char *cmd_data
, DWORD cmd_size
)
80 SECURITY_ATTRIBUTES sa
= {sizeof(sa
), 0, TRUE
};
81 char command
[] = "test.cmd";
82 STARTUPINFOA si
= {sizeof(si
)};
83 PROCESS_INFORMATION pi
;
88 file
= CreateFileA("test.cmd", GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
,
89 FILE_ATTRIBUTE_NORMAL
, NULL
);
90 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed\n");
91 if(file
== INVALID_HANDLE_VALUE
)
94 bres
= WriteFile(file
, cmd_data
, cmd_size
, &size
, NULL
);
96 ok(bres
, "Could not write to file: %u\n", GetLastError());
100 file
= CreateFileA("test.out", GENERIC_WRITE
, FILE_SHARE_WRITE
|FILE_SHARE_READ
, &sa
, CREATE_ALWAYS
,
101 FILE_ATTRIBUTE_NORMAL
, NULL
);
102 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed\n");
103 if(file
== INVALID_HANDLE_VALUE
)
106 fileerr
= CreateFileA("test.err", GENERIC_WRITE
, FILE_SHARE_WRITE
|FILE_SHARE_READ
, &sa
, CREATE_ALWAYS
,
107 FILE_ATTRIBUTE_NORMAL
, NULL
);
108 ok(fileerr
!= INVALID_HANDLE_VALUE
, "CreateFile stderr failed\n");
109 if(fileerr
== INVALID_HANDLE_VALUE
)
112 si
.dwFlags
= STARTF_USESTDHANDLES
;
113 si
.hStdOutput
= file
;
114 si
.hStdError
= fileerr
;
115 bres
= CreateProcessA(NULL
, command
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &si
, &pi
);
116 ok(bres
, "CreateProcess failed: %u\n", GetLastError());
118 DeleteFileA("test.out");
122 WaitForSingleObject(pi
.hProcess
, INFINITE
);
123 CloseHandle(pi
.hThread
);
124 CloseHandle(pi
.hProcess
);
126 CloseHandle(fileerr
);
127 DeleteFileA("test.cmd");
131 static DWORD
map_file(const char *file_name
, const char **ret
)
136 file
= CreateFileA(file_name
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_READONLY
, NULL
);
137 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed: %08x\n", GetLastError());
138 if(file
== INVALID_HANDLE_VALUE
)
141 size
= GetFileSize(file
, NULL
);
143 map
= CreateFileMapping(file
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
145 ok(map
!= NULL
, "CreateFileMapping(%s) failed: %u\n", file_name
, GetLastError());
149 *ret
= MapViewOfFile(map
, FILE_MAP_READ
, 0, 0, 0);
150 ok(*ret
!= NULL
, "MapViewOfFile failed: %u\n", GetLastError());
158 static const char *compare_line(const char *out_line
, const char *out_end
, const char *exp_line
,
161 const char *out_ptr
= out_line
, *exp_ptr
= exp_line
;
162 const char *err
= NULL
;
164 static const char pwd_cmd
[] = {'@','p','w','d','@'};
165 static const char drive_cmd
[] = {'@','d','r','i','v','e','@'};
166 static const char path_cmd
[] = {'@','p','a','t','h','@'};
167 static const char shortpath_cmd
[] = {'@','s','h','o','r','t','p','a','t','h','@'};
168 static const char space_cmd
[] = {'@','s','p','a','c','e','@'};
169 static const char tab_cmd
[] = {'@','t','a','b','@'};
170 static const char or_broken_cmd
[] = {'@','o','r','_','b','r','o','k','e','n','@'};
172 while(exp_ptr
< exp_end
) {
173 if(*exp_ptr
== '@') {
174 if(exp_ptr
+sizeof(pwd_cmd
) <= exp_end
175 && !memcmp(exp_ptr
, pwd_cmd
, sizeof(pwd_cmd
))) {
176 exp_ptr
+= sizeof(pwd_cmd
);
177 if(out_end
-out_ptr
< workdir_len
178 || (CompareStringA(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
, out_ptr
, workdir_len
,
179 workdir
, workdir_len
) != CSTR_EQUAL
)) {
182 out_ptr
+= workdir_len
;
185 } else if(exp_ptr
+sizeof(drive_cmd
) <= exp_end
186 && !memcmp(exp_ptr
, drive_cmd
, sizeof(drive_cmd
))) {
187 exp_ptr
+= sizeof(drive_cmd
);
188 if(out_end
-out_ptr
< drive_len
189 || (CompareStringA(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
190 out_ptr
, drive_len
, drive
, drive_len
) != CSTR_EQUAL
)) {
193 out_ptr
+= drive_len
;
196 } else if(exp_ptr
+sizeof(path_cmd
) <= exp_end
197 && !memcmp(exp_ptr
, path_cmd
, sizeof(path_cmd
))) {
198 exp_ptr
+= sizeof(path_cmd
);
199 if(out_end
-out_ptr
< path_len
200 || (CompareStringA(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
201 out_ptr
, path_len
, path
, path_len
) != CSTR_EQUAL
)) {
207 } else if(exp_ptr
+sizeof(shortpath_cmd
) <= exp_end
208 && !memcmp(exp_ptr
, shortpath_cmd
, sizeof(shortpath_cmd
))) {
209 exp_ptr
+= sizeof(shortpath_cmd
);
210 if(out_end
-out_ptr
< shortpath_len
211 || (CompareStringA(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
212 out_ptr
, shortpath_len
, shortpath
, shortpath_len
) != CSTR_EQUAL
)) {
215 out_ptr
+= shortpath_len
;
218 }else if(exp_ptr
+sizeof(space_cmd
) <= exp_end
219 && !memcmp(exp_ptr
, space_cmd
, sizeof(space_cmd
))) {
220 exp_ptr
+= sizeof(space_cmd
);
221 if(out_ptr
< out_end
&& *out_ptr
== ' ') {
227 }else if(exp_ptr
+sizeof(tab_cmd
) <= exp_end
228 && !memcmp(exp_ptr
, tab_cmd
, sizeof(tab_cmd
))) {
229 exp_ptr
+= sizeof(tab_cmd
);
230 if(out_ptr
< out_end
&& *out_ptr
== '\t') {
236 }else if(exp_ptr
+sizeof(or_broken_cmd
) <= exp_end
237 && !memcmp(exp_ptr
, or_broken_cmd
, sizeof(or_broken_cmd
))) {
238 if(out_ptr
== out_end
)
242 }else if(out_ptr
== out_end
|| *out_ptr
!= *exp_ptr
)
244 }else if(out_ptr
== out_end
|| *out_ptr
!= *exp_ptr
) {
252 while(exp_ptr
+sizeof(or_broken_cmd
) <= exp_end
&& memcmp(exp_ptr
, or_broken_cmd
, sizeof(or_broken_cmd
)))
257 exp_ptr
+= sizeof(or_broken_cmd
);
267 if(exp_ptr
!= exp_end
)
269 else if(out_ptr
!= out_end
)
275 static void test_output(const char *out_data
, DWORD out_size
, const char *exp_data
, DWORD exp_size
)
277 const char *out_ptr
= out_data
, *exp_ptr
= exp_data
, *out_nl
, *exp_nl
, *err
;
279 static const char todo_wine_cmd
[] = {'@','t','o','d','o','_','w','i','n','e','@'};
280 static const char resync_cmd
[] = {'-','-','-'};
281 BOOL is_todo_wine
, is_out_resync
, is_exp_resync
;
283 while(out_ptr
< out_data
+out_size
&& exp_ptr
< exp_data
+exp_size
) {
286 for(exp_nl
= exp_ptr
; exp_nl
< exp_data
+exp_size
&& *exp_nl
!= '\r' && *exp_nl
!= '\n'; exp_nl
++);
287 for(out_nl
= out_ptr
; out_nl
< out_data
+out_size
&& *out_nl
!= '\r' && *out_nl
!= '\n'; out_nl
++);
289 is_todo_wine
= (exp_ptr
+sizeof(todo_wine_cmd
) <= exp_nl
&&
290 !memcmp(exp_ptr
, todo_wine_cmd
, sizeof(todo_wine_cmd
)));
292 exp_ptr
+= sizeof(todo_wine_cmd
);
293 winetest_start_todo("wine");
295 is_exp_resync
=(exp_ptr
+sizeof(resync_cmd
) <= exp_nl
&&
296 !memcmp(exp_ptr
, resync_cmd
, sizeof(resync_cmd
)));
297 is_out_resync
=(out_ptr
+sizeof(resync_cmd
) <= out_nl
&&
298 !memcmp(out_ptr
, resync_cmd
, sizeof(resync_cmd
)));
300 err
= compare_line(out_ptr
, out_nl
, exp_ptr
, exp_nl
);
302 ok(0, "unexpected end of line %d (got '%.*s', wanted '%.*s')\n",
303 line
, (int)(out_nl
-out_ptr
), out_ptr
, (int)(exp_nl
-exp_ptr
), exp_ptr
);
304 else if(err
== exp_nl
)
305 ok(0, "excess characters on line %d (got '%.*s', wanted '%.*s')\n",
306 line
, (int)(out_nl
-out_ptr
), out_ptr
, (int)(exp_nl
-exp_ptr
), exp_ptr
);
307 else if (!err
&& is_todo_wine
&& is_out_resync
&& is_exp_resync
)
308 /* Consider that the todo_wine was to deal with extra lines,
309 * not for the resync line itself
313 ok(!err
, "unexpected char 0x%x position %d in line %d (got '%.*s', wanted '%.*s')\n",
314 (err
? *err
: 0), (err
? (int)(err
-out_ptr
) : -1), line
, (int)(out_nl
-out_ptr
), out_ptr
, (int)(exp_nl
-exp_ptr
), exp_ptr
);
316 if(is_todo_wine
) winetest_end_todo("wine");
318 if (is_exp_resync
&& err
&& is_todo_wine
)
320 exp_ptr
-= sizeof(todo_wine_cmd
);
321 /* If we rewind to the beginning of the line, don't increment line number */
324 else if (!is_exp_resync
|| (is_exp_resync
&& !err
))
327 if(exp_nl
+1 < exp_data
+exp_size
&& exp_nl
[0] == '\r' && exp_nl
[1] == '\n')
330 if (!is_out_resync
|| (is_out_resync
&& !err
))
333 if(out_nl
+1 < out_data
+out_size
&& out_nl
[0] == '\r' && out_nl
[1] == '\n')
338 ok(exp_ptr
>= exp_data
+exp_size
, "unexpected end of output in line %d, missing %s\n", line
, exp_ptr
);
339 ok(out_ptr
>= out_data
+out_size
, "too long output, got additional %s\n", out_ptr
);
342 static void run_test(const char *cmd_data
, DWORD cmd_size
, const char *exp_data
, DWORD exp_size
)
344 const char *out_data
, *actual_cmd_data
;
345 DWORD out_size
, actual_cmd_size
;
347 actual_cmd_data
= convert_input_data(cmd_data
, cmd_size
, &actual_cmd_size
);
348 if(!actual_cmd_size
|| !actual_cmd_data
)
351 if(!run_cmd(actual_cmd_data
, actual_cmd_size
))
354 out_size
= map_file("test.out", &out_data
);
356 test_output(out_data
, out_size
, exp_data
, exp_size
);
357 UnmapViewOfFile(out_data
);
359 DeleteFileA("test.out");
360 DeleteFileA("test.err");
363 HeapFree(GetProcessHeap(), 0, (LPVOID
)actual_cmd_data
);
366 static void run_from_file(const char *file_name
)
368 char out_name
[MAX_PATH
];
369 const char *test_data
, *out_data
;
370 DWORD test_size
, out_size
;
372 test_size
= map_file(file_name
, &test_data
);
374 ok(0, "Could not map file %s: %u\n", file_name
, GetLastError());
378 sprintf(out_name
, "%s.exp", file_name
);
379 out_size
= map_file(out_name
, &out_data
);
381 ok(0, "Could not map file %s: %u\n", out_name
, GetLastError());
382 UnmapViewOfFile(test_data
);
386 run_test(test_data
, test_size
, out_data
, out_size
);
388 UnmapViewOfFile(test_data
);
389 UnmapViewOfFile(out_data
);
392 static DWORD
load_resource(const char *name
, const char *type
, const char **ret
)
398 src
= FindResourceA(NULL
, name
, type
);
399 ok(src
!= NULL
, "Could not find resource %s: %u\n", name
, GetLastError());
403 res
= LoadResource(NULL
, src
);
404 size
= SizeofResource(NULL
, src
);
405 while(size
&& !res
[size
-1])
412 static BOOL WINAPI
test_enum_proc(HMODULE module
, LPCTSTR type
, LPSTR name
, LONG_PTR param
)
414 const char *cmd_data
, *out_data
;
415 DWORD cmd_size
, out_size
;
418 trace("running %s test...\n", name
);
420 cmd_size
= load_resource(name
, type
, &cmd_data
);
424 sprintf(res_name
, "%s.exp", name
);
425 out_size
= load_resource(res_name
, "TESTOUT", &out_data
);
429 run_test(cmd_data
, cmd_size
, out_data
, out_size
);
433 static int cmd_available(void)
436 PROCESS_INFORMATION pi
;
437 char cmd
[] = "cmd /c exit 0";
439 memset(&si
, 0, sizeof(si
));
441 if (CreateProcessA(NULL
, cmd
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
)) {
442 CloseHandle(pi
.hThread
);
443 CloseHandle(pi
.hProcess
);
454 if(!winetest_interactive
)
456 skip("Skipping cmd tests. CORE-6810.\n");
460 if (!cmd_available()) {
461 win_skip("cmd not installed, skipping cmd tests\n");
465 workdir_len
= GetCurrentDirectoryA(sizeof(workdir
), workdir
);
466 drive
[0] = workdir
[0];
467 drive
[1] = workdir
[1]; /* Should be ':' */
468 memcpy(path
, workdir
+ drive_len
, (workdir_len
- drive_len
) * sizeof(drive
[0]));
469 path
[workdir_len
- drive_len
] = '\\';
470 path_len
= workdir_len
- drive_len
+ 1;
471 shortpath_len
= GetShortPathNameA(path
, shortpath
,
472 sizeof(shortpath
)/sizeof(shortpath
[0]));
474 argc
= winetest_get_mainargs(&argv
);
476 run_from_file(argv
[2]);
478 EnumResourceNamesA(NULL
, "TESTCMD", test_enum_proc
, 0);