ReactOS  0.4.12-dev-914-g71f84a3
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 = sizeof(drive)/sizeof(drive[0]);
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  *new_size = strlen(new_data);
75  return new_data;
76 }
77 
78 static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
79 {
80  SECURITY_ATTRIBUTES sa = {sizeof(sa), 0, TRUE};
81  char command[] = "test.cmd";
82  STARTUPINFOA si = {sizeof(si)};
84  HANDLE file,fileerr;
85  DWORD size;
86  BOOL bres;
87 
88  file = CreateFileA("test.cmd", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
90  ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
92  return FALSE;
93 
94  bres = WriteFile(file, cmd_data, cmd_size, &size, NULL);
96  ok(bres, "Could not write to file: %u\n", GetLastError());
97  if(!bres)
98  return FALSE;
99 
102  ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
104  return FALSE;
105 
108  ok(fileerr != INVALID_HANDLE_VALUE, "CreateFile stderr failed\n");
109  if(fileerr == INVALID_HANDLE_VALUE)
110  return FALSE;
111 
113  si.hStdOutput = file;
114  si.hStdError = fileerr;
115  bres = CreateProcessA(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
116  ok(bres, "CreateProcess failed: %u\n", GetLastError());
117  if(!bres) {
118  DeleteFileA("test.out");
119  return FALSE;
120  }
121 
122  WaitForSingleObject(pi.hProcess, INFINITE);
123  CloseHandle(pi.hThread);
124  CloseHandle(pi.hProcess);
125  CloseHandle(file);
126  CloseHandle(fileerr);
127  DeleteFileA("test.cmd");
128  return TRUE;
129 }
130 
131 static DWORD map_file(const char *file_name, const char **ret)
132 {
133  HANDLE file, map;
134  DWORD size;
135 
137  ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %08x\n", GetLastError());
139  return 0;
140 
142 
144  CloseHandle(file);
145  ok(map != NULL, "CreateFileMappingA(%s) failed: %u\n", file_name, GetLastError());
146  if(!map)
147  return 0;
148 
149  *ret = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
150  ok(*ret != NULL, "MapViewOfFile failed: %u\n", GetLastError());
151  CloseHandle(map);
152  if(!*ret)
153  return 0;
154 
155  return size;
156 }
157 
158 static const char *compare_line(const char *out_line, const char *out_end, const char *exp_line,
159  const char *exp_end)
160 {
161  const char *out_ptr = out_line, *exp_ptr = exp_line;
162  const char *err = NULL;
163 
164  static const char pwd_cmd[] = {'@','p','w','d','@'};
165  static const char drive_cmd[] = {'@','d','r','i','v','e','@'};
166  static const char path_cmd[] = {'@','p','a','t','h','@'};
167  static const char shortpath_cmd[] = {'@','s','h','o','r','t','p','a','t','h','@'};
168  static const char space_cmd[] = {'@','s','p','a','c','e','@'};
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
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
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
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
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(tab_cmd) <= exp_end
228  && !memcmp(exp_ptr, tab_cmd, sizeof(tab_cmd))) {
229  exp_ptr += sizeof(tab_cmd);
230  if(out_ptr < out_end && *out_ptr == '\t') {
231  out_ptr++;
232  continue;
233  } else {
234  err = out_end;
235  }
236  }else if(exp_ptr+sizeof(or_broken_cmd) <= exp_end
237  && !memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd))) {
238  if(out_ptr == out_end)
239  return NULL;
240  else
241  err = out_ptr;
242  }else if(out_ptr == out_end || *out_ptr != *exp_ptr)
243  err = out_ptr;
244  }else if(out_ptr == out_end || *out_ptr != *exp_ptr) {
245  err = out_ptr;
246  }
247 
248  if(err) {
249  if(!broken(1))
250  return err;
251 
252  while(exp_ptr+sizeof(or_broken_cmd) <= exp_end && memcmp(exp_ptr, or_broken_cmd, sizeof(or_broken_cmd)))
253  exp_ptr++;
254  if(!exp_ptr)
255  return err;
256 
257  exp_ptr += sizeof(or_broken_cmd);
258  out_ptr = out_line;
259  err = NULL;
260  continue;
261  }
262 
263  exp_ptr++;
264  out_ptr++;
265  }
266 
267  if(exp_ptr != exp_end)
268  return out_ptr;
269  else if(out_ptr != out_end)
270  return exp_end;
271 
272  return NULL;
273 }
274 
275 static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
276 {
277  const char *out_ptr = out_data, *exp_ptr = exp_data, *out_nl, *exp_nl, *err = NULL;
278  DWORD line = 0;
279  static const char todo_wine_cmd[] = {'@','t','o','d','o','_','w','i','n','e','@'};
280  static const char resync_cmd[] = {'-','-','-'};
281  BOOL is_todo_wine, is_out_resync = FALSE, is_exp_resync = FALSE;
282 
283  while(out_ptr < out_data+out_size && exp_ptr < exp_data+exp_size) {
284  line++;
285 
286  for(exp_nl = exp_ptr; exp_nl < exp_data+exp_size && *exp_nl != '\r' && *exp_nl != '\n'; exp_nl++);
287  for(out_nl = out_ptr; out_nl < out_data+out_size && *out_nl != '\r' && *out_nl != '\n'; out_nl++);
288 
289  is_todo_wine = (exp_ptr+sizeof(todo_wine_cmd) <= exp_nl &&
290  !memcmp(exp_ptr, todo_wine_cmd, sizeof(todo_wine_cmd)));
291  if (is_todo_wine)
292  exp_ptr += sizeof(todo_wine_cmd);
293 
294  todo_wine_if(is_todo_wine)
295  {
296  is_exp_resync=(exp_ptr+sizeof(resync_cmd) <= exp_nl &&
297  !memcmp(exp_ptr, resync_cmd, sizeof(resync_cmd)));
298  is_out_resync=(out_ptr+sizeof(resync_cmd) <= out_nl &&
299  !memcmp(out_ptr, resync_cmd, sizeof(resync_cmd)));
300 
301  err = compare_line(out_ptr, out_nl, exp_ptr, exp_nl);
302  if(err == out_nl)
303  ok(0, "unexpected end of line %d (got '%.*s', wanted '%.*s')\n",
304  line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
305  else if(err == exp_nl)
306  ok(0, "excess characters on line %d (got '%.*s', wanted '%.*s')\n",
307  line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
308  else if (!err && is_todo_wine && is_out_resync && is_exp_resync)
309  /* Consider that the todo_wine was to deal with extra lines,
310  * not for the resync line itself
311  */
312  err = NULL;
313  else
314  ok(!err, "unexpected char 0x%x position %d in line %d (got '%.*s', wanted '%.*s')\n",
315  (err ? *err : 0), (err ? (int)(err-out_ptr) : -1), line, (int)(out_nl-out_ptr), out_ptr, (int)(exp_nl-exp_ptr), exp_ptr);
316  }
317 
318  if (is_exp_resync && err && is_todo_wine)
319  {
320  exp_ptr -= sizeof(todo_wine_cmd);
321  /* If we rewind to the beginning of the line, don't increment line number */
322  line--;
323  }
324  else if (!is_exp_resync || !err ||
325  (is_exp_resync && is_out_resync && err))
326  {
327  exp_ptr = exp_nl+1;
328  if(exp_nl+1 < exp_data+exp_size && exp_nl[0] == '\r' && exp_nl[1] == '\n')
329  exp_ptr++;
330  }
331 
332  if (!is_out_resync || !err)
333  {
334  out_ptr = out_nl+1;
335  if(out_nl+1 < out_data+out_size && out_nl[0] == '\r' && out_nl[1] == '\n')
336  out_ptr++;
337  }
338  }
339 
340  ok(exp_ptr >= exp_data+exp_size, "unexpected end of output in line %d, missing %s\n", line, exp_ptr);
341  ok(out_ptr >= out_data+out_size, "too long output, got additional %s\n", out_ptr);
342 }
343 
344 static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
345 {
346  const char *out_data, *actual_cmd_data;
347  DWORD out_size, actual_cmd_size;
348 
349  actual_cmd_data = convert_input_data(cmd_data, cmd_size, &actual_cmd_size);
350  if(!actual_cmd_size || !actual_cmd_data)
351  goto cleanup;
352 
353  if(!run_cmd(actual_cmd_data, actual_cmd_size))
354  goto cleanup;
355 
356  out_size = map_file("test.out", &out_data);
357  if(out_size) {
358  test_output(out_data, out_size, exp_data, exp_size);
359  UnmapViewOfFile(out_data);
360  }
361  DeleteFileA("test.out");
362  DeleteFileA("test.err");
363 
364 cleanup:
365  HeapFree(GetProcessHeap(), 0, (LPVOID)actual_cmd_data);
366 }
367 
368 static void run_from_file(const char *file_name)
369 {
370  char out_name[MAX_PATH];
371  const char *test_data, *out_data;
373 
375  if(!test_size) {
376  ok(0, "Could not map file %s: %u\n", file_name, GetLastError());
377  return;
378  }
379 
380  sprintf(out_name, "%s.exp", file_name);
381  out_size = map_file(out_name, &out_data);
382  if(!out_size) {
383  ok(0, "Could not map file %s: %u\n", out_name, GetLastError());
385  return;
386  }
387 
388  run_test(test_data, test_size, out_data, out_size);
389 
391  UnmapViewOfFile(out_data);
392 }
393 
394 static DWORD load_resource(const char *name, const char *type, const char **ret)
395 {
396  const char *res;
397  HRSRC src;
398  DWORD size;
399 
401  ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError());
402  if(!src)
403  return 0;
404 
405  res = LoadResource(NULL, src);
407  while(size && !res[size-1])
408  size--;
409 
410  *ret = res;
411  return size;
412 }
413 
415 {
416  const char *cmd_data, *out_data;
417  DWORD cmd_size, out_size;
418  char res_name[100];
419 
420  trace("running %s test...\n", name);
421 
422  cmd_size = load_resource(name, type, &cmd_data);
423  if(!cmd_size)
424  return TRUE;
425 
426  sprintf(res_name, "%s.exp", name);
427  out_size = load_resource(res_name, "TESTOUT", &out_data);
428  if(!out_size)
429  return TRUE;
430 
431  run_test(cmd_data, cmd_size, out_data, out_size);
432  return TRUE;
433 }
434 
435 static int cmd_available(void)
436 {
437  STARTUPINFOA si;
439  char cmd[] = "cmd /c exit 0";
440 
441  memset(&si, 0, sizeof(si));
442  si.cb = sizeof(si);
443  if (CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
444  CloseHandle(pi.hThread);
445  CloseHandle(pi.hProcess);
446  return TRUE;
447  }
448  return FALSE;
449 }
450 
451 START_TEST(reactos)
452 {
453  int argc;
454  char **argv;
455 
456  if (!cmd_available()) {
457  win_skip("cmd not installed, skipping cmd tests\n");
458  return;
459  }
460 
462  drive[0] = workdir[0];
463  drive[1] = workdir[1]; /* Should be ':' */
464  memcpy(path, workdir + drive_len, (workdir_len - drive_len) * sizeof(drive[0]));
465 
466  /* Only add trailing backslash to 'path' for non-root directory */
467  if (workdir_len - drive_len > 1) {
468  path[workdir_len - drive_len] = '\\';
470  } else {
471  path_len = 1; /* \ */
472  }
474  sizeof(shortpath)/sizeof(shortpath[0]));
475 
477  if(argc > 2)
478  run_from_file(argv[2]);
479  else
480  EnumResourceNamesA(NULL, "TESTCMD", test_enum_proc, 0);
481 }
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
#define trace(...)
Definition: kmt_test.h:217
#define TRUE
Definition: types.h:120
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:398
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define MapViewOfFile
Definition: compat.h:402
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
Definition: ftp_var.h:139
static void test_output(const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:275
static DWORD map_file(const char *file_name, const char **ret)
Definition: batch.c:131
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:391
static DWORD shortpath_len
Definition: batch.c:33
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
DWORD dwFlags
Definition: winbase.h:807
#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:125
static DWORD load_resource(const char *name, const char *type, const char **ret)
Definition: batch.c:394
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
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:4866
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:427
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:158
#define OPEN_EXISTING
Definition: compat.h:426
static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
Definition: batch.c:78
#define ok(value,...)
Definition: CComObject.cpp:34
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: lang.c:2296
#define todo_wine_if(is_todo)
Definition: test.h:155
#define STARTF_USESTDHANDLES
Definition: winbase.h:480
START_TEST(reactos)
Definition: batch.c:451
GLsizeiptr size
Definition: glext.h:5919
DWORD cb
Definition: winbase.h:796
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
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:4772
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:26
#define WINAPI
Definition: msvc.h:8
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:812
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:481
Definition: _map.h:44
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int winetest_get_mainargs(char ***pargv)
static DWORD pi
Definition: protocol.c:150
int ret
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CSTR_EQUAL
Definition: winnls.h:453
#define GENERIC_READ
Definition: compat.h:124
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 char drive[2]
Definition: batch.c:28
static DWORD path_len
Definition: batch.c:31
static void run_from_file(const char *file_name)
Definition: batch.c:368
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2145
Definition: services.c:325
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define PAGE_READONLY
Definition: compat.h:127
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
static int cmd_available(void)
Definition: batch.c:435
static LPCWSTR file_name
Definition: protocol.c:146
static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
Definition: batch.c:414
Definition: name.c:36
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:399
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:344
#define INFINITE
Definition: serial.h:102
#define UnmapViewOfFile
Definition: compat.h:403
#define memset(x, y, z)
Definition: compat.h:39
#define win_skip
Definition: test.h:141
HANDLE hStdError
Definition: winbase.h:813
#define HeapFree(x, y, z)
Definition: compat.h:394
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