Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488/* * Copyright 2009 Dan Kegel * Copyright 2010 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
#include <windows.h>#include <stdio.h>
#include "wine/test.h"
static char workdir[MAX_PATH];static DWORD workdir_len;static char drive[2];static const DWORD drive_len = ARRAY_SIZE(drive);static char path[MAX_PATH];static DWORD path_len;static char shortpath[MAX_PATH];static DWORD shortpath_len;
/* Convert to DOS line endings, and substitute escaped whitespace chars with real ones */static const char* convert_input_data(const char *data, DWORD size, DWORD *new_size){ static const char escaped_space[] = {'@','s','p','a','c','e','@'}; static const char escaped_tab[] = {'@','t','a','b','@'}; DWORD i, eol_count = 0; char *ptr, *new_data;
for (i = 0; i < size; i++) if (data[i] == '\n') eol_count++;
ptr = new_data = HeapAlloc(GetProcessHeap(), 0, size + eol_count + 1);
for (i = 0; i < size; i++) { switch (data[i]) { case '\n': if (data[i-1] != '\r') *ptr++ = '\r'; *ptr++ = '\n'; break; case '@': if (data + i + sizeof(escaped_space) - 1 < data + size && !memcmp(data + i, escaped_space, sizeof(escaped_space))) { *ptr++ = ' '; i += sizeof(escaped_space) - 1; } else if (data + i + sizeof(escaped_tab) - 1 < data + size && !memcmp(data + i, escaped_tab, sizeof(escaped_tab))) { *ptr++ = '\t'; i += sizeof(escaped_tab) - 1; } else { *ptr++ = data[i]; } break; default: *ptr++ = data[i]; } } *ptr = '\0';
*new_size = strlen(new_data); return new_data;}
static BOOL run_cmd(const char *cmd_data, DWORD cmd_size){ SECURITY_ATTRIBUTES sa = {sizeof(sa), 0, TRUE}; char command[] = "test.cmd"; STARTUPINFOA si = {sizeof(si)}; PROCESS_INFORMATION pi; HANDLE file,fileerr; DWORD size; BOOL bres;
file = CreateFileA("test.cmd", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n"); if(file == INVALID_HANDLE_VALUE) return FALSE;
bres = WriteFile(file, cmd_data, cmd_size, &size, NULL); CloseHandle(file); ok(bres, "Could not write to file: %u\n", GetLastError()); if(!bres) return FALSE;
file = CreateFileA("test.out", GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, &sa, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n"); if(file == INVALID_HANDLE_VALUE) return FALSE;
fileerr = CreateFileA("test.err", GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, &sa, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); ok(fileerr != INVALID_HANDLE_VALUE, "CreateFile stderr failed\n"); if(fileerr == INVALID_HANDLE_VALUE) return FALSE;
si.dwFlags = STARTF_USESTDHANDLES; si.hStdOutput = file; si.hStdError = fileerr; bres = CreateProcessA(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi); ok(bres, "CreateProcess failed: %u\n", GetLastError()); if(!bres) { DeleteFileA("test.out"); return FALSE; }
WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hThread); CloseHandle(pi.hProcess); CloseHandle(file); CloseHandle(fileerr); DeleteFileA("test.cmd"); return TRUE;}
static DWORD map_file(const char *file_name, const char **ret){ HANDLE file, map; DWORD size;
file = CreateFileA(file_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError()); if(file == INVALID_HANDLE_VALUE) return 0;
size = GetFileSize(file, NULL);
map = CreateFileMappingA(file, NULL, PAGE_READONLY, 0, 0, NULL); CloseHandle(file); ok(map != NULL, "CreateFileMappingA(%s) failed: %u\n", file_name, GetLastError()); if(!map) return 0;
*ret = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0); ok(*ret != NULL, "MapViewOfFile failed: %u\n", GetLastError()); CloseHandle(map); if(!*ret) return 0;
return size;}
static const char *compare_line(const char *out_line, const char *out_end, const char *exp_line, const char *exp_end){ const char *out_ptr = out_line, *exp_ptr = exp_line; const char *err = NULL;
static const char pwd_cmd[] = {'@','p','w','d','@'}; static const char drive_cmd[] = {'@','d','r','i','v','e','@'}; static const char path_cmd[] = {'@','p','a','t','h','@'}; static const char shortpath_cmd[] = {'@','s','h','o','r','t','p','a','t','h','@'}; static const char space_cmd[] = {'@','s','p','a','c','e','@'}; static const char spaces_cmd[] = {'@','s','p','a','c','e','s','@'}; static const char tab_cmd[] = {'@','t','a','b','@'}; static const char or_broken_cmd[] = {'@','o','r','_','b','r','o','k','e','n','@'};
while(exp_ptr < exp_end) { if(*exp_ptr == '@') { if(exp_ptr+sizeof(pwd_cmd) <= exp_end && !memcmp(exp_ptr, pwd_cmd, sizeof(pwd_cmd))) { exp_ptr += sizeof(pwd_cmd); if(out_end-out_ptr < workdir_len || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, out_ptr, workdir_len, workdir, workdir_len) != CSTR_EQUAL)) { err = out_ptr; }else { out_ptr += workdir_len; continue; } } else if(exp_ptr+sizeof(drive_cmd) <= exp_end && !memcmp(exp_ptr, drive_cmd, sizeof(drive_cmd))) { exp_ptr += sizeof(drive_cmd); if(out_end-out_ptr < drive_len || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, out_ptr, drive_len, drive, drive_len) != CSTR_EQUAL)) { err = out_ptr; }else { out_ptr += drive_len; continue; } } else if(exp_ptr+sizeof(path_cmd) <= exp_end && !memcmp(exp_ptr, path_cmd, sizeof(path_cmd))) { exp_ptr += sizeof(path_cmd); if(out_end-out_ptr < path_len || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, out_ptr, path_len, path, path_len) != CSTR_EQUAL)) { err = out_ptr; }else { out_ptr += path_len; continue; } } else if(exp_ptr+sizeof(shortpath_cmd) <= exp_end && !memcmp(exp_ptr, shortpath_cmd, sizeof(shortpath_cmd))) { exp_ptr += sizeof(shortpath_cmd); if(out_end-out_ptr < shortpath_len || (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, out_ptr, shortpath_len, shortpath, shortpath_len) != CSTR_EQUAL)) { err = out_ptr; }else { out_ptr += shortpath_len; continue; } }else if(exp_ptr+sizeof(space_cmd) <= exp_end && !memcmp(exp_ptr, space_cmd, sizeof(space_cmd))) { exp_ptr += sizeof(space_cmd); if(out_ptr < out_end && *out_ptr == ' ') { out_ptr++; continue; } else { err = out_end; } }else if(exp_ptr+sizeof(spaces_cmd) <= exp_end && !memcmp(exp_ptr, spaces_cmd, sizeof(spaces_cmd))) { exp_ptr += sizeof(spaces_cmd); if(out_ptr < out_end && *out_ptr == ' ') { while (out_ptr < out_end && *out_ptr == ' ') out_ptr++; continue; } else { err = out_end; } }else if(exp_ptr+sizeof(tab_cmd) <= exp_end && !memcmp(exp_ptr, tab_cmd, sizeof(tab_cmd))) { exp_ptr += sizeof(tab_cmd); if(out_ptr < out_end && *out_ptr == '\t') { out_ptr++; continue; } else { err = out_end; } }else if(exp_ptr+sizeof(or_broken_cmd) <= exp_end && !memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd))) { if(out_ptr == out_end) return NULL; else err = out_ptr; }else if(out_ptr == out_end || *out_ptr != *exp_ptr) err = out_ptr; }else if(out_ptr == out_end || *out_ptr != *exp_ptr) { err = out_ptr; }
if(err) { if(!broken(1)) return err;
while(exp_ptr+sizeof(or_broken_cmd) <= exp_end && memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd))) exp_ptr++; exp_ptr += sizeof(or_broken_cmd); if (exp_ptr > exp_end) return err; out_ptr = out_line; err = NULL; continue; }
exp_ptr++; out_ptr++; }
if(exp_ptr != exp_end) return out_ptr; else if(out_ptr != out_end) return exp_end;
return NULL;}
static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size){ const char *out_ptr = out_data, *exp_ptr = exp_data, *out_nl, *exp_nl, *err = NULL; DWORD line = 0; static const char todo_wine_cmd[] = {'@','t','o','d','o','_','w','i','n','e','@'}; static const char resync_cmd[] = {'-','-','-'}; BOOL is_todo_wine, is_out_resync = FALSE, is_exp_resync = FALSE;
while(out_ptr < out_data+out_size && exp_ptr < exp_data+exp_size) { line++;
for(exp_nl = exp_ptr; exp_nl < exp_data+exp_size && *exp_nl != '\r' && *exp_nl != '\n'; exp_nl++); for(out_nl = out_ptr; out_nl < out_data+out_size && *out_nl != '\r' && *out_nl != '\n'; out_nl++);
is_todo_wine = (exp_ptr+sizeof(todo_wine_cmd) <= exp_nl && !memcmp(exp_ptr, todo_wine_cmd, sizeof(todo_wine_cmd))); if (is_todo_wine) exp_ptr += sizeof(todo_wine_cmd);
todo_wine_if(is_todo_wine) { is_exp_resync=(exp_ptr+sizeof(resync_cmd) <= exp_nl && !memcmp(exp_ptr, resync_cmd, sizeof(resync_cmd))); is_out_resync=(out_ptr+sizeof(resync_cmd) <= out_nl && !memcmp(out_ptr, resync_cmd, sizeof(resync_cmd)));
err = compare_line(out_ptr, out_nl, exp_ptr, exp_nl); if(err == out_nl) ok(0, "unexpected end of line %d (got '%.*s', wanted '%.*s')\n", line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr); else if(err == exp_nl) ok(0, "excess characters on line %d (got '%.*s', wanted '%.*s')\n", line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr); else if (!err && is_todo_wine && is_out_resync && is_exp_resync) /* Consider that the todo_wine was to deal with extra lines, * not for the resync line itself */ err = NULL; else ok(!err, "unexpected char 0x%x position %d in line %d (got '%.*s', wanted '%.*s')\n", (err ? *err : 0), (err ? (int)(err-out_ptr) : -1), line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr); }
if (is_exp_resync && err && is_todo_wine) { exp_ptr -= sizeof(todo_wine_cmd); /* If we rewind to the beginning of the line, don't increment line number */ line--; } else if (!is_exp_resync || !err || (is_exp_resync && is_out_resync && err)) { exp_ptr = exp_nl+1; if(exp_nl+1 < exp_data+exp_size && exp_nl[0] == '\r' && exp_nl[1] == '\n') exp_ptr++; }
if (!is_out_resync || !err) { out_ptr = out_nl+1; if(out_nl+1 < out_data+out_size && out_nl[0] == '\r' && out_nl[1] == '\n') out_ptr++; } }
ok(exp_ptr >= exp_data+exp_size, "unexpected end of output in line %d, missing %s\n", line, exp_ptr); ok(out_ptr >= out_data+out_size, "too long output, got additional %s\n", out_ptr);}
static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size){ const char *out_data, *actual_cmd_data; DWORD out_size, actual_cmd_size;
actual_cmd_data = convert_input_data(cmd_data, cmd_size, &actual_cmd_size); if(!actual_cmd_size || !actual_cmd_data) goto cleanup;
if(!run_cmd(actual_cmd_data, actual_cmd_size)) goto cleanup;
out_size = map_file("test.out", &out_data); if(out_size) { test_output(out_data, out_size, exp_data, exp_size); UnmapViewOfFile(out_data); } DeleteFileA("test.out"); DeleteFileA("test.err");
cleanup: HeapFree(GetProcessHeap(), 0, (LPVOID)actual_cmd_data);}
static void run_from_file(const char *file_name){ char out_name[MAX_PATH]; const char *test_data, *out_data; DWORD test_size, out_size;
test_size = map_file(file_name, &test_data); if(!test_size) { ok(0, "Could not map file %s: %u\n", file_name, GetLastError()); return; }
sprintf(out_name, "%s.exp", file_name); out_size = map_file(out_name, &out_data); if(!out_size) { ok(0, "Could not map file %s: %u\n", out_name, GetLastError()); UnmapViewOfFile(test_data); return; }
run_test(test_data, test_size, out_data, out_size);
UnmapViewOfFile(test_data); UnmapViewOfFile(out_data);}
static DWORD load_resource(const char *name, const char *type, const char **ret){ const char *res; HRSRC src; DWORD size;
src = FindResourceA(NULL, name, type); ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError()); if(!src) return 0;
res = LoadResource(NULL, src); size = SizeofResource(NULL, src); while(size && !res[size-1]) size--;
*ret = res; return size;}
static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param){ const char *cmd_data, *out_data; DWORD cmd_size, out_size; char res_name[100];
trace("running %s test...\n", name);
cmd_size = load_resource(name, type, &cmd_data); if(!cmd_size) return TRUE;
sprintf(res_name, "%s.exp", name); out_size = load_resource(res_name, "TESTOUT", &out_data); if(!out_size) return TRUE;
run_test(cmd_data, cmd_size, out_data, out_size); return TRUE;}
static int cmd_available(void){ STARTUPINFOA si; PROCESS_INFORMATION pi; char cmd[] = "cmd /c exit 0";
memset(&si, 0, sizeof(si)); si.cb = sizeof(si); if (CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { CloseHandle(pi.hThread); CloseHandle(pi.hProcess); return TRUE; } return FALSE;}
START_TEST(batch){ int argc; char **argv;
if (!cmd_available()) { win_skip("cmd not installed, skipping cmd tests\n"); return; }
workdir_len = GetCurrentDirectoryA(sizeof(workdir), workdir); drive[0] = workdir[0]; drive[1] = workdir[1]; /* Should be ':' */ memcpy(path, workdir + drive_len, (workdir_len - drive_len) * sizeof(drive[0]));
/* Only add trailing backslash to 'path' for non-root directory */ if (workdir_len - drive_len > 1) { path[workdir_len - drive_len] = '\\'; path_len = workdir_len - drive_len + 1; } else { path_len = 1; /* \ */ } shortpath_len = GetShortPathNameA(path, shortpath, ARRAY_SIZE(shortpath));
argc = winetest_get_mainargs(&argv); if(argc > 2) run_from_file(argv[2]); else EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0);}