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