From 8dd89c7cfcfb6abc51d873a4aeafa91510513f1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herm=C3=A8s=20B=C3=A9lusca-Ma=C3=AFto?= Date: Fri, 17 Nov 2017 00:56:01 +0100 Subject: [PATCH] [ROSTESTS] Start adding ReactOS-owned tests for cmd.exe, based on Wine's. CORE-7998 Based on Wine's cmd_winetest code, this first bunch of tests check how the "for" command should process the newlines inside its parenthesed set. Adapted by Doug Lyons. --- modules/rostests/CMakeLists.txt | 2 +- modules/rostests/win32/CMakeLists.txt | 1 + modules/rostests/win32/cmd/CMakeLists.txt | 11 + modules/rostests/win32/cmd/README.txt | 1 + modules/rostests/win32/cmd/batch.c | 481 ++++++++++++++++++ modules/rostests/win32/cmd/rsrc.rc | 24 + modules/rostests/win32/cmd/test_builtins.cmd | 30 ++ .../rostests/win32/cmd/test_builtins.cmd.exp | 27 + modules/rostests/win32/cmd/testlist.c | 12 + 9 files changed, 588 insertions(+), 1 deletion(-) create mode 100644 modules/rostests/win32/cmd/CMakeLists.txt create mode 100644 modules/rostests/win32/cmd/README.txt create mode 100644 modules/rostests/win32/cmd/batch.c create mode 100644 modules/rostests/win32/cmd/rsrc.rc create mode 100644 modules/rostests/win32/cmd/test_builtins.cmd create mode 100644 modules/rostests/win32/cmd/test_builtins.cmd.exp create mode 100644 modules/rostests/win32/cmd/testlist.c diff --git a/modules/rostests/CMakeLists.txt b/modules/rostests/CMakeLists.txt index 1f8062b9ffe..1635a64c82c 100644 --- a/modules/rostests/CMakeLists.txt +++ b/modules/rostests/CMakeLists.txt @@ -13,7 +13,7 @@ add_subdirectory(kmtests) #add_subdirectory(regtests) add_subdirectory(rosautotest) add_subdirectory(tests) -#add_subdirectory(win32) +add_subdirectory(win32) add_subdirectory(winetests) diff --git a/modules/rostests/win32/CMakeLists.txt b/modules/rostests/win32/CMakeLists.txt index 73e15e25a0e..7fc9c96f732 100644 --- a/modules/rostests/win32/CMakeLists.txt +++ b/modules/rostests/win32/CMakeLists.txt @@ -1,3 +1,4 @@ add_subdirectory(advapi32) +add_subdirectory(cmd) add_subdirectory(kernel32) add_subdirectory(user32) diff --git a/modules/rostests/win32/cmd/CMakeLists.txt b/modules/rostests/win32/cmd/CMakeLists.txt new file mode 100644 index 00000000000..d0f9ab1517d --- /dev/null +++ b/modules/rostests/win32/cmd/CMakeLists.txt @@ -0,0 +1,11 @@ +add_definitions(-D__ROS_LONG64__) + +list(APPEND SOURCE + batch.c + testlist.c + rsrc.rc) + +add_executable(cmd_rostest ${SOURCE}) +set_module_type(cmd_rostest win32cui) +add_importlibs(cmd_rostest msvcrt kernel32) +add_rostests_file(TARGET cmd_rostest) diff --git a/modules/rostests/win32/cmd/README.txt b/modules/rostests/win32/cmd/README.txt new file mode 100644 index 00000000000..5ab52b3f4da --- /dev/null +++ b/modules/rostests/win32/cmd/README.txt @@ -0,0 +1 @@ +Cloned from Wine's cmd_winetest code. \ No newline at end of file diff --git a/modules/rostests/win32/cmd/batch.c b/modules/rostests/win32/cmd/batch.c new file mode 100644 index 00000000000..e1db7c9ec90 --- /dev/null +++ b/modules/rostests/win32/cmd/batch.c @@ -0,0 +1,481 @@ +/* + * 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 +#include + +#include +#include + +static char workdir[MAX_PATH]; +static DWORD workdir_len; +static char drive[2]; +static const DWORD drive_len = sizeof(drive)/sizeof(drive[0]); +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 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(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++; + if(!exp_ptr) + return err; + + exp_ptr += sizeof(or_broken_cmd); + 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(reactos) +{ + 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, + sizeof(shortpath)/sizeof(shortpath[0])); + + argc = winetest_get_mainargs(&argv); + if(argc > 2) + run_from_file(argv[2]); + else + EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0); +} diff --git a/modules/rostests/win32/cmd/rsrc.rc b/modules/rostests/win32/cmd/rsrc.rc new file mode 100644 index 00000000000..7fd54341dff --- /dev/null +++ b/modules/rostests/win32/cmd/rsrc.rc @@ -0,0 +1,24 @@ +/* + * Copyright 2010 Jacek Caban for CodeWeavers + * Copyright 2017 by Doug Lyons + * + * 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 + */ + +/* @makedep: test_builtins.cmd */ +test_builtins.cmd TESTCMD "test_builtins.cmd" + +/* @makedep: test_builtins.cmd.exp */ +test_builtins.cmd.exp TESTOUT "test_builtins.cmd.exp" diff --git a/modules/rostests/win32/cmd/test_builtins.cmd b/modules/rostests/win32/cmd/test_builtins.cmd new file mode 100644 index 00000000000..cc387c08e57 --- /dev/null +++ b/modules/rostests/win32/cmd/test_builtins.cmd @@ -0,0 +1,30 @@ +@echo off +echo ------------ Testing for1 ------------ +echo --- plain FOR with multiple lines +for %%i in (A +B +C) do echo %%i +echo ------------ Testing for2 ------------ +echo --- plain FOR with lines and spaces +for %%i in (D + E + F) do echo %%i +echo ------------ Testing for3 ------------ +echo --- plain FOR with multiple lines and commas +for %%i in (G, +H, +I +) do echo %%i +echo ------------ Testing for4 ------------ +echo --- plain FOR with multiple lines and %%I +for %%i in (J + K + L) do echo %%I +echo ------------ Testing for5 ------------ +echo --- plain FOR with multiple lines and %%j +for %%i in (M, +N, +O +) do echo %%j +echo ------------ End of Testing ------------ +echo --- Testing ends here diff --git a/modules/rostests/win32/cmd/test_builtins.cmd.exp b/modules/rostests/win32/cmd/test_builtins.cmd.exp new file mode 100644 index 00000000000..c13f7018fab --- /dev/null +++ b/modules/rostests/win32/cmd/test_builtins.cmd.exp @@ -0,0 +1,27 @@ +------------ Testing for1 ------------ +--- plain FOR with multiple lines +A +B +C +------------ Testing for2 ------------ +--- plain FOR with lines and spaces +D +E +F +------------ Testing for3 ------------ +--- plain FOR with multiple lines and commas +G +H +I +------------ Testing for4 ------------ +--- plain FOR with multiple lines and %I +%I +%I +%I +------------ Testing for5 ------------ +--- plain FOR with multiple lines and %j +%j +%j +%j +------------ End of Testing ------------ +--- Testing ends here diff --git a/modules/rostests/win32/cmd/testlist.c b/modules/rostests/win32/cmd/testlist.c new file mode 100644 index 00000000000..bf8b9f138e7 --- /dev/null +++ b/modules/rostests/win32/cmd/testlist.c @@ -0,0 +1,12 @@ +/* Automatically generated file; DO NOT EDIT!! */ + +#define STANDALONE +#include "wine/test.h" + +extern void func_reactos(void); + +const struct test winetest_testlist[] = +{ + { "reactos", func_reactos }, + { 0, 0 } +};