ReactOS  0.4.13-dev-563-g0561610
batch.c File Reference
#include <stdio.h>
#include <wine/test.h>
#include <winnls.h>
Include dependency graph for batch.c:

Go to the source code of this file.

Functions

static const charconvert_input_data (const char *data, DWORD size, DWORD *new_size)
 
static BOOL run_cmd (const char *cmd_data, DWORD cmd_size)
 
static DWORD map_file (const char *file_name, const char **ret)
 
static const charcompare_line (const char *out_line, const char *out_end, const char *exp_line, const char *exp_end)
 
static void test_output (const char *out_data, DWORD out_size, const char *exp_data, DWORD exp_size)
 
static void run_test (const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
 
static void run_from_file (const char *file_name)
 
static DWORD load_resource (const char *name, const char *type, const char **ret)
 
static BOOL WINAPI test_enum_proc (HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
 
static int cmd_available (void)
 
 START_TEST (reactos)
 

Variables

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
 

Function Documentation

◆ cmd_available()

static int cmd_available ( void  )
static

Definition at line 435 of file batch.c.

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 }
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:398
Definition: ftp_var.h:139
smooth NULL
Definition: ftsmooth.c:416
DWORD cb
Definition: winbase.h:796
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
static DWORD pi
Definition: protocol.c:150
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ compare_line()

static const char* compare_line ( const char out_line,
const char out_end,
const char exp_line,
const char exp_end 
)
static

Definition at line 158 of file batch.c.

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 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
static DWORD shortpath_len
Definition: batch.c:33
#define NORM_IGNORECASE
Definition: winnls.h:173
static const DWORD drive_len
Definition: batch.c:29
smooth NULL
Definition: ftsmooth.c:416
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: lang.c:2299
static char workdir[MAX_PATH]
Definition: batch.c:26
#define LOCALE_SYSTEM_DEFAULT
#define CSTR_EQUAL
Definition: winnls.h:453
#define err(...)
#define broken(x)
Definition: _sntprintf.h:21
static DWORD path_len
Definition: batch.c:31
Definition: services.c:325
static char shortpath[MAX_PATH]
Definition: batch.c:32
static DWORD workdir_len
Definition: batch.c:27

Referenced by test_output().

◆ convert_input_data()

static const char* convert_input_data ( const char data,
DWORD  size,
DWORD new_size 
)
static

Definition at line 36 of file batch.c.

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 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
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
static PVOID ptr
Definition: dispmode.c:27
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

Referenced by run_test().

◆ load_resource()

static DWORD load_resource ( const char name,
const char type,
const char **  ret 
)
static

Definition at line 394 of file batch.c.

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 }
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ok(value,...)
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
GLenum src
Definition: glext.h:6340
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
Definition: name.c:36
GLuint res
Definition: glext.h:9613

Referenced by test_enum_proc().

◆ map_file()

static DWORD map_file ( const char file_name,
const char **  ret 
)
static

Definition at line 131 of file batch.c.

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 }
#define CloseHandle
Definition: compat.h:398
#define MapViewOfFile
Definition: compat.h:402
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ok(value,...)
smooth NULL
Definition: ftsmooth.c:416
#define FILE_MAP_READ
Definition: compat.h:427
#define OPEN_EXISTING
Definition: compat.h:426
GLsizeiptr size
Definition: glext.h:5919
const char file[]
Definition: icontest.c:11
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:481
Definition: _map.h:44
int ret
#define GENERIC_READ
Definition: compat.h:124
#define PAGE_READONLY
Definition: compat.h:127
static LPCWSTR file_name
Definition: protocol.c:146
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:399
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
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

Referenced by run_from_file(), and run_test().

◆ run_cmd()

static BOOL run_cmd ( const char cmd_data,
DWORD  cmd_size 
)
static

Definition at line 78 of file batch.c.

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 }
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:398
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
DWORD dwFlags
Definition: winbase.h:807
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_SHARE_READ
Definition: compat.h:125
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
unsigned int BOOL
Definition: ntddk_ex.h:94
#define GENERIC_WRITE
Definition: nt_native.h:90
#define ok(value,...)
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
#define STARTF_USESTDHANDLES
Definition: winbase.h:480
GLsizeiptr size
Definition: glext.h:5919
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
const char file[]
Definition: icontest.c:11
unsigned long DWORD
Definition: ntddk_ex.h:95
HANDLE hStdOutput
Definition: winbase.h:812
static DWORD pi
Definition: protocol.c:150
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
#define CREATE_ALWAYS
Definition: disk.h:72
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:399
#define INFINITE
Definition: serial.h:102
HANDLE hStdError
Definition: winbase.h:813
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
Definition: fci.c:126

Referenced by run_test().

◆ run_from_file()

static void run_from_file ( const char file_name)
static

Definition at line 368 of file batch.c.

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 }
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
static DWORD map_file(const char *file_name, const char **ret)
Definition: batch.c:131
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static struct _test_data test_data[]
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define ok(value,...)
#define MAX_PATH
Definition: compat.h:26
unsigned long DWORD
Definition: ntddk_ex.h:95
static void test_size(void)
Definition: monthcal.c:1559
static LPCWSTR file_name
Definition: protocol.c:146
static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:344
#define UnmapViewOfFile
Definition: compat.h:403

Referenced by START_TEST().

◆ run_test()

static void run_test ( const char cmd_data,
DWORD  cmd_size,
const char exp_data,
DWORD  exp_size 
)
static

Definition at line 344 of file batch.c.

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 }
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
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
static const char * convert_input_data(const char *data, DWORD size, DWORD *new_size)
Definition: batch.c:36
struct ChNotifyTest * exp_data
Definition: shlfolder.c:4866
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
static BOOL run_cmd(const char *cmd_data, DWORD cmd_size)
Definition: batch.c:78
#define GetProcessHeap()
Definition: compat.h:395
unsigned long DWORD
Definition: ntddk_ex.h:95
char * cleanup(char *str)
Definition: wpickclick.c:99
#define UnmapViewOfFile
Definition: compat.h:403
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by run_from_file(), and test_enum_proc().

◆ START_TEST()

START_TEST ( reactos  )

Definition at line 451 of file batch.c.

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 }
static int argc
Definition: ServiceArgs.c:12
static DWORD shortpath_len
Definition: batch.c:33
BOOL WINAPI EnumResourceNamesA(HMODULE hmod, LPCSTR type, ENUMRESNAMEPROCA lpfun, LONG_PTR lparam)
Definition: res.c:285
#define argv
Definition: mplay32.c:18
static const DWORD drive_len
Definition: batch.c:29
smooth NULL
Definition: ftsmooth.c:416
static char workdir[MAX_PATH]
Definition: batch.c:26
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1751
int winetest_get_mainargs(char ***pargv)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
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
static int cmd_available(void)
Definition: batch.c:435
static BOOL WINAPI test_enum_proc(HMODULE module, LPCSTR type, LPSTR name, LONG_PTR param)
Definition: batch.c:414
static char shortpath[MAX_PATH]
Definition: batch.c:32
#define win_skip
Definition: test.h:141
static DWORD workdir_len
Definition: batch.c:27

◆ test_enum_proc()

static BOOL WINAPI test_enum_proc ( HMODULE  module,
LPCSTR  type,
LPSTR  name,
LONG_PTR  param 
)
static

Definition at line 414 of file batch.c.

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 }
#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
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static DWORD load_resource(const char *name, const char *type, const char **ret)
Definition: batch.c:394
#define sprintf(buf, format,...)
Definition: sprintf.c:55
unsigned long DWORD
Definition: ntddk_ex.h:95
Definition: name.c:36
static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)
Definition: batch.c:344

Referenced by START_TEST().

◆ test_output()

static void test_output ( const char out_data,
DWORD  out_size,
const char exp_data,
DWORD  exp_size 
)
static

Definition at line 275 of file batch.c.

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 }
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
unsigned int BOOL
Definition: ntddk_ex.h:94
struct ChNotifyTest * exp_data
Definition: shlfolder.c:4866
#define ok(value,...)
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
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 todo_wine_if(is_todo)
Definition: test.h:155
unsigned long DWORD
Definition: ntddk_ex.h:95
#define err(...)

Referenced by run_test().

Variable Documentation

◆ drive

◆ drive_len

const DWORD drive_len = sizeof(drive)/sizeof(drive[0])
static

Definition at line 29 of file batch.c.

Referenced by compare_line(), and START_TEST().

◆ path

char path[MAX_PATH]
static

Definition at line 30 of file batch.c.

◆ path_len

◆ shortpath

char shortpath[MAX_PATH]
static

Definition at line 32 of file batch.c.

Referenced by compare_line(), get_long_path_name(), START_TEST(), and test_GetLongPathNameW().

◆ shortpath_len

DWORD shortpath_len
static

Definition at line 33 of file batch.c.

Referenced by compare_line(), and START_TEST().

◆ workdir

◆ workdir_len

DWORD workdir_len
static

Definition at line 27 of file batch.c.

Referenced by compare_line(), and START_TEST().