ReactOS 0.4.16-dev-1305-ge26ad0d
dir.c
Go to the documentation of this file.
1/*
2 * Unit test suite for dir functions
3 *
4 * Copyright 2006 CodeWeavers, Aric Stewart
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include "wine/test.h"
22#include <stdarg.h>
23#include <stdlib.h>
24#include <stdio.h>
25#include <fcntl.h>
26#include <direct.h>
27#include <sys/stat.h>
28#include <io.h>
29#include <mbctype.h>
30#include <windef.h>
31#include <winbase.h>
32#include <winnls.h>
33#include <process.h>
34#include <errno.h>
35
36static int (__cdecl *p_makepath_s)(char *, size_t, const char *, const char *, const char *, const char *);
37static int (__cdecl *p_wmakepath_s)(wchar_t *, size_t, const wchar_t *,const wchar_t *, const wchar_t *, const wchar_t *);
38static int (__cdecl *p_searchenv_s)(const char*, const char*, char*, size_t);
39static int (__cdecl *p_wsearchenv_s)(const wchar_t*, const wchar_t*, wchar_t*, size_t);
40
41static void init(void)
42{
43 HMODULE hmod = GetModuleHandleA("msvcrt.dll");
44
45 p_makepath_s = (void *)GetProcAddress(hmod, "_makepath_s");
46 p_wmakepath_s = (void *)GetProcAddress(hmod, "_wmakepath_s");
47 p_searchenv_s = (void *)GetProcAddress(hmod, "_searchenv_s");
48 p_wsearchenv_s = (void *)GetProcAddress(hmod, "_wsearchenv_s");
49}
50
51typedef struct
52{
53 const char* buffer;
54 const char* drive;
55 const char* dir;
56 const char* file;
57 const char* ext;
58 const char* expected;
59} makepath_case;
60
61#define USE_BUFF ((char*)~0ul)
62static const makepath_case makepath_cases[] =
63{
64 { NULL, NULL, NULL, NULL, NULL, "" }, /* 0 */
65 { NULL, "c", NULL, NULL, NULL, "c:" },
66 { NULL, "c:", NULL, NULL, NULL, "c:" },
67 { NULL, "c:\\", NULL, NULL, NULL, "c:" },
68 { NULL, NULL, "dir", NULL, NULL, "dir\\" },
69 { NULL, NULL, "dir\\", NULL, NULL, "dir\\" },
70 { NULL, NULL, "\\dir", NULL, NULL, "\\dir\\" },
71 { NULL, NULL, NULL, "file", NULL, "file" },
72 { NULL, NULL, NULL, "\\file", NULL, "\\file" },
73 { NULL, NULL, NULL, "file", NULL, "file" },
74 { NULL, NULL, NULL, NULL, "ext", ".ext" }, /* 10 */
75 { NULL, NULL, NULL, NULL, ".ext", ".ext" },
76 { "foo", NULL, NULL, NULL, NULL, "" },
77 { "foo", USE_BUFF, NULL, NULL, NULL, "f:" },
78 { "foo", NULL, USE_BUFF, NULL, NULL, "foo\\" },
79 { "foo", NULL, NULL, USE_BUFF, NULL, "foo" },
80 { "foo", NULL, USE_BUFF, "file", NULL, "foo\\file" },
81 { "foo", NULL, USE_BUFF, "file", "ext", "foo\\file.ext" },
82 { "foo", NULL, NULL, USE_BUFF, "ext", "foo.ext" },
83 /* remaining combinations of USE_BUFF crash native */
84 { NULL, "c", "dir", "file", "ext", "c:dir\\file.ext" },
85 { NULL, "c:", "dir", "file", "ext", "c:dir\\file.ext" }, /* 20 */
86 { NULL, "c:\\", "dir", "file", "ext", "c:dir\\file.ext" }
87};
88
89static void test_makepath(void)
90{
91 WCHAR driveW[MAX_PATH];
92 WCHAR dirW[MAX_PATH];
93 WCHAR fileW[MAX_PATH];
94 WCHAR extW[MAX_PATH];
95 WCHAR bufferW[MAX_PATH];
96 char buffer[MAX_PATH];
97
98 unsigned int i, n;
99
100 for (i = 0; i < ARRAY_SIZE(makepath_cases); ++i)
101 {
102 const makepath_case* p = &makepath_cases[i];
103
104 memset(buffer, 'X', MAX_PATH);
105 if (p->buffer)
106 strcpy(buffer, p->buffer);
107
108 /* Ascii */
109 _makepath(buffer,
110 p->drive == USE_BUFF ? buffer : p->drive,
111 p->dir == USE_BUFF ? buffer : p->dir,
112 p->file == USE_BUFF? buffer : p->file,
113 p->ext == USE_BUFF ? buffer : p->ext);
114
115 buffer[MAX_PATH - 1] = '\0';
116 ok(!strcmp(p->expected, buffer), "got '%s' for case %d\n", buffer, i);
117
118 /* Unicode */
119 if (p->drive != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->drive, -1, driveW, MAX_PATH);
120 if (p->dir != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->dir, -1, dirW, MAX_PATH);
121 if (p->file != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->file, -1, fileW, MAX_PATH);
122 if (p->ext != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->ext, -1, extW, MAX_PATH);
123
124 memset(buffer, 0, MAX_PATH);
125 for (n = 0; n < MAX_PATH; ++n)
126 bufferW[n] = 'X';
127 if (p->buffer) MultiByteToWideChar( CP_ACP, 0, p->buffer, -1, bufferW, MAX_PATH);
128
129 _wmakepath(bufferW,
130 p->drive == USE_BUFF ? bufferW : p->drive ? driveW : NULL,
131 p->dir == USE_BUFF ? bufferW : p->dir ? dirW : NULL,
132 p->file == USE_BUFF? bufferW : p->file ? fileW : NULL,
133 p->ext == USE_BUFF ? bufferW : p->ext ? extW : NULL);
134
135 bufferW[MAX_PATH - 1] = '\0';
136 WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
137 ok(!strcmp(p->expected, buffer), "got '%s' for unicode case %d\n", buffer, i);
138 }
139}
140
141typedef struct
142{
143 const char* buffer;
144 size_t length;
145 const char* drive;
146 const char* dir;
147 const char* file;
148 const char* ext;
149 const char* expected;
150 const WCHAR *expected_unicode;
151 size_t expected_length;
152} makepath_s_case;
153
154static const makepath_s_case makepath_s_cases[] =
155{
156 /* Behavior with directory parameter containing backslash. */
157 {NULL, 1, "c:", "d\\", "file", "ext", "\0XXXXXXXXXXXX", L"\0XXXXXXXXXXXX", 13},
158 {NULL, 2, "c:", "d\\", "file", "ext", "\0XXXXXXXXXXXX", L"\0XXXXXXXXXXXX", 13},
159 {NULL, 3, "c:", "d\\", "file", "ext", "\0:XXXXXXXXXXX", L"\0:XXXXXXXXXXX", 13},
160 {NULL, 4, "c:", "d\\", "file", "ext", "\0:dXXXXXXXXXX", L"\0:dXXXXXXXXXX", 13},
161 {NULL, 5, "c:", "d\\", "file", "ext", "\0:d\\XXXXXXXXX", L"\0:d\\XXXXXXXXX", 13},
162 {NULL, 6, "c:", "d\\", "file", "ext", "\0:d\\fXXXXXXXX", L"\0:d\\fXXXXXXXX", 13},
163 {NULL, 7, "c:", "d\\", "file", "ext", "\0:d\\fiXXXXXXX", L"\0:d\\fiXXXXXXX", 13},
164 {NULL, 8, "c:", "d\\", "file", "ext", "\0:d\\filXXXXXX", L"\0:d\\filXXXXXX", 13},
165 {NULL, 9, "c:", "d\\", "file", "ext", "\0:d\\fileXXXXX", L"\0:d\\fileXXXXX", 13},
166 {NULL, 10, "c:", "d\\", "file", "ext", "\0:d\\file.XXXX", L"\0:d\\file.XXXX", 13},
167 {NULL, 11, "c:", "d\\", "file", "ext", "\0:d\\file.eXXX", L"\0:d\\file.eXXX", 13},
168 {NULL, 12, "c:", "d\\", "file", "ext", "\0:d\\file.exXX", L"\0:d\\file.exXX", 13},
169 /* Behavior with directory parameter lacking backslash. */
170 {NULL, 3, "c:", "dir", "f", "ext", "\0:XXXXXXXX", L"\0:XXXXXXXX", 10},
171 {NULL, 4, "c:", "dir", "f", "ext", "\0:dXXXXXXX", L"\0:dXXXXXXX", 10},
172 {NULL, 5, "c:", "dir", "f", "ext", "\0:diXXXXXX", L"\0:diXXXXXX", 10},
173 {NULL, 6, "c:", "dir", "f", "ext", "\0:dirXXXXX", L"\0:dirXXXXX", 10},
174 {NULL, 7, "c:", "dir", "f", "ext", "\0:dir\\XXXX", L"\0:dir\\XXXX", 10},
175 /* Behavior with overlapped buffer. */
176 {"foo", 2, USE_BUFF, NULL, NULL, NULL, "\0oo", L"\0oo", 3},
177 {"foo", 4, NULL, USE_BUFF, NULL, NULL, "\0oo\0X", L"\0oo\0X", 5},
178 {"foo", 3, NULL, NULL, USE_BUFF, NULL, "\0oo\0", L"\0oo", 4},
179 {"foo", 4, NULL, USE_BUFF, "file", NULL, "\0oo\0XXXXX", L"\0oo\0XXXXX", 9},
180 {"foo", 8, NULL, USE_BUFF, "file", NULL, "\0oo\\filXX", L"\0oo\\filXX", 9},
181 {"foo", 4, NULL, USE_BUFF, "file", "ext", "\0oo\0XXXXXXXXX", L"\0oo\0XXXXXXXXX", 13},
182 {"foo", 8, NULL, USE_BUFF, "file", "ext", "\0oo\\filXXXXXX", L"\0oo\\filXXXXXX", 13},
183 {"foo", 12, NULL, USE_BUFF, "file", "ext", "\0oo\\file.exXX", L"\0oo\\file.exXX", 13},
184 {"foo", 4, NULL, NULL, USE_BUFF, "ext", "\0oo\0XXXX", L"\0oo\0XXXX", 8},
185 {"foo", 7, NULL, NULL, USE_BUFF, "ext", "\0oo.exXX", L"\0oo.exXX", 8},
186};
187
188static void test_makepath_s(void)
189{
190 WCHAR driveW[MAX_PATH];
191 WCHAR dirW[MAX_PATH];
192 WCHAR fileW[MAX_PATH];
193 WCHAR extW[MAX_PATH];
194 WCHAR bufferW[MAX_PATH];
195 char buffer[MAX_PATH];
196 int ret;
197 unsigned int i, n;
198
199 if (!p_makepath_s || !p_wmakepath_s)
200 {
201 win_skip("Safe makepath functions are not available\n");
202 return;
203 }
204
205 errno = EBADF;
206 ret = p_makepath_s(NULL, 0, NULL, NULL, NULL, NULL);
207 ok(ret == EINVAL, "Expected _makepath_s to return EINVAL, got %d\n", ret);
208 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
209
210 errno = EBADF;
211 ret = p_makepath_s(buffer, 0, NULL, NULL, NULL, NULL);
212 ok(ret == EINVAL, "Expected _makepath_s to return EINVAL, got %d\n", ret);
213 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
214
215 errno = EBADF;
216 ret = p_wmakepath_s(NULL, 0, NULL, NULL, NULL, NULL);
217 ok(ret == EINVAL, "Expected _wmakepath_s to return EINVAL, got %d\n", ret);
218 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
219
220 errno = EBADF;
221 ret = p_wmakepath_s(bufferW, 0, NULL, NULL, NULL, NULL);
222 ok(ret == EINVAL, "Expected _wmakepath_s to return EINVAL, got %d\n", ret);
223 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
224
225 /* Test with the normal _makepath cases. */
226 for (i = 0; i < ARRAY_SIZE(makepath_cases); i++)
227 {
228 const makepath_case *p = makepath_cases + i;
229
230 memset(buffer, 'X', MAX_PATH);
231 if (p->buffer)
232 strcpy(buffer, p->buffer);
233
234 /* Ascii */
235 ret = p_makepath_s(buffer, MAX_PATH,
236 p->drive == USE_BUFF ? buffer : p->drive,
237 p->dir == USE_BUFF ? buffer : p->dir,
238 p->file == USE_BUFF? buffer : p->file,
239 p->ext == USE_BUFF ? buffer : p->ext);
240 ok(ret == 0, "[%d] Expected _makepath_s to return 0, got %d\n", i, ret);
241
242 buffer[MAX_PATH - 1] = '\0';
243 ok(!strcmp(p->expected, buffer), "got '%s' for case %d\n", buffer, i);
244
245 /* Unicode */
246 if (p->drive != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->drive, -1, driveW, MAX_PATH);
247 if (p->dir != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->dir, -1, dirW, MAX_PATH);
248 if (p->file != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->file, -1, fileW, MAX_PATH);
249 if (p->ext != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->ext, -1, extW, MAX_PATH);
250
251 memset(buffer, 0, MAX_PATH);
252 for (n = 0; n < MAX_PATH; ++n)
253 bufferW[n] = 'X';
254 if (p->buffer) MultiByteToWideChar( CP_ACP, 0, p->buffer, -1, bufferW, MAX_PATH);
255
256 ret = p_wmakepath_s(bufferW, MAX_PATH,
257 p->drive == USE_BUFF ? bufferW : p->drive ? driveW : NULL,
258 p->dir == USE_BUFF ? bufferW : p->dir ? dirW : NULL,
259 p->file == USE_BUFF? bufferW : p->file ? fileW : NULL,
260 p->ext == USE_BUFF ? bufferW : p->ext ? extW : NULL);
261 ok(ret == 0, "[%d] Expected _wmakepath_s to return 0, got %d\n", i, ret);
262
263 bufferW[MAX_PATH - 1] = '\0';
264 WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
265 ok(!strcmp(p->expected, buffer), "got '%s' for unicode case %d\n", buffer, i);
266 }
267
268 /* Try insufficient length cases. */
269 for (i = 0; i < ARRAY_SIZE(makepath_s_cases); i++)
270 {
271 const makepath_s_case *p = makepath_s_cases + i;
272
273 memset(buffer, 'X', MAX_PATH);
274 if (p->buffer)
275 strcpy(buffer, p->buffer);
276
277 /* Ascii */
278 errno = EBADF;
279 ret = p_makepath_s(buffer, p->length,
280 p->drive == USE_BUFF ? buffer : p->drive,
281 p->dir == USE_BUFF ? buffer : p->dir,
282 p->file == USE_BUFF? buffer : p->file,
283 p->ext == USE_BUFF ? buffer : p->ext);
284 ok(ret == ERANGE, "[%d] Expected _makepath_s to return ERANGE, got %d\n", i, ret);
285 ok(errno == ERANGE, "[%d] Expected errno to be ERANGE, got %d\n", i, errno);
286 ok(!memcmp(p->expected, buffer, p->expected_length), "unexpected output for case %d\n", i);
287
288 /* Unicode */
289 if (p->drive != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->drive, -1, driveW, MAX_PATH);
290 if (p->dir != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->dir, -1, dirW, MAX_PATH);
291 if (p->file != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->file, -1, fileW, MAX_PATH);
292 if (p->ext != USE_BUFF) MultiByteToWideChar(CP_ACP, 0, p->ext, -1, extW, MAX_PATH);
293
294 memset(buffer, 0, MAX_PATH);
295 for (n = 0; n < MAX_PATH; ++n)
296 bufferW[n] = 'X';
297 if (p->buffer) MultiByteToWideChar( CP_ACP, 0, p->buffer, -1, bufferW, MAX_PATH);
298
299 errno = EBADF;
300 ret = p_wmakepath_s(bufferW, p->length,
301 p->drive == USE_BUFF ? bufferW : p->drive ? driveW : NULL,
302 p->dir == USE_BUFF ? bufferW : p->dir ? dirW : NULL,
303 p->file == USE_BUFF? bufferW : p->file ? fileW : NULL,
304 p->ext == USE_BUFF ? bufferW : p->ext ? extW : NULL);
305 ok(ret == ERANGE, "[%d] Expected _wmakepath_s to return ERANGE, got %d\n", i, ret);
306 ok(errno == ERANGE, "[%d] Expected errno to be ERANGE, got %d\n", i, errno);
307
308 ok(!memcmp(p->expected_unicode, bufferW, p->expected_length * sizeof(WCHAR)), "unexpected output for case %d\n", i);
309 }
310}
311
312static void test_fullpath(void)
313{
314 char full[MAX_PATH];
315 char tmppath[MAX_PATH];
316 char prevpath[MAX_PATH];
317 char level1[MAX_PATH];
318 char level2[MAX_PATH];
319 char teststring[MAX_PATH];
320 char *freeme;
321 BOOL rc,free1,free2;
322
323 free1=free2=TRUE;
324 GetCurrentDirectoryA(MAX_PATH, prevpath);
325 GetTempPathA(MAX_PATH,tmppath);
326 strcpy(level1,tmppath);
327 strcat(level1,"msvcrt-test\\");
328
329 rc = CreateDirectoryA(level1,NULL);
330 if (!rc && GetLastError()==ERROR_ALREADY_EXISTS)
331 free1=FALSE;
332
333 strcpy(level2,level1);
334 strcat(level2,"nextlevel\\");
335 rc = CreateDirectoryA(level2,NULL);
336 if (!rc && GetLastError()==ERROR_ALREADY_EXISTS)
337 free2=FALSE;
338 SetCurrentDirectoryA(level2);
339
340 ok(_fullpath(full,"test", MAX_PATH)!=NULL,"_fullpath failed\n");
341 strcpy(teststring,level2);
342 strcat(teststring,"test");
343 ok(strcmp(full,teststring)==0,"Invalid Path returned %s\n",full);
344 ok(_fullpath(full,"\\test", MAX_PATH)!=NULL,"_fullpath failed\n");
345 memcpy(teststring,level2,3);
346 teststring[3]=0;
347 strcat(teststring,"test");
348 ok(strcmp(full,teststring)==0,"Invalid Path returned %s\n",full);
349 ok(_fullpath(full,"..\\test", MAX_PATH)!=NULL,"_fullpath failed\n");
350 strcpy(teststring,level1);
351 strcat(teststring,"test");
352 ok(strcmp(full,teststring)==0,"Invalid Path returned %s\n",full);
353 ok(_fullpath(full,"..\\test", 10)==NULL,"_fullpath failed to generate error\n");
354
355 freeme = _fullpath(NULL,"test", 0);
356 ok(freeme!=NULL,"No path returned\n");
357 strcpy(teststring,level2);
358 strcat(teststring,"test");
359 ok(strcmp(freeme,teststring)==0,"Invalid Path returned %s\n",freeme);
360 free(freeme);
361
362 SetCurrentDirectoryA(prevpath);
363 if (free2)
364 RemoveDirectoryA(level2);
365 if (free1)
366 RemoveDirectoryA(level1);
367}
368
369static void test_splitpath(void)
370{
371 const char* path = "c:\\\x83\x5c\x83\x74\x83\x67.bin";
372 char drive[3], dir[MAX_PATH], fname[MAX_PATH], ext[MAX_PATH];
373 int prev_cp = _getmbcp();
374
375 /* SBCS codepage */
376 _setmbcp(1252);
377 _splitpath(path, drive, dir, fname, ext);
378 ok(!strcmp(drive, "c:"), "got %s\n", drive);
379 ok(!strcmp(dir, "\\\x83\x5c"), "got %s\n", dir);
380 ok(!strcmp(fname, "\x83\x74\x83\x67"), "got %s\n", fname);
381 ok(!strcmp(ext, ".bin"), "got %s\n", ext);
382
383 /* MBCS (Japanese) codepage */
384 _setmbcp(932);
385 _splitpath(path, drive, dir, fname, ext);
386 ok(!strcmp(drive, "c:"), "got %s\n", drive);
387 ok(!strcmp(dir, "\\"), "got %s\n", dir);
388 ok(!strcmp(fname, "\x83\x5c\x83\x74\x83\x67"), "got %s\n", fname);
389 ok(!strcmp(ext, ".bin"), "got %s\n", ext);
390
391 _setmbcp(prev_cp);
392}
393
394static void test_searchenv(void)
395{
396 const char *dirs[] = {
397 "\\search_env_test",
398 "\\search_env_test\\dir1",
399 "\\search_env_test\\dir2",
400 "\\search_env_test\\dir3longer"
401 };
402
403 const char *files[] = {
404 "\\search_env_test\\dir1\\1.dat",
405 "\\search_env_test\\dir1\\2.dat",
406 "\\search_env_test\\dir2\\1.dat",
407 "\\search_env_test\\dir2\\3.dat",
408 "\\search_env_test\\dir3longer\\3.dat"
409 };
410
411 char env1[4*MAX_PATH], env2[4*MAX_PATH], tmppath[MAX_PATH], path[2*MAX_PATH];
412 char result[MAX_PATH], exp[2*MAX_PATH];
413 WCHAR result_w[MAX_PATH];
414 int i, path_len;
415 FILE *tmp_file;
416
417 if (getenv("TEST_PATH")) {
418 skip("TEST_PATH environment variable already set\n");
419 return;
420 }
421
422 path_len = GetTempPathA(MAX_PATH, tmppath);
423 ok(path_len, "GetTempPath failed\n");
424 memcpy(path, tmppath, path_len);
425
426 for (i=0; i<ARRAY_SIZE(dirs); i++) {
427 strcpy(path+path_len, dirs[i]);
428 ok(!mkdir(path), "mkdir failed (dir = %s)\n", path);
429 }
430
431 for (i=0; i<ARRAY_SIZE(files); i++) {
432 strcpy(path+path_len, files[i]);
433 tmp_file = fopen(path, "wb");
434 ok(tmp_file != NULL, "fopen failed (file = %s)\n", path);
435 fclose(tmp_file);
436 }
437
438 strcpy(env1, "TEST_PATH=");
439 strcpy(env2, "TEST_PATH=;");
440 for (i=1; i<ARRAY_SIZE(dirs); i++) {
441 strcat(env1, tmppath);
442 strcat(env1, dirs[i]);
443 strcat(env1, ";");
444
445 strcat(env2, tmppath);
446 strcat(env2, dirs[i]);
447 strcat(env2, ";;");
448 }
449
450 if (!p_searchenv_s || !p_wsearchenv_s)
451 win_skip("searchenv_s or wsearchenv_s function is not available\n");
452
453 putenv(env1);
454 memset(result, 'x', sizeof(result));
455 _searchenv("fail", "TEST_PATH", result);
456 ok(!result[0], "got %s, expected ''\n", result);
457
458 if (p_searchenv_s) {
459 memset(result, 'x', sizeof(result));
460 i = p_searchenv_s("fail", "TEST_PATH", result, MAX_PATH);
461 ok(i == ENOENT, "searchenv_s returned %d\n", i);
462 ok(!result[0], "got %s, expected ''\n", result);
463 }
464
465 memset(result, 'x', sizeof(result));
466 strcpy(exp, tmppath);
467 strcat(exp, files[0]);
468 _searchenv("1.dat", "TEST_PATH", result);
469 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
470
471 if (p_searchenv_s) {
472 memset(result, 'x', sizeof(result));
473 i = p_searchenv_s("1.dat", "TEST_PATH", result, MAX_PATH);
474 ok(!i, "searchenv_s returned %d\n", i);
475 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
476 }
477
478 memset(result_w, 'x', sizeof(result_w));
479 _wsearchenv(L"1.dat", L"TEST_PATH", result_w);
480 WideCharToMultiByte(CP_ACP, 0, result_w, -1, result, MAX_PATH, NULL, NULL);
481 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
482
483 if (p_wsearchenv_s) {
484 memset(result_w, 'x', sizeof(result_w));
485 i = p_wsearchenv_s(L"1.dat", L"TEST_PATH", result_w, MAX_PATH);
486 ok(!i, "wsearchenv_s returned %d\n", i);
487 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
488 }
489
490 memset(result, 'x', sizeof(result));
491 strcpy(exp, tmppath);
492 strcat(exp, files[3]);
493 _searchenv("3.dat", "TEST_PATH", result);
494 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
495
496 if (p_searchenv_s) {
497 memset(result, 'x', sizeof(result));
498 i = p_searchenv_s("3.dat", "TEST_PATH", result, MAX_PATH);
499 ok(!i, "searchenv_s returned %d\n", i);
500 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
501 }
502
503 memset(result_w, 'x', sizeof(result_w));
504 _wsearchenv(L"3.dat", L"TEST_PATH", result_w);
505 WideCharToMultiByte(CP_ACP, 0, result_w, -1, result, MAX_PATH, NULL, NULL);
506 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
507
508 if (p_wsearchenv_s) {
509 memset(result_w, 'x', sizeof(result_w));
510 i = p_wsearchenv_s(L"3.dat", L"TEST_PATH", result_w, MAX_PATH);
511 ok(!i, "wsearchenv_s returned %d\n", i);
512 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
513 }
514
515 putenv(env2);
516 memset(result, 'x', sizeof(result));
517 strcpy(exp, tmppath);
518 strcat(exp, files[0]);
519 _searchenv("1.dat", "TEST_PATH", result);
520 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
521
522 if (p_searchenv_s) {
523 memset(result, 'x', sizeof(result));
524 i = p_searchenv_s("1.dat", "TEST_PATH", result, MAX_PATH);
525 ok(!i, "searchenv_s returned %d\n", i);
526 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
527 }
528
529 memset(result_w, 'x', sizeof(result_w));
530 _wsearchenv(L"1.dat", L"TEST_PATH", result_w);
531 WideCharToMultiByte(CP_ACP, 0, result_w, -1, result, MAX_PATH, NULL, NULL);
532 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
533
534 if (p_wsearchenv_s) {
535 memset(result_w, 'x', sizeof(result_w));
536 i = p_wsearchenv_s(L"1.dat", L"TEST_PATH", result_w, MAX_PATH);
537 ok(!i, "wsearchenv_s returned %d\n", i);
538 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
539 }
540
541 memset(result, 'x', sizeof(result));
542 strcpy(exp, tmppath);
543 strcat(exp, files[3]);
544 _searchenv("3.dat", "TEST_PATH", result);
545 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
546
547 if (p_searchenv_s) {
548 memset(result, 'x', sizeof(result));
549 i = p_searchenv_s("3.dat", "TEST_PATH", result, MAX_PATH);
550 ok(!i, "searchenv_s returned %d\n", i);
551 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
552 }
553
554 memset(result_w, 'x', sizeof(result_w));
555 _wsearchenv(L"3.dat", L"TEST_PATH", result_w);
556 WideCharToMultiByte(CP_ACP, 0, result_w, -1, result, MAX_PATH, NULL, NULL);
557 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
558
559 if (p_wsearchenv_s) {
560 memset(result_w, 'x', sizeof(result_w));
561 i = p_wsearchenv_s(L"3.dat", L"TEST_PATH", result_w, MAX_PATH);
562 ok(!i, "wsearchenv_s returned %d\n", i);
563 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
564 }
565
566 strcpy(env1, "TEST_PATH=");
567 strcat(env1, tmppath);
568 strcat(env1, "\"\\search_env_test\\\"d\"i\"r\"1");
569 putenv(env1);
570 strcpy(exp, tmppath);
571 strcat(exp, files[0]);
572 _searchenv("1.dat", "TEST_PATH", result);
573 ok(!strcmp(result, exp), "got %s, expected '%s'\n", result, exp);
574
575 strcat(env1, ";");
576 putenv(env1);
577 _searchenv("1.dat", "TEST_PATH", result);
578 ok(!result[0], "got %s, expected ''\n", result);
579
580 putenv("TEST_PATH=");
581
582 for (i=ARRAY_SIZE(files)-1; i>=0; i--) {
583 strcpy(path+path_len, files[i]);
584 ok(!remove(path), "remove failed (file = %s)\n", path);
585 }
586
587 for (i=ARRAY_SIZE(dirs)-1; i>=0; i--) {
588 strcpy(path+path_len, dirs[i]);
589 ok(!rmdir(path), "rmdir failed (dir = %s)\n", path);
590 }
591}
592
593START_TEST(dir)
594{
595 init();
596
597 test_fullpath();
598 test_makepath();
599 test_makepath_s();
600 test_splitpath();
601 test_searchenv();
602}
ENOENT
#define ENOENT
Definition: acclib.h:79
EINVAL
#define EINVAL
Definition: acclib.h:90
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ERANGE
#define ERANGE
Definition: acclib.h:92
EBADF
#define EBADF
Definition: acclib.h:82
__cdecl
#define __cdecl
Definition: accygwin.h:79
mkdir
#define mkdir
Definition: acwin.h:101
dir
unsigned int dir
Definition: maze.c:112
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
_getmbcp
_CRTIMP int __cdecl _getmbcp(void)
Definition: locale.c:1474
free
#define free
Definition: debug_ros.c:5
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
CP_ACP
#define CP_ACP
Definition: compat.h:109
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
ext
static const WCHAR *const ext[]
Definition: module.c:53
RemoveDirectoryA
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714
CreateDirectoryA
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
GetCurrentDirectoryA
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2146
SetCurrentDirectoryA
BOOL WINAPI SetCurrentDirectoryA(IN LPCSTR lpPathName)
Definition: path.c:2206
GetTempPathA
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
fileW
static const WCHAR fileW[]
Definition: url.c:111
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
n
GLdouble n
Definition: glext.h:7729
buffer
GLuint buffer
Definition: glext.h:5915
result
GLuint64EXT * result
Definition: glext.h:11304
p
GLfloat GLfloat p
Definition: glext.h:8902
i
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
fopen
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
fclose
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
putenv
_Check_return_ _CRTIMP int __cdecl putenv(_In_z_ const char *_EnvString)
_wsearchenv
_CRTIMP void __cdecl _wsearchenv(_In_z_ const wchar_t *_Filename, _In_z_ const wchar_t *_EnvVar, _Pre_notnull_ _Post_z_ wchar_t *_ResultPath)
_fullpath
_Check_return_ _CRTIMP char *__cdecl _fullpath(_Out_writes_opt_z_(_SizeInBytes) char *_FullPath, _In_z_ const char *_Path, _In_ size_t _SizeInBytes)
_splitpath
_CRTIMP void __cdecl _splitpath(_In_z_ const char *_FullPath, _Pre_maybenull_ _Post_z_ char *_Drive, _Pre_maybenull_ _Post_z_ char *_Dir, _Pre_maybenull_ _Post_z_ char *_Filename, _Pre_maybenull_ _Post_z_ char *_Ext)
_wmakepath
_CRTIMP void __cdecl _wmakepath(_Pre_notnull_ _Post_z_ wchar_t *_ResultPath, _In_opt_z_ const wchar_t *_Drive, _In_opt_z_ const wchar_t *_Dir, _In_opt_z_ const wchar_t *_Filename, _In_opt_z_ const wchar_t *_Ext)
_searchenv
_CRTIMP void __cdecl _searchenv(_In_z_ const char *_Filename, _In_z_ const char *_EnvVar, _Pre_notnull_ _Post_z_ char *_ResultPath)
getenv
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
_makepath
_makepath
Definition: stdlib.h:1096
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ERROR_ALREADY_EXISTS
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
path_len
static DWORD path_len
Definition: batch.c:31
hmod
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143
test_fullpath
static void test_fullpath(void)
Definition: dir.c:312
init
static void init(void)
Definition: dir.c:41
test_makepath
static void test_makepath(void)
Definition: dir.c:89
makepath_cases
static const makepath_case makepath_cases[]
Definition: dir.c:62
makepath_s_cases
static const makepath_s_case makepath_s_cases[]
Definition: dir.c:154
test_searchenv
static void test_searchenv(void)
Definition: dir.c:394
test_splitpath
static void test_splitpath(void)
Definition: dir.c:369
test_makepath_s
static void test_makepath_s(void)
Definition: dir.c:188
size_t
static size_t
Definition: dir.c:36
USE_BUFF
#define USE_BUFF
Definition: dir.c:61
_setmbcp
int __cdecl _setmbcp(int)
Definition: _setmbcp.c:218
exp
DWORD exp
Definition: msg.c:16058
remove
int remove
Definition: msacm.c:1366
rmdir
#define rmdir
Definition: syshdrs.h:70
L
#define L(x)
Definition: ntvdm.h:50
errno
#define errno
Definition: errno.h:18
win_skip
#define win_skip
Definition: test.h:164
strcat
strcat
Definition: string.h:92
strcpy
strcpy
Definition: string.h:131
memset
#define memset(x, y, z)
Definition: compat.h:39
_iobuf
Definition: mbstring.h:19
makepath_case
Definition: dir.c:52
makepath_case::ext
const char * ext
Definition: dir.c:57
makepath_case::file
const char * file
Definition: dir.c:56
makepath_case::buffer
const char * buffer
Definition: dir.c:53
makepath_case::dir
const char * dir
Definition: dir.c:55
makepath_case::drive
const char * drive
Definition: dir.c:54
makepath_case::expected
const char * expected
Definition: dir.c:58
makepath_s_case
Definition: dir.c:142
makepath_s_case::expected
const char * expected
Definition: dir.c:149
makepath_s_case::buffer
const char * buffer
Definition: dir.c:143
makepath_s_case::length
size_t length
Definition: dir.c:144
makepath_s_case::expected_unicode
const WCHAR * expected_unicode
Definition: dir.c:150
makepath_s_case::drive
const char * drive
Definition: dir.c:145
makepath_s_case::ext
const char * ext
Definition: dir.c:148
makepath_s_case::expected_length
size_t expected_length
Definition: dir.c:151
makepath_s_case::dir
const char * dir
Definition: dir.c:146
makepath_s_case::file
const char * file
Definition: dir.c:147
ret
int ret
Definition: wcstombs-tests.c:31
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180