ReactOS  0.4.15-dev-1171-gab82533
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 
26 static char workdir[MAX_PATH];
28 static char drive[2];
29 static const DWORD drive_len = ARRAY_SIZE(drive);
30 static char path[MAX_PATH];
31 static DWORD path_len;
32 static char shortpath[MAX_PATH];
34 
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)
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 
82 static 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 
92  file = CreateFileA("test.cmd", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
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 
126  WaitForSingleObject(pi.hProcess, INFINITE);
127  CloseHandle(pi.hThread);
128  CloseHandle(pi.hProcess);
129  CloseHandle(file);
130  CloseHandle(fileerr);
131  DeleteFileA("test.cmd");
132  return TRUE;
133 }
134 
135 static 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 
148  CloseHandle(file);
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());
155  CloseHandle(map);
156  if(!*ret)
157  return 0;
158 
159  return size;
160 }
161 
162 static 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 
287 static 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 
356 static 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 
376 cleanup:
377  HeapFree(GetProcessHeap(), 0, (LPVOID)actual_cmd_data);
378 }
379 
380 static 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 
400  run_test(test_data, test_size, out_data, out_size);
401 
403  UnmapViewOfFile(out_data);
404 }
405 
406 static 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 
417  res = LoadResource(NULL, src);
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 
447 static 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 
463 START_TEST(reactos)
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)
489  run_from_file(argv[2]);
490  else
491  EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0);
492 }
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
static int argc
Definition: ServiceArgs.c:12
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
#define CloseHandle
Definition: compat.h:487
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define MapViewOfFile
Definition: compat.h:493
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
Definition: ftp_var.h:139
#define TRUE
Definition: types.h:120
static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:287
static DWORD map_file(const char *file_name, const char **ret)
Definition: batch.c:135
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define INVALID_HANDLE_VALUE
Definition: compat.h:479
static DWORD shortpath_len
Definition: batch.c:33
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
DWORD dwFlags
Definition: winbase.h:820
#define NORM_IGNORECASE
Definition: winnls.h:173
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
BOOL WINAPI EnumResourceNamesA(HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam)
Definition: res.c:285
static struct _test_data test_data[]
#define argv
Definition: mplay32.c:18
char * LPSTR
Definition: xmlstorage.h:182
static const DWORD drive_len
Definition: batch.c:29
#define FILE_SHARE_READ
Definition: compat.h:136
static DWORD load_resource(const char *name, const char *type, const char **ret)
Definition: batch.c:406
static const char * convert_input_data(const char *data, DWORD size, DWORD *new_size)
Definition: batch.c:36
#define sprintf(buf, format,...)
Definition: sprintf.c:55
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
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
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define GENERIC_WRITE
Definition: nt_native.h:90
static PVOID ptr
Definition: dispmode.c:27
struct ChNotifyTest * exp_data
Definition: shlfolder.c:4868
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
Definition: parser.c:48
#define FILE_MAP_READ
Definition: compat.h:524
const char * LPCSTR
Definition: xmlstorage.h:183
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
#define OPEN_EXISTING
Definition: compat.h:523
static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
Definition: batch.c:82
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: lang.c:2299
#define todo_wine_if(is_todo)
Definition: test.h:163
#define STARTF_USESTDHANDLES
Definition: winbase.h:480
START_TEST(reactos)
Definition: batch.c:463
GLsizeiptr size
Definition: glext.h:5919
DWORD cb
Definition: winbase.h:809
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
static refpint_t pi[]
Definition: server.c:96
static char workdir[MAX_PATH]
Definition: batch.c:26
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:4744
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1751
GLfloat param
Definition: glext.h:5796
#define MAX_PATH
Definition: compat.h:34
#define WINAPI
Definition: msvc.h:6
const char file[]
Definition: icontest.c:11
#define LOCALE_SYSTEM_DEFAULT
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
unsigned long DWORD
Definition: ntddk_ex.h:95
HANDLE hStdOutput
Definition: winbase.h:825
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
Definition: _map.h:44
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int winetest_get_mainargs(char ***pargv)
int ret
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CSTR_EQUAL
Definition: winnls.h:453
#define GENERIC_READ
Definition: compat.h:135
GLenum src
Definition: glext.h:6340
#define err(...)
#define broken(x)
Definition: _sntprintf.h:21
static void test_size(void)
Definition: monthcal.c:1559
#define CREATE_ALWAYS
Definition: disk.h:72
static DWORD path_len
Definition: batch.c:31
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define ARRAY_SIZE(a)
Definition: main.h:24
static void run_from_file(const char *file_name)
Definition: batch.c:380
#define ok(value,...)
Definition: atltest.h:57
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2145
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define PAGE_READONLY
Definition: compat.h:138
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
static int cmd_available(void)
Definition: batch.c:447
static LPCWSTR file_name
Definition: protocol.c:147
static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
Definition: batch.c:426
Definition: name.c:38
GLuint res
Definition: glext.h:9613
char * cleanup(char *str)
Definition: wpickclick.c:99
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:488
static char shortpath[MAX_PATH]
Definition: batch.c:32
static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:356
#define INFINITE
Definition: serial.h:102
#define UnmapViewOfFile
Definition: compat.h:494
#define memset(x, y, z)
Definition: compat.h:39
#define win_skip
Definition: test.h:149
HANDLE hStdError
Definition: winbase.h:826
#define HeapFree(x, y, z)
Definition: compat.h:483
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
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
static DWORD workdir_len
Definition: batch.c:27
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 GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum map
Definition: glfuncs.h:262
Definition: fci.c:126