ReactOS  0.4.14-dev-115-g4576127
path.c File Reference
#include "ntdll_test.h"
Include dependency graph for path.c:

Go to the source code of this file.

Functions

static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR dst
 
static UINT (WINAPI *pRtlDetermineDosPathNameType_U)(PCWSTR path)
 
static ULONG (WINAPI *pRtlIsDosDeviceName_U)(PCWSTR dos_name)
 
static BOOLEAN (WINAPI *pRtlIsNameLegalDOS8Dot3)(const UNICODE_STRING *
 
static DWORD (WINAPI *pRtlGetFullPathName_U)(const WCHAR *
 
static WCHAR WCHAR **static UNICODE_STRING WCHAR CURDIR *static void test_RtlDetermineDosPathNameType_U (void)
 
static void test_RtlIsDosDeviceName_U (void)
 
static void test_RtlIsNameLegalDOS8Dot3 (void)
 
static void test_RtlGetFullPathName_U (void)
 
static void test_RtlDosPathNameToNtPathName_U_WithStatus (void)
 
 START_TEST (path)
 

Variables

static DWORD dstlen
 
static DWORD LPDWORD reslen
 
static DWORD LPDWORD LPCSTR src
 
static DWORD LPDWORD LPCSTR DWORD srclen
 
static DWORD
 
static LPDWORD
 
static LPCWSTR
 
static const STRING BOOLEAN
 
static POEM_STRING
 
static PBOOLEAN
 
static ULONG
 

Function Documentation

◆ BOOLEAN()

static BOOLEAN ( WINAPI pRtlIsNameLegalDOS8Dot3) const
static

◆ DWORD()

static DWORD ( WINAPI pRtlGetFullPathName_U) const
static

◆ NTSTATUS()

static NTSTATUS ( WINAPI pRtlMultiByteToUnicodeN)
static

◆ START_TEST()

START_TEST ( path  )

Definition at line 377 of file path.c.

378 {
379  HMODULE mod = GetModuleHandleA("ntdll.dll");
380  if (!mod)
381  {
382  win_skip("Not running on NT, skipping tests\n");
383  return;
384  }
385 
386  pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
387  pRtlUnicodeToMultiByteN = (void *)GetProcAddress(mod,"RtlUnicodeToMultiByteN");
388  pRtlDetermineDosPathNameType_U = (void *)GetProcAddress(mod,"RtlDetermineDosPathNameType_U");
389  pRtlIsDosDeviceName_U = (void *)GetProcAddress(mod,"RtlIsDosDeviceName_U");
390  pRtlOemStringToUnicodeString = (void *)GetProcAddress(mod,"RtlOemStringToUnicodeString");
391  pRtlIsNameLegalDOS8Dot3 = (void *)GetProcAddress(mod,"RtlIsNameLegalDOS8Dot3");
392  pRtlGetFullPathName_U = (void *)GetProcAddress(mod,"RtlGetFullPathName_U");
393  pRtlDosPathNameToNtPathName_U_WithStatus = (void *)GetProcAddress(mod, "RtlDosPathNameToNtPathName_U_WithStatus");
394 
400 }
static void test_RtlGetFullPathName_U(void)
Definition: path.c:247
static void test_RtlDosPathNameToNtPathName_U_WithStatus(void)
Definition: path.c:348
static void test_RtlIsNameLegalDOS8Dot3(void)
Definition: path.c:170
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:821
static void test_RtlIsDosDeviceName_U(void)
Definition: path.c:93
#define GetProcAddress(x, y)
Definition: compat.h:410
static WCHAR WCHAR **static UNICODE_STRING WCHAR CURDIR *static void test_RtlDetermineDosPathNameType_U(void)
Definition: path.c:33
#define win_skip
Definition: test.h:141
static int mod
Definition: i386-dis.c:1273

◆ test_RtlDetermineDosPathNameType_U()

static WCHAR WCHAR** static UNICODE_STRING WCHAR CURDIR* static void test_RtlDetermineDosPathNameType_U ( void  )
static

Definition at line 33 of file path.c.

34 {
35  struct test
36  {
37  const char *path;
38  UINT ret;
39  };
40 
41  static const struct test tests[] =
42  {
43  { "\\\\foo", 1 },
44  { "//foo", 1 },
45  { "\\/foo", 1 },
46  { "/\\foo", 1 },
47  { "\\\\", 1 },
48  { "//", 1 },
49  { "c:\\foo", 2 },
50  { "c:/foo", 2 },
51  { "c://foo", 2 },
52  { "c:\\", 2 },
53  { "c:/", 2 },
54  { "c:foo", 3 },
55  { "c:f\\oo", 3 },
56  { "c:foo/bar", 3 },
57  { "\\foo", 4 },
58  { "/foo", 4 },
59  { "\\", 4 },
60  { "/", 4 },
61  { "foo", 5 },
62  { "", 5 },
63  { "\0:foo", 5 },
64  { "\\\\.\\foo", 6 },
65  { "//./foo", 6 },
66  { "/\\./foo", 6 },
67  { "\\\\.foo", 1 },
68  { "//.foo", 1 },
69  { "\\\\.", 7 },
70  { "//.", 7 },
71  { NULL, 0 }
72  };
73 
74  const struct test *test;
76  UINT ret;
77 
78  if (!pRtlDetermineDosPathNameType_U)
79  {
80  win_skip("RtlDetermineDosPathNameType_U is not available\n");
81  return;
82  }
83 
84  for (test = tests; test->path; test++)
85  {
86  pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
87  ret = pRtlDetermineDosPathNameType_U( buffer );
88  ok( ret == test->ret, "Wrong result %d/%d for %s\n", ret, test->ret, test->path );
89  }
90 }
struct param_test tests[]
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLuint buffer
Definition: glext.h:5915
#define test
Definition: rosglue.h:37
DWORD ret
Definition: path.c:47
smooth NULL
Definition: ftsmooth.c:416
const char * path
Definition: path.c:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:26
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define win_skip
Definition: test.h:141

Referenced by START_TEST().

◆ test_RtlDosPathNameToNtPathName_U_WithStatus()

static void test_RtlDosPathNameToNtPathName_U_WithStatus ( void  )
static

Definition at line 348 of file path.c.

349 {
350  static const WCHAR emptyW[] = { 0 };
354 
355  if (!pRtlDosPathNameToNtPathName_U_WithStatus)
356  {
357  win_skip("RtlDosPathNameToNtPathName_U_WithStatus() is not supported.\n");
358  return;
359  }
360 
362 
363  status = pRtlDosPathNameToNtPathName_U_WithStatus( path, &nameW, NULL, NULL );
364  ok(!status, "Failed convert to nt path, %#x.\n", status);
365 
366  status = pRtlDosPathNameToNtPathName_U_WithStatus( NULL, &nameW, NULL, NULL );
368  "Unexpected status %#x.\n", status);
369 
370  status = pRtlDosPathNameToNtPathName_U_WithStatus( emptyW, &nameW, NULL, NULL );
372  "Unexpected status %#x.\n", status);
373 
375 }
LONG NTSTATUS
Definition: precomp.h:26
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR nameW[]
Definition: main.c:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:26
#define STATUS_OBJECT_PATH_NOT_FOUND
Definition: udferr_usr.h:151
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define broken(x)
Definition: _sntprintf.h:21
static const WCHAR emptyW[]
Definition: navigate.c:36
#define ok(value,...)
Definition: atltest.h:57
Definition: services.c:325
#define STATUS_OBJECT_NAME_INVALID
Definition: udferr_usr.h:148
DWORD WINAPI GetCurrentDirectoryW(IN DWORD nBufferLength, OUT LPWSTR lpBuffer)
Definition: path.c:2194
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:141
Definition: ps.c:97

Referenced by START_TEST().

◆ test_RtlGetFullPathName_U()

static void test_RtlGetFullPathName_U ( void  )
static

Definition at line 247 of file path.c.

248 {
249  static const WCHAR emptyW[] = {0};
250  static const WCHAR deadbeefW[] = {'d','e','a','d','b','e','e','f',0};
251 
252  struct test
253  {
254  const char *path;
255  const char *rname;
256  const char *rfile;
257  const char *alt_rname;
258  const char *alt_rfile;
259  };
260 
261  static const struct test tests[] =
262  {
263  { "c:/test", "c:\\test", "test"},
264  { "c:/test ", "c:\\test", "test"},
265  { "c:/test.", "c:\\test", "test"},
266  { "c:/test .... .. ", "c:\\test", "test"},
267  { "c:/test/ .... .. ", "c:\\test\\", NULL},
268  { "c:/test/..", "c:\\", NULL},
269  { "c:/test/.. ", "c:\\test\\", NULL},
270  { "c:/TEST", "c:\\TEST", "TEST"},
271  { "c:/test/file", "c:\\test\\file", "file"},
272  { "c:/test./file", "c:\\test\\file", "file"},
273  { "c:/test.. /file", "c:\\test.. \\file","file"},
274  { "c:/test/././file", "c:\\test\\file", "file"},
275  { "c:/test\\.\\.\\file", "c:\\test\\file", "file"},
276  { "c:/test/\\.\\.\\file", "c:\\test\\file", "file"},
277  { "c:/test\\\\.\\.\\file", "c:\\test\\file", "file"},
278  { "c:/test\\test1\\..\\.\\file", "c:\\test\\file", "file"},
279  { "c:///test\\.\\.\\file//", "c:\\test\\file\\", NULL,
280  "c:\\test\\file", "file"}, /* nt4 */
281  { "c:///test\\..\\file\\..\\//", "c:\\", NULL},
282  { "c:/test../file", "c:\\test.\\file", "file",
283  "c:\\test..\\file", "file"}, /* vista */
284  { "c:\\test", "c:\\test", "test"},
285  { NULL, NULL, NULL}
286  };
287 
288  const struct test *test;
289  WCHAR pathbufW[2*MAX_PATH], rbufferW[MAX_PATH];
290  CHAR rbufferA[MAX_PATH], rfileA[MAX_PATH];
291  ULONG ret;
292  WCHAR *file_part;
293  DWORD reslen;
294  UINT len;
295 
296  if (!pRtlGetFullPathName_U)
297  {
298  win_skip("RtlGetFullPathName_U is not available\n");
299  return;
300  }
301 
302  file_part = (WCHAR *)0xdeadbeef;
303  lstrcpyW(rbufferW, deadbeefW);
304  ret = pRtlGetFullPathName_U(NULL, MAX_PATH, rbufferW, &file_part);
305  ok(!ret, "Expected RtlGetFullPathName_U to return 0, got %u\n", ret);
306  ok(!lstrcmpW(rbufferW, deadbeefW),
307  "Expected the output buffer to be untouched, got %s\n", wine_dbgstr_w(rbufferW));
308  ok(file_part == (WCHAR *)0xdeadbeef ||
309  file_part == NULL, /* Win7 */
310  "Expected file part pointer to be untouched, got %p\n", file_part);
311 
312  file_part = (WCHAR *)0xdeadbeef;
313  lstrcpyW(rbufferW, deadbeefW);
314  ret = pRtlGetFullPathName_U(emptyW, MAX_PATH, rbufferW, &file_part);
315  ok(!ret, "Expected RtlGetFullPathName_U to return 0, got %u\n", ret);
316  ok(!lstrcmpW(rbufferW, deadbeefW),
317  "Expected the output buffer to be untouched, got %s\n", wine_dbgstr_w(rbufferW));
318  ok(file_part == (WCHAR *)0xdeadbeef ||
319  file_part == NULL, /* Win7 */
320  "Expected file part pointer to be untouched, got %p\n", file_part);
321 
322  for (test = tests; test->path; test++)
323  {
324  len= strlen(test->rname) * sizeof(WCHAR);
325  pRtlMultiByteToUnicodeN(pathbufW , sizeof(pathbufW), NULL, test->path, strlen(test->path)+1 );
326  ret = pRtlGetFullPathName_U( pathbufW,MAX_PATH, rbufferW, &file_part);
327  ok( ret == len || (test->alt_rname && ret == strlen(test->alt_rname)*sizeof(WCHAR)),
328  "Wrong result %d/%d for \"%s\"\n", ret, len, test->path );
329  ok(pRtlUnicodeToMultiByteN(rbufferA,MAX_PATH,&reslen,rbufferW,(lstrlenW(rbufferW) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
330  "RtlUnicodeToMultiByteN failed\n");
331  ok(!lstrcmpA(rbufferA,test->rname) || (test->alt_rname && !lstrcmpA(rbufferA,test->alt_rname)),
332  "Got \"%s\" expected \"%s\"\n",rbufferA,test->rname);
333  if (file_part)
334  {
335  ok(pRtlUnicodeToMultiByteN(rfileA,MAX_PATH,&reslen,file_part,(lstrlenW(file_part) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
336  "RtlUnicodeToMultiByteN failed\n");
337  ok((test->rfile && !lstrcmpA(rfileA,test->rfile)) ||
338  (test->alt_rfile && !lstrcmpA(rfileA,test->alt_rfile)),
339  "Got \"%s\" expected \"%s\"\n",rfileA,test->rfile);
340  }
341  else
342  {
343  ok( !test->rfile, "Got NULL expected \"%s\"\n", test->rfile );
344  }
345  }
346 }
struct param_test tests[]
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
char CHAR
Definition: xmlstorage.h:175
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
#define test
Definition: rosglue.h:37
#define lstrlenW
Definition: compat.h:407
DWORD ret
Definition: path.c:47
static DWORD LPDWORD reslen
Definition: path.c:23
smooth NULL
Definition: ftsmooth.c:416
const char * path
Definition: path.c:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:26
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLsizei len
Definition: glext.h:6722
static const WCHAR emptyW[]
Definition: navigate.c:36
#define lstrcpyW
Definition: compat.h:406
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define win_skip
Definition: test.h:141

Referenced by START_TEST().

◆ test_RtlIsDosDeviceName_U()

static void test_RtlIsDosDeviceName_U ( void  )
static

Definition at line 93 of file path.c.

94 {
95  struct test
96  {
97  const char *path;
98  WORD pos;
99  WORD len;
100  BOOL fails;
101  };
102 
103  static const struct test tests[] =
104  {
105  { "\\\\.\\CON", 8, 6, TRUE }, /* fails on win8 */
106  { "\\\\.\\con", 8, 6, TRUE }, /* fails on win8 */
107  { "\\\\.\\CON2", 0, 0 },
108  { "", 0, 0 },
109  { "\\\\foo\\nul", 0, 0 },
110  { "c:\\nul:", 6, 6 },
111  { "c:\\nul\\", 0, 0 },
112  { "c:\\nul\\foo", 0, 0 },
113  { "c:\\nul::", 6, 6, TRUE }, /* fails on nt4 */
114  { "c:\\nul::::::", 6, 6, TRUE }, /* fails on nt4 */
115  { "c:prn ", 4, 6 },
116  { "c:prn.......", 4, 6 },
117  { "c:prn... ...", 4, 6 },
118  { "c:NUL .... ", 4, 6, TRUE }, /* fails on nt4 */
119  { "c: . . .", 0, 0 },
120  { "c:", 0, 0 },
121  { " . . . :", 0, 0 },
122  { ":", 0, 0 },
123  { "c:nul. . . :", 4, 6 },
124  { "c:nul . . :", 4, 6, TRUE }, /* fails on nt4 */
125  { "c:nul0", 0, 0 },
126  { "c:prn:aaa", 4, 6, TRUE }, /* fails on win9x */
127  { "c:PRN:.txt", 4, 6 },
128  { "c:aux:.txt...", 4, 6 },
129  { "c:prn:.txt:", 4, 6 },
130  { "c:nul:aaa", 4, 6, TRUE }, /* fails on win9x */
131  { "con:", 0, 6 },
132  { "lpt1:", 0, 8 },
133  { "c:com5:", 4, 8 },
134  { "CoM4:", 0, 8 },
135  { "lpt9:", 0, 8 },
136  { "c:\\lpt0.txt", 0, 0 },
137  { "c:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
138  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
139  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
140  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
141  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
142  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
143  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\nul.txt", 1000, 6 },
144  // ReactOS r54114
145  { "c:\\nul", 6, 6 },
146  { NULL, 0 }
147  };
148 
149  const struct test *test;
150  WCHAR buffer[2000];
151  ULONG ret;
152 
153  if (!pRtlIsDosDeviceName_U)
154  {
155  win_skip("RtlIsDosDeviceName_U is not available\n");
156  return;
157  }
158 
159  for (test = tests; test->path; test++)
160  {
161  pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
162  ret = pRtlIsDosDeviceName_U( buffer );
163  ok( ret == MAKELONG( test->len, test->pos ) ||
164  (test->fails && broken( ret == 0 )),
165  "Wrong result (%d,%d)/(%d,%d) for %s\n",
166  HIWORD(ret), LOWORD(ret), test->pos, test->len, test->path );
167  }
168 }
struct param_test tests[]
#define TRUE
Definition: types.h:120
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLuint buffer
Definition: glext.h:5915
#define test
Definition: rosglue.h:37
DWORD ret
Definition: path.c:47
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MAKELONG(a, b)
Definition: typedefs.h:248
smooth NULL
Definition: ftsmooth.c:416
const char * path
Definition: path.c:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned short WORD
Definition: ntddk_ex.h:93
GLenum GLsizei len
Definition: glext.h:6722
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
#define HIWORD(l)
Definition: typedefs.h:246
unsigned int ULONG
Definition: retypes.h:1
#define win_skip
Definition: test.h:141
#define LOWORD(l)
Definition: pedump.c:82

Referenced by START_TEST().

◆ test_RtlIsNameLegalDOS8Dot3()

static void test_RtlIsNameLegalDOS8Dot3 ( void  )
static

Definition at line 170 of file path.c.

171 {
172  struct test
173  {
174  const char *path;
175  BOOLEAN result;
176  BOOLEAN spaces;
177  };
178 
179  static const struct test tests[] =
180  {
181  { "12345678", TRUE, FALSE },
182  { "123 5678", TRUE, TRUE },
183  { "12345678.", FALSE, 2 /*not set*/ },
184  { "1234 678.", FALSE, 2 /*not set*/ },
185  { "12345678.a", TRUE, FALSE },
186  { "12345678.a ", FALSE, 2 /*not set*/ },
187  { "12345678.a c", TRUE, TRUE },
188  { " 2345678.a ", FALSE, 2 /*not set*/ },
189  { "1 345678.abc", TRUE, TRUE },
190  { "1 8.a c", TRUE, TRUE },
191  { "1 3 5 7 .abc", FALSE, 2 /*not set*/ },
192  { "12345678. c", TRUE, TRUE },
193  { "123456789.a", FALSE, 2 /*not set*/ },
194  { "12345.abcd", FALSE, 2 /*not set*/ },
195  { "12345.ab d", FALSE, 2 /*not set*/ },
196  { ".abc", FALSE, 2 /*not set*/ },
197  { "12.abc.d", FALSE, 2 /*not set*/ },
198  { ".", TRUE, FALSE },
199  { "..", TRUE, FALSE },
200  { "...", FALSE, 2 /*not set*/ },
201  { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", FALSE, 2 /*not set*/ },
202  { NULL, 0 }
203  };
204 
205  const struct test *test;
206  UNICODE_STRING ustr;
207  OEM_STRING oem, oem_ret;
208  WCHAR buffer[200];
209  char buff2[12];
210  BOOLEAN ret, spaces;
211 
212  if (!pRtlIsNameLegalDOS8Dot3)
213  {
214  win_skip("RtlIsNameLegalDOS8Dot3 is not available\n");
215  return;
216  }
217 
218  ustr.MaximumLength = sizeof(buffer);
219  ustr.Buffer = buffer;
220  for (test = tests; test->path; test++)
221  {
222  char path[100];
223  strcpy(path, test->path);
224  oem.Buffer = path;
225  oem.Length = strlen(test->path);
226  oem.MaximumLength = oem.Length + 1;
227  pRtlOemStringToUnicodeString( &ustr, &oem, FALSE );
228  spaces = 2;
229  oem_ret.Length = oem_ret.MaximumLength = sizeof(buff2);
230  oem_ret.Buffer = buff2;
231  ret = pRtlIsNameLegalDOS8Dot3( &ustr, &oem_ret, &spaces );
232  ok( ret == test->result, "Wrong result %d/%d for '%s'\n", ret, test->result, test->path );
233  ok( spaces == test->spaces, "Wrong spaces value %d/%d for '%s'\n", spaces, test->spaces, test->path );
234  if (strlen(test->path) <= 12)
235  {
236  char str[13];
237  int i;
238  strcpy( str, test->path );
239  for (i = 0; str[i]; i++) str[i] = toupper(str[i]);
240  ok( oem_ret.Length == strlen(test->path), "Wrong length %d/%d for '%s'\n",
241  oem_ret.Length, lstrlenA(test->path), test->path );
242  ok( !memcmp( oem_ret.Buffer, str, oem_ret.Length ),
243  "Wrong string '%.*s'/'%s'\n", oem_ret.Length, oem_ret.Buffer, str );
244  }
245  }
246 }
struct param_test tests[]
#define TRUE
Definition: types.h:120
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
USHORT MaximumLength
Definition: env_spec_w32.h:370
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLuint buffer
Definition: glext.h:5915
#define test
Definition: rosglue.h:37
STRING OEM_STRING
Definition: umtypes.h:203
DWORD ret
Definition: path.c:47
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
const char * result
Definition: path.c:169
const WCHAR * str
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
const char * path
Definition: path.c:46
int toupper(int c)
Definition: utclib.c:881
__wchar_t WCHAR
Definition: xmlstorage.h:180
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define ok(value,...)
Definition: atltest.h:57
Definition: services.c:325
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define win_skip
Definition: test.h:141

Referenced by START_TEST().

◆ UINT()

static UINT ( WINAPI pRtlDetermineDosPathNameType_U)
static

◆ ULONG()

static ULONG ( WINAPI pRtlIsDosDeviceName_U)
static

Variable Documentation

◆ BOOLEAN

Definition at line 28 of file path.c.

◆ dstlen

DWORD dstlen

Definition at line 23 of file path.c.

◆ DWORD

Definition at line 25 of file path.c.

◆ LPCWSTR

Definition at line 25 of file path.c.

◆ LPDWORD

Definition at line 25 of file path.c.

◆ PBOOLEAN

Definition at line 29 of file path.c.

◆ POEM_STRING

Definition at line 29 of file path.c.

◆ reslen

DWORD LPDWORD reslen

Definition at line 23 of file path.c.

Referenced by test_RtlGetFullPathName_U().

◆ src

Definition at line 23 of file path.c.

Referenced by PathCreateFromUrlW().

◆ srclen

Definition at line 23 of file path.c.

◆ ULONG

Definition at line 30 of file path.c.