ReactOS 0.4.15-dev-8408-g466a198
batch.c
Go to the documentation of this file.
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];
28static char drive[2];
30static char path[MAX_PATH];
32static char shortpath[MAX_PATH];
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)};
88 HANDLE file,fileerr;
89 DWORD size;
90 BOOL bres;
91
94 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
96 return FALSE;
97
98 bres = WriteFile(file, cmd_data, cmd_size, &size, NULL);
100 ok(bres, "Could not write to file: %u\n", GetLastError());
101 if(!bres)
102 return FALSE;
103
106 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
108 return FALSE;
109
112 ok(fileerr != INVALID_HANDLE_VALUE, "CreateFile stderr failed\n");
113 if(fileerr == INVALID_HANDLE_VALUE)
114 return FALSE;
115
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
127 CloseHandle(pi.hThread);
128 CloseHandle(pi.hProcess);
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
141 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError());
143 return 0;
144
146
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());
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
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
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
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
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;
385
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());
397 return;
398 }
399
401
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
413 ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError());
414 if(!src)
415 return 0;
416
419 while(size && !res[size-1])
420 size--;
421
422 *ret = res;
423 return size;
424}
425
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;
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
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
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] = '\\';
482 } else {
483 path_len = 1; /* \ */
484 }
486
488 if(argc > 2)
490 else
491 EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0);
492}
static int argc
Definition: ServiceArgs.c:12
#define broken(x)
Definition: _sntprintf.h:21
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
#define START_TEST(x)
Definition: atltest.h:75
#define ARRAY_SIZE(A)
Definition: main.h:33
Definition: _map.h:48
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define PAGE_READONLY
Definition: compat.h:138
#define UnmapViewOfFile
Definition: compat.h:746
#define OPEN_EXISTING
Definition: compat.h:775
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define FILE_MAP_READ
Definition: compat.h:776
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define MapViewOfFile
Definition: compat.h:745
#define FILE_SHARE_READ
Definition: compat.h:136
static void cleanup(void)
Definition: main.c:1335
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2146
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1752
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4741
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
BOOL WINAPI EnumResourceNamesA(HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam)
Definition: res.c:285
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: locale.c:4082
#define INFINITE
Definition: serial.h:102
HANDLE NTAPI CreateFileMappingA(IN HANDLE hFile, IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes, IN DWORD flProtect, IN DWORD dwMaximumSizeHigh, IN DWORD dwMaximumSizeLow, IN LPCSTR lpName)
Definition: filemap.c:23
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLenum src
Definition: glext.h:6340
GLfloat param
Definition: glext.h:5796
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CREATE_ALWAYS
Definition: disk.h:72
static PVOID ptr
Definition: dispmode.c:27
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static const DWORD drive_len
Definition: batch.c:29
static DWORD load_resource(const char *name, const char *type, const char **ret)
Definition: batch.c:406
static DWORD map_file(const char *file_name, const char **ret)
Definition: batch.c:135
static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
Definition: batch.c:82
static char workdir[MAX_PATH]
Definition: batch.c:26
static DWORD workdir_len
Definition: batch.c:27
static int cmd_available(void)
Definition: batch.c:447
static DWORD path_len
Definition: batch.c:31
static const char * convert_input_data(const char *data, DWORD size, DWORD *new_size)
Definition: batch.c:36
static void run_from_file(const char *file_name)
Definition: batch.c:380
static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
Definition: batch.c:426
static DWORD shortpath_len
Definition: batch.c:33
static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:287
static const char * compare_line(const char *out_line, const char *out_end, const char *exp_line, const char *exp_end)
Definition: batch.c:162
static char shortpath[MAX_PATH]
Definition: batch.c:32
static void test_size(void)
Definition: monthcal.c:1559
#define todo_wine_if(is_todo)
Definition: custom.c:76
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
static refpint_t pi[]
Definition: server.c:96
static LPCWSTR file_name
Definition: protocol.c:147
#define argv
Definition: mplay32.c:18
#define run_test(test)
Definition: ms_seh.c:71
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define GENERIC_WRITE
Definition: nt_native.h:90
#define LOCALE_SYSTEM_DEFAULT
#define err(...)
#define win_skip
Definition: test.h:163
int winetest_get_mainargs(char ***pargv)
#define memset(x, y, z)
Definition: compat.h:39
struct ChNotifyTest * exp_data
Definition: shlfolder.c:4868
HANDLE hStdOutput
Definition: winbase.h:847
HANDLE hStdError
Definition: winbase.h:848
DWORD dwFlags
Definition: winbase.h:842
DWORD cb
Definition: winbase.h:831
Definition: ftp_var.h:139
Definition: fci.c:127
Definition: parser.c:49
Definition: name.c:39
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
int ret
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define STARTF_USESTDHANDLES
Definition: winbase.h:499
#define WINAPI
Definition: msvc.h:6
#define NORM_IGNORECASE
Definition: winnls.h:176
#define CSTR_EQUAL
Definition: winnls.h:456
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182