Remove unnecessary executable bits
[reactos.git] / modules / rostests / winetests / shlwapi / path.c
1 /* Unit test suite for Path functions
2 *
3 * Copyright 2002 Matthew Mastracci
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 <stdarg.h>
21 #include <stdio.h>
22
23 #include "wine/test.h"
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winreg.h"
27 #include "shlwapi.h"
28 #include "wininet.h"
29
30 static BOOL (WINAPI *pPathIsValidCharA)(char,DWORD);
31 static BOOL (WINAPI *pPathIsValidCharW)(WCHAR,DWORD);
32 static LPWSTR (WINAPI *pPathCombineW)(LPWSTR, LPCWSTR, LPCWSTR);
33 static HRESULT (WINAPI *pPathCreateFromUrlA)(LPCSTR, LPSTR, LPDWORD, DWORD);
34 static HRESULT (WINAPI *pPathCreateFromUrlW)(LPCWSTR, LPWSTR, LPDWORD, DWORD);
35 static HRESULT (WINAPI *pPathCreateFromUrlAlloc)(LPCWSTR, LPWSTR*, DWORD);
36 static BOOL (WINAPI *pPathAppendA)(LPSTR, LPCSTR);
37 static BOOL (WINAPI *pPathUnExpandEnvStringsA)(LPCSTR, LPSTR, UINT);
38 static BOOL (WINAPI *pPathUnExpandEnvStringsW)(LPCWSTR, LPWSTR, UINT);
39 static BOOL (WINAPI *pPathIsRelativeA)(LPCSTR);
40 static BOOL (WINAPI *pPathIsRelativeW)(LPCWSTR);
41
42 /* ################ */
43
44 static const struct {
45 const char *url;
46 const char *path;
47 DWORD ret, todo;
48 } TEST_PATHFROMURL[] = {
49 /* 0 leading slash */
50 {"file:c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
51 {"file:c|/foo/bar", "c:\\foo\\bar", S_OK, 0},
52 {"file:cx|/foo/bar", "cx|\\foo\\bar", S_OK, 0},
53 {"file:c:foo/bar", "c:foo\\bar", S_OK, 0},
54 {"file:c|foo/bar", "c:foo\\bar", S_OK, 0},
55 {"file:c:/foo%20ba%2fr", "c:\\foo ba/r", S_OK, 0},
56 {"file:foo%20ba%2fr", "foo ba/r", S_OK, 0},
57 {"file:foo/bar/", "foo\\bar\\", S_OK, 0},
58
59 /* 1 leading (back)slash */
60 {"file:/c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
61 {"file:\\c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
62 {"file:/c|/foo/bar", "c:\\foo\\bar", S_OK, 0},
63 {"file:/cx|/foo/bar", "\\cx|\\foo\\bar", S_OK, 0},
64 {"file:/c:foo/bar", "c:foo\\bar", S_OK, 0},
65 {"file:/c|foo/bar", "c:foo\\bar", S_OK, 0},
66 {"file:/c:/foo%20ba%2fr", "c:\\foo ba/r", S_OK, 0},
67 {"file:/foo%20ba%2fr", "\\foo ba/r", S_OK, 0},
68 {"file:/foo/bar/", "\\foo\\bar\\", S_OK, 0},
69
70 /* 2 leading (back)slashes */
71 {"file://c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
72 {"file://c:/d:/foo/bar", "c:\\d:\\foo\\bar", S_OK, 0},
73 {"file://c|/d|/foo/bar", "c:\\d|\\foo\\bar", S_OK, 0},
74 {"file://cx|/foo/bar", "\\\\cx|\\foo\\bar", S_OK, 0},
75 {"file://c:foo/bar", "c:foo\\bar", S_OK, 0},
76 {"file://c|foo/bar", "c:foo\\bar", S_OK, 0},
77 {"file://c:/foo%20ba%2fr", "c:\\foo%20ba%2fr", S_OK, 0},
78 {"file://c%3a/foo/../bar", "\\\\c:\\foo\\..\\bar", S_OK, 0},
79 {"file://c%7c/foo/../bar", "\\\\c|\\foo\\..\\bar", S_OK, 0},
80 {"file://foo%20ba%2fr", "\\\\foo ba/r", S_OK, 0},
81 {"file://localhost/c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
82 {"file://localhost/c:/foo%20ba%5Cr", "c:\\foo ba\\r", S_OK, 0},
83 {"file://LocalHost/c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
84 {"file:\\\\localhost\\c:\\foo\\bar", "c:\\foo\\bar", S_OK, 0},
85 {"file://incomplete", "\\\\incomplete", S_OK, 0},
86
87 /* 3 leading (back)slashes (omitting hostname) */
88 {"file:///c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
89 {"File:///c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
90 {"file:///c:/foo%20ba%2fr", "c:\\foo ba/r", S_OK, 0},
91 {"file:///foo%20ba%2fr", "\\foo ba/r", S_OK, 0},
92 {"file:///foo/bar/", "\\foo\\bar\\", S_OK, 0},
93 {"file:///localhost/c:/foo/bar", "\\localhost\\c:\\foo\\bar", S_OK, 0},
94
95 /* 4 leading (back)slashes */
96 {"file:////c:/foo/bar", "c:\\foo\\bar", S_OK, 0},
97 {"file:////c:/foo%20ba%2fr", "c:\\foo%20ba%2fr", S_OK, 0},
98 {"file:////foo%20ba%2fr", "\\\\foo%20ba%2fr", S_OK, 0},
99
100 /* 5 and more leading (back)slashes */
101 {"file://///c:/foo/bar", "\\\\c:\\foo\\bar", S_OK, 0},
102 {"file://///c:/foo%20ba%2fr", "\\\\c:\\foo ba/r", S_OK, 0},
103 {"file://///foo%20ba%2fr", "\\\\foo ba/r", S_OK, 0},
104 {"file://////c:/foo/bar", "\\\\c:\\foo\\bar", S_OK, 0},
105
106 /* Leading (back)slashes cannot be escaped */
107 {"file:%2f%2flocalhost%2fc:/foo/bar", "//localhost/c:\\foo\\bar", S_OK, 0},
108 {"file:%5C%5Clocalhost%5Cc:/foo/bar", "\\\\localhost\\c:\\foo\\bar", S_OK, 0},
109
110 /* Hostname handling */
111 {"file://l%6fcalhost/c:/foo/bar", "\\\\localhostc:\\foo\\bar", S_OK, 0},
112 {"file://localhost:80/c:/foo/bar", "\\\\localhost:80c:\\foo\\bar", S_OK, 0},
113 {"file://host/c:/foo/bar", "\\\\hostc:\\foo\\bar", S_OK, 0},
114 {"file://host//c:/foo/bar", "\\\\host\\\\c:\\foo\\bar", S_OK, 0},
115 {"file://host/\\c:/foo/bar", "\\\\host\\\\c:\\foo\\bar", S_OK, 0},
116 {"file://host/c:foo/bar", "\\\\hostc:foo\\bar", S_OK, 0},
117 {"file://host/foo/bar", "\\\\host\\foo\\bar", S_OK, 0},
118 {"file:\\\\host\\c:\\foo\\bar", "\\\\hostc:\\foo\\bar", S_OK, 0},
119 {"file:\\\\host\\ca\\foo\\bar", "\\\\host\\ca\\foo\\bar", S_OK, 0},
120 {"file:\\\\host\\c|\\foo\\bar", "\\\\hostc|\\foo\\bar", S_OK, 0},
121 {"file:\\%5Chost\\c:\\foo\\bar", "\\\\host\\c:\\foo\\bar", S_OK, 0},
122 {"file:\\\\host\\cx:\\foo\\bar", "\\\\host\\cx:\\foo\\bar", S_OK, 0},
123 {"file:///host/c:/foo/bar", "\\host\\c:\\foo\\bar", S_OK, 0},
124
125 /* Not file URLs */
126 {"c:\\foo\\bar", NULL, E_INVALIDARG, 0},
127 {"foo/bar", NULL, E_INVALIDARG, 0},
128 {"http://foo/bar", NULL, E_INVALIDARG, 0},
129
130 };
131
132
133 static struct {
134 const char *path;
135 BOOL expect;
136 } TEST_PATH_IS_URL[] = {
137 {"http://foo/bar", TRUE},
138 {"c:\\foo\\bar", FALSE},
139 {"c:/foo/bar", FALSE},
140 {"foo://foo/bar", TRUE},
141 {"foo\\bar", FALSE},
142 {"foo.bar", FALSE},
143 {"bogusscheme:", TRUE},
144 {"http:partial", TRUE},
145 {"www.winehq.org", FALSE},
146 /* More examples that the user might enter as the browser start page */
147 {"winehq.org", FALSE},
148 {"ftp.winehq.org", FALSE},
149 {"http://winehq.org", TRUE},
150 {"http://www.winehq.org", TRUE},
151 {"https://winehq.org", TRUE},
152 {"https://www.winehq.org", TRUE},
153 {"ftp://winehq.org", TRUE},
154 {"ftp://ftp.winehq.org", TRUE},
155 {"file://does_not_exist.txt", TRUE},
156 {"about:blank", TRUE},
157 {"about:home", TRUE},
158 {"about:mozilla", TRUE},
159 /* scheme is case independent */
160 {"HTTP://www.winehq.org", TRUE},
161 /* a space at the start is not allowed */
162 {" http://www.winehq.org", FALSE},
163 {"", FALSE},
164 {NULL, FALSE}
165 };
166
167 static const struct {
168 const char *path;
169 const char *result;
170 } TEST_PATH_UNQUOTE_SPACES[] = {
171 { "abcdef", "abcdef" },
172 { "\"abcdef\"", "abcdef" },
173 { "\"abcdef", "\"abcdef" },
174 { "abcdef\"", "abcdef\"" },
175 { "\"\"abcdef\"\"", "\"abcdef\"" },
176 { "abc\"def", "abc\"def" },
177 { "\"abc\"def", "\"abc\"def" },
178 { "\"abc\"def\"", "abc\"def" },
179 { "\'abcdef\'", "\'abcdef\'" },
180 { "\"\"", "" },
181 { "\"", "" }
182 };
183
184 /* ################ */
185
186 static LPWSTR GetWideString(const char *src)
187 {
188 WCHAR *ret;
189
190 if (!src)
191 return NULL;
192
193 ret = HeapAlloc(GetProcessHeap(), 0, (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
194
195 MultiByteToWideChar(CP_ACP, 0, src, -1, ret, INTERNET_MAX_URL_LENGTH);
196
197 return ret;
198 }
199
200 static void FreeWideString(LPWSTR wszString)
201 {
202 HeapFree(GetProcessHeap(), 0, wszString);
203 }
204
205 static LPSTR strdupA(LPCSTR p)
206 {
207 LPSTR ret;
208 DWORD len = (strlen(p) + 1);
209 ret = HeapAlloc(GetProcessHeap(), 0, len);
210 memcpy(ret, p, len);
211 return ret;
212 }
213
214 /* ################ */
215
216 static void test_PathSearchAndQualify(void)
217 {
218 WCHAR path1[] = {'c',':','\\','f','o','o',0};
219 WCHAR expect1[] = {'c',':','\\','f','o','o',0};
220 WCHAR path2[] = {'c',':','f','o','o',0};
221 WCHAR c_drive[] = {'c',':',0};
222 WCHAR foo[] = {'f','o','o',0};
223 WCHAR path3[] = {'\\','f','o','o',0};
224 WCHAR winini[] = {'w','i','n','.','i','n','i',0};
225 WCHAR out[MAX_PATH];
226 WCHAR cur_dir[MAX_PATH];
227 WCHAR dot[] = {'.',0};
228
229 /* c:\foo */
230 ok(PathSearchAndQualifyW(path1, out, MAX_PATH) != 0,
231 "PathSearchAndQualify rets 0\n");
232 ok(!lstrcmpiW(out, expect1), "strings don't match\n");
233
234 /* c:foo */
235 ok(PathSearchAndQualifyW(path2, out, MAX_PATH) != 0,
236 "PathSearchAndQualify rets 0\n");
237 GetFullPathNameW(c_drive, MAX_PATH, cur_dir, NULL);
238 PathAddBackslashW(cur_dir);
239 lstrcatW(cur_dir, foo);
240 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
241
242 /* foo */
243 ok(PathSearchAndQualifyW(foo, out, MAX_PATH) != 0,
244 "PathSearchAndQualify rets 0\n");
245 GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
246 PathAddBackslashW(cur_dir);
247 lstrcatW(cur_dir, foo);
248 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
249
250 /* \foo */
251 ok(PathSearchAndQualifyW(path3, out, MAX_PATH) != 0,
252 "PathSearchAndQualify rets 0\n");
253 GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
254 lstrcpyW(cur_dir + 2, path3);
255 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
256
257 /* win.ini */
258 ok(PathSearchAndQualifyW(winini, out, MAX_PATH) != 0,
259 "PathSearchAndQualify rets 0\n");
260 if(!SearchPathW(NULL, winini, NULL, MAX_PATH, cur_dir, NULL))
261 GetFullPathNameW(winini, MAX_PATH, cur_dir, NULL);
262 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
263
264 }
265
266 static void test_PathCreateFromUrl(void)
267 {
268 size_t i;
269 char ret_path[INTERNET_MAX_URL_LENGTH];
270 DWORD len, len2, ret;
271 WCHAR ret_pathW[INTERNET_MAX_URL_LENGTH];
272 WCHAR *pathW, *urlW;
273
274 if (!pPathCreateFromUrlA) {
275 win_skip("PathCreateFromUrlA not found\n");
276 return;
277 }
278
279 /* Won't say how much is needed without a buffer */
280 len = 0xdeca;
281 ret = pPathCreateFromUrlA("file://foo", NULL, &len, 0);
282 ok(ret == E_INVALIDARG, "got 0x%08x expected E_INVALIDARG\n", ret);
283 ok(len == 0xdeca, "got %x expected 0xdeca\n", len);
284
285 /* Test the decoding itself */
286 for(i = 0; i < sizeof(TEST_PATHFROMURL) / sizeof(TEST_PATHFROMURL[0]); i++) {
287 len = INTERNET_MAX_URL_LENGTH;
288 ret = pPathCreateFromUrlA(TEST_PATHFROMURL[i].url, ret_path, &len, 0);
289 todo_wine_if (TEST_PATHFROMURL[i].todo & 0x1)
290 ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url %s\n", ret, TEST_PATHFROMURL[i].url);
291 if(SUCCEEDED(ret) && TEST_PATHFROMURL[i].path) {
292 if(!(TEST_PATHFROMURL[i].todo & 0x2)) {
293 ok(!lstrcmpiA(ret_path, TEST_PATHFROMURL[i].path), "got %s expected %s from url %s\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
294 ok(len == strlen(ret_path), "ret len %d from url %s\n", len, TEST_PATHFROMURL[i].url);
295 } else todo_wine
296 /* Wrong string, don't bother checking the length */
297 ok(!lstrcmpiA(ret_path, TEST_PATHFROMURL[i].path), "got %s expected %s from url %s\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
298 }
299
300 if (pPathCreateFromUrlW) {
301 len = INTERNET_MAX_URL_LENGTH;
302 pathW = GetWideString(TEST_PATHFROMURL[i].path);
303 urlW = GetWideString(TEST_PATHFROMURL[i].url);
304 ret = pPathCreateFromUrlW(urlW, ret_pathW, &len, 0);
305 WideCharToMultiByte(CP_ACP, 0, ret_pathW, -1, ret_path, sizeof(ret_path),NULL,NULL);
306 todo_wine_if (TEST_PATHFROMURL[i].todo & 0x1)
307 ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url L\"%s\"\n", ret, TEST_PATHFROMURL[i].url);
308 if(SUCCEEDED(ret) && TEST_PATHFROMURL[i].path) {
309 if(!(TEST_PATHFROMURL[i].todo & 0x2)) {
310 ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L\"%s\"\n",
311 ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
312 ok(len == lstrlenW(ret_pathW), "ret len %d from url L\"%s\"\n", len, TEST_PATHFROMURL[i].url);
313 } else todo_wine
314 /* Wrong string, don't bother checking the length */
315 ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L\"%s\"\n",
316 ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
317 }
318
319 if (SUCCEEDED(ret))
320 {
321 /* Check what happens if the buffer is too small */
322 len2 = 2;
323 ret = pPathCreateFromUrlW(urlW, ret_pathW, &len2, 0);
324 ok(ret == E_POINTER, "ret %08x, expected E_POINTER from url %s\n", ret, TEST_PATHFROMURL[i].url);
325 todo_wine_if (TEST_PATHFROMURL[i].todo & 0x4)
326 ok(len2 == len + 1, "got len = %d expected %d from url %s\n", len2, len + 1, TEST_PATHFROMURL[i].url);
327 }
328
329 FreeWideString(urlW);
330 FreeWideString(pathW);
331 }
332 }
333
334 if (pPathCreateFromUrlAlloc)
335 {
336 static const WCHAR fileW[] = {'f','i','l','e',':','/','/','f','o','o',0};
337 static const WCHAR fooW[] = {'\\','\\','f','o','o',0};
338
339 pathW = NULL;
340 ret = pPathCreateFromUrlAlloc(fileW, &pathW, 0);
341 ok(ret == S_OK, "got 0x%08x expected S_OK\n", ret);
342 ok(lstrcmpiW(pathW, fooW) == 0, "got %s expected %s\n", wine_dbgstr_w(pathW), wine_dbgstr_w(fooW));
343 HeapFree(GetProcessHeap(), 0, pathW);
344 }
345 }
346
347
348 static void test_PathIsUrl(void)
349 {
350 size_t i;
351 BOOL ret;
352
353 for(i = 0; i < sizeof(TEST_PATH_IS_URL)/sizeof(TEST_PATH_IS_URL[0]); i++) {
354 ret = PathIsURLA(TEST_PATH_IS_URL[i].path);
355 ok(ret == TEST_PATH_IS_URL[i].expect,
356 "returned %d from path %s, expected %d\n", ret, TEST_PATH_IS_URL[i].path,
357 TEST_PATH_IS_URL[i].expect);
358 }
359 }
360
361 static const DWORD SHELL_charclass[] =
362 {
363 0x00000000, 0x00000000, 0x00000000, 0x00000000,
364 0x00000000, 0x00000000, 0x00000000, 0x00000000,
365 0x00000000, 0x00000000, 0x00000000, 0x00000000,
366 0x00000000, 0x00000000, 0x00000000, 0x00000000,
367 0x00000000, 0x00000000, 0x00000000, 0x00000000,
368 0x00000000, 0x00000000, 0x00000000, 0x00000000,
369 0x00000000, 0x00000000, 0x00000000, 0x00000000,
370 0x00000000, 0x00000000, 0x00000000, 0x00000000,
371 0x00000080, 0x00000100, 0x00000200, 0x00000100,
372 0x00000100, 0x00000100, 0x00000100, 0x00000100,
373 0x00000100, 0x00000100, 0x00000002, 0x00000100,
374 0x00000040, 0x00000100, 0x00000004, 0x00000000,
375 0x00000100, 0x00000100, 0x00000100, 0x00000100,
376 0x00000100, 0x00000100, 0x00000100, 0x00000100,
377 0x00000100, 0x00000100, 0x00000010, 0x00000020,
378 0x00000000, 0x00000100, 0x00000000, 0x00000001,
379 0x00000100, 0xffffffff, 0xffffffff, 0xffffffff,
380 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
381 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
382 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
383 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
384 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
385 0xffffffff, 0xffffffff, 0xffffffff, 0x00000100,
386 0x00000008, 0x00000100, 0x00000100, 0x00000100,
387 0x00000100, 0xffffffff, 0xffffffff, 0xffffffff,
388 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
389 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
390 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
391 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
392 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
393 0xffffffff, 0xffffffff, 0xffffffff, 0x00000100,
394 0x00000000, 0x00000100, 0x00000100
395 };
396
397 static void test_PathIsValidCharA(void)
398 {
399 BOOL ret;
400 unsigned int c;
401
402 /* For whatever reason, PathIsValidCharA and PathAppendA share the same
403 * ordinal number in some native versions. Check this to prevent a crash.
404 */
405 if (!pPathIsValidCharA || pPathIsValidCharA == (void*)pPathAppendA)
406 {
407 win_skip("PathIsValidCharA isn't available\n");
408 return;
409 }
410
411 for (c = 0; c < 0x7f; c++)
412 {
413 ret = pPathIsValidCharA( c, ~0U );
414 ok ( ret || !SHELL_charclass[c], "PathIsValidCharA failed: 0x%02x got 0x%08x\n", c, ret );
415 }
416
417 for (c = 0x7f; c <= 0xff; c++)
418 {
419 ret = pPathIsValidCharA( c, ~0U );
420 ok ( ret, "PathIsValidCharA failed: 0x%02x got 0x%08x\n", c, ret );
421 }
422 }
423
424 static void test_PathIsValidCharW(void)
425 {
426 BOOL ret;
427 unsigned int c;
428
429 if (!pPathIsValidCharW)
430 {
431 win_skip("PathIsValidCharW isn't available\n");
432 return;
433 }
434
435 for (c = 0; c < 0x7f; c++)
436 {
437 ret = pPathIsValidCharW( c, ~0U );
438 ok ( ret || !SHELL_charclass[c], "PathIsValidCharW failed: 0x%02x got 0x%08x\n", c, ret );
439 }
440
441 for (c = 0x007f; c <= 0xffff; c++)
442 {
443 ret = pPathIsValidCharW( c, ~0U );
444 ok ( ret, "PathIsValidCharW failed: 0x%02x got 0x%08x\n", c, ret );
445 }
446 }
447
448 static void test_PathMakePretty(void)
449 {
450 char buff[MAX_PATH];
451
452 ok (PathMakePrettyA(NULL) == FALSE, "PathMakePretty: NULL path succeeded\n");
453 buff[0] = '\0';
454 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Empty path failed\n");
455
456 strcpy(buff, "C:\\A LONG FILE NAME WITH \\SPACES.TXT");
457 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Long UC name failed\n");
458 ok (strcmp(buff, "C:\\a long file name with \\spaces.txt") == 0,
459 "PathMakePretty: Long UC name not changed\n");
460
461 strcpy(buff, "C:\\A LONG FILE NAME WITH \\MixedCase.TXT");
462 ok (PathMakePrettyA(buff) == FALSE, "PathMakePretty: Long MC name succeeded\n");
463 ok (strcmp(buff, "C:\\A LONG FILE NAME WITH \\MixedCase.TXT") == 0,
464 "PathMakePretty: Failed but modified path\n");
465
466 strcpy(buff, "TEST");
467 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Short name failed\n");
468 ok (strcmp(buff, "Test") == 0, "PathMakePretty: 1st char lowercased %s\n", buff);
469 }
470
471 static void test_PathMatchSpec(void)
472 {
473 static const char file[] = "c:\\foo\\bar\\filename.ext";
474 static const char spec1[] = ".ext";
475 static const char spec2[] = "*.ext";
476 static const char spec3[] = "*.ext ";
477 static const char spec4[] = " *.ext";
478 static const char spec5[] = "* .ext";
479 static const char spec6[] = "*. ext";
480 static const char spec7[] = "* . ext";
481 static const char spec8[] = "*.e?t";
482 static const char spec9[] = "filename.ext";
483 static const char spec10[] = "*bar\\filename.ext";
484 static const char spec11[] = " foo; *.ext";
485 static const char spec12[] = "*.ext;*.bar";
486 static const char spec13[] = "*bar*";
487
488 ok (PathMatchSpecA(file, spec1) == FALSE, "PathMatchSpec: Spec1 failed\n");
489 ok (PathMatchSpecA(file, spec2) == TRUE, "PathMatchSpec: Spec2 failed\n");
490 ok (PathMatchSpecA(file, spec3) == FALSE, "PathMatchSpec: Spec3 failed\n");
491 ok (PathMatchSpecA(file, spec4) == TRUE, "PathMatchSpec: Spec4 failed\n");
492 todo_wine ok (PathMatchSpecA(file, spec5) == TRUE, "PathMatchSpec: Spec5 failed\n");
493 todo_wine ok (PathMatchSpecA(file, spec6) == TRUE, "PathMatchSpec: Spec6 failed\n");
494 ok (PathMatchSpecA(file, spec7) == FALSE, "PathMatchSpec: Spec7 failed\n");
495 ok (PathMatchSpecA(file, spec8) == TRUE, "PathMatchSpec: Spec8 failed\n");
496 ok (PathMatchSpecA(file, spec9) == FALSE, "PathMatchSpec: Spec9 failed\n");
497 ok (PathMatchSpecA(file, spec10) == TRUE, "PathMatchSpec: Spec10 failed\n");
498 ok (PathMatchSpecA(file, spec11) == TRUE, "PathMatchSpec: Spec11 failed\n");
499 ok (PathMatchSpecA(file, spec12) == TRUE, "PathMatchSpec: Spec12 failed\n");
500 ok (PathMatchSpecA(file, spec13) == TRUE, "PathMatchSpec: Spec13 failed\n");
501 }
502
503 static void test_PathCombineW(void)
504 {
505 LPWSTR wszString, wszString2;
506 WCHAR wbuf[MAX_PATH+1], wstr1[MAX_PATH] = {'C',':','\\',0}, wstr2[MAX_PATH];
507 static const WCHAR expout[] = {'C',':','\\','A','A',0};
508 int i;
509
510 if (!pPathCombineW)
511 {
512 win_skip("PathCombineW isn't available\n");
513 return;
514 }
515
516 wszString2 = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
517
518 /* NULL test */
519 wszString = pPathCombineW(NULL, NULL, NULL);
520 ok (wszString == NULL, "Expected a NULL return\n");
521
522 /* Some NULL */
523 wszString2[0] = 'a';
524 wszString = pPathCombineW(wszString2, NULL, NULL);
525 ok (wszString == NULL ||
526 broken(wszString[0] == 'a'), /* Win95 and some W2K */
527 "Expected a NULL return\n");
528 ok (wszString2[0] == 0 ||
529 broken(wszString2[0] == 'a'), /* Win95 and some W2K */
530 "Destination string not empty\n");
531
532 HeapFree(GetProcessHeap(), 0, wszString2);
533
534 /* overflow test */
535 wstr2[0] = wstr2[1] = wstr2[2] = 'A';
536 for (i=3; i<MAX_PATH/2; i++)
537 wstr1[i] = wstr2[i] = 'A';
538 wstr1[(MAX_PATH/2) - 1] = wstr2[MAX_PATH/2] = 0;
539 memset(wbuf, 0xbf, sizeof(wbuf));
540
541 wszString = pPathCombineW(wbuf, wstr1, wstr2);
542 ok(wszString == NULL, "Expected a NULL return\n");
543 ok(wbuf[0] == 0 ||
544 broken(wbuf[0] == 0xbfbf), /* Win95 and some W2K */
545 "Buffer contains data\n");
546
547 /* PathCombineW can be used in place */
548 wstr1[3] = 0;
549 wstr2[2] = 0;
550 ok(PathCombineW(wstr1, wstr1, wstr2) == wstr1, "Expected a wstr1 return\n");
551 ok(StrCmpW(wstr1, expout) == 0, "Unexpected PathCombine output\n");
552 }
553
554
555 #define LONG_LEN (MAX_PATH * 2)
556 #define HALF_LEN (MAX_PATH / 2 + 1)
557
558 static void test_PathCombineA(void)
559 {
560 LPSTR str;
561 char dest[MAX_PATH];
562 char too_long[LONG_LEN];
563 char one[HALF_LEN], two[HALF_LEN];
564
565 /* try NULL dest */
566 SetLastError(0xdeadbeef);
567 str = PathCombineA(NULL, "C:\\", "one\\two\\three");
568 ok(str == NULL, "Expected NULL, got %p\n", str);
569 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
570
571 /* try NULL dest and NULL directory */
572 SetLastError(0xdeadbeef);
573 str = PathCombineA(NULL, NULL, "one\\two\\three");
574 ok(str == NULL, "Expected NULL, got %p\n", str);
575 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
576
577 /* try all NULL*/
578 SetLastError(0xdeadbeef);
579 str = PathCombineA(NULL, NULL, NULL);
580 ok(str == NULL, "Expected NULL, got %p\n", str);
581 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
582
583 /* try NULL file part */
584 SetLastError(0xdeadbeef);
585 lstrcpyA(dest, "control");
586 str = PathCombineA(dest, "C:\\", NULL);
587 ok(str == dest, "Expected str == dest, got %p\n", str);
588 ok(!lstrcmpA(str, "C:\\"), "Expected C:\\, got %s\n", str);
589 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
590
591 /* try empty file part */
592 SetLastError(0xdeadbeef);
593 lstrcpyA(dest, "control");
594 str = PathCombineA(dest, "C:\\", "");
595 ok(str == dest, "Expected str == dest, got %p\n", str);
596 ok(!lstrcmpA(str, "C:\\"), "Expected C:\\, got %s\n", str);
597 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
598
599 /* try empty directory and file part */
600 SetLastError(0xdeadbeef);
601 lstrcpyA(dest, "control");
602 str = PathCombineA(dest, "", "");
603 ok(str == dest, "Expected str == dest, got %p\n", str);
604 ok(!lstrcmpA(str, "\\") ||
605 broken(!lstrcmpA(str, "control")), /* Win95 and some W2K */
606 "Expected \\, got %s\n", str);
607 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
608
609 /* try NULL directory */
610 SetLastError(0xdeadbeef);
611 lstrcpyA(dest, "control");
612 str = PathCombineA(dest, NULL, "one\\two\\three");
613 ok(str == dest, "Expected str == dest, got %p\n", str);
614 ok(!lstrcmpA(str, "one\\two\\three"), "Expected one\\two\\three, got %s\n", str);
615 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
616
617 /* try NULL directory and empty file part */
618 SetLastError(0xdeadbeef);
619 lstrcpyA(dest, "control");
620 str = PathCombineA(dest, NULL, "");
621 ok(str == dest, "Expected str == dest, got %p\n", str);
622 ok(!lstrcmpA(str, "\\") ||
623 broken(!lstrcmpA(str, "one\\two\\three")), /* Win95 and some W2K */
624 "Expected \\, got %s\n", str);
625 ok(GetLastError() == 0xdeadbeef ||
626 broken(GetLastError() == ERROR_INVALID_PARAMETER), /* Win95 */
627 "Expected 0xdeadbeef, got %d\n", GetLastError());
628
629 /* try NULL directory and file part */
630 SetLastError(0xdeadbeef);
631 lstrcpyA(dest, "control");
632 str = PathCombineA(dest, NULL, NULL);
633 ok(str == NULL ||
634 broken(str != NULL), /* Win95 and some W2K */
635 "Expected str == NULL, got %p\n", str);
636 ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */
637 "Expected 0 length, got %i\n", lstrlenA(dest));
638 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
639
640 /* try directory without backslash */
641 SetLastError(0xdeadbeef);
642 lstrcpyA(dest, "control");
643 str = PathCombineA(dest, "C:", "one\\two\\three");
644 ok(str == dest, "Expected str == dest, got %p\n", str);
645 ok(!lstrcmpA(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
646 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
647
648 /* try directory with backslash */
649 SetLastError(0xdeadbeef);
650 lstrcpyA(dest, "control");
651 str = PathCombineA(dest, "C:\\", "one\\two\\three");
652 ok(str == dest, "Expected str == dest, got %p\n", str);
653 ok(!lstrcmpA(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
654 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
655
656 /* try directory with backslash and file with prepended backslash */
657 SetLastError(0xdeadbeef);
658 lstrcpyA(dest, "control");
659 str = PathCombineA(dest, "C:\\", "\\one\\two\\three");
660 ok(str == dest, "Expected str == dest, got %p\n", str);
661 ok(!lstrcmpA(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
662 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
663
664 /* try previous test, with backslash appended as well */
665 SetLastError(0xdeadbeef);
666 lstrcpyA(dest, "control");
667 str = PathCombineA(dest, "C:\\", "\\one\\two\\three\\");
668 ok(str == dest, "Expected str == dest, got %p\n", str);
669 ok(!lstrcmpA(str, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", str);
670 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
671
672 /* try a relative directory */
673 SetLastError(0xdeadbeef);
674 lstrcpyA(dest, "control");
675 str = PathCombineA(dest, "relative\\dir", "\\one\\two\\three\\");
676 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
677 /* Vista fails which probably makes sense as PathCombineA expects an absolute dir */
678 if (str)
679 {
680 ok(str == dest, "Expected str == dest, got %p\n", str);
681 ok(!lstrcmpA(str, "one\\two\\three\\"), "Expected one\\two\\three\\, got %s\n", str);
682 }
683
684 /* try forward slashes */
685 SetLastError(0xdeadbeef);
686 lstrcpyA(dest, "control");
687 str = PathCombineA(dest, "C:\\", "one/two/three\\");
688 ok(str == dest, "Expected str == dest, got %p\n", str);
689 ok(!lstrcmpA(str, "C:\\one/two/three\\"), "Expected one/two/three\\, got %s\n", str);
690 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
691
692 /* try a really weird directory */
693 SetLastError(0xdeadbeef);
694 lstrcpyA(dest, "control");
695 str = PathCombineA(dest, "C:\\/\\/", "\\one\\two\\three\\");
696 ok(str == dest, "Expected str == dest, got %p\n", str);
697 ok(!lstrcmpA(str, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", str);
698 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
699
700 /* try periods */
701 SetLastError(0xdeadbeef);
702 lstrcpyA(dest, "control");
703 str = PathCombineA(dest, "C:\\", "one\\..\\two\\.\\three");
704 ok(str == dest, "Expected str == dest, got %p\n", str);
705 ok(!lstrcmpA(str, "C:\\two\\three"), "Expected C:\\two\\three, got %s\n", str);
706 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
707
708 /* try .. as file */
709 /* try forward slashes */
710 SetLastError(0xdeadbeef);
711 lstrcpyA(dest, "control");
712 str = PathCombineA(dest, "C:\\", "..");
713 ok(str == dest, "Expected str == dest, got %p\n", str);
714 ok(!lstrcmpA(str, "C:\\"), "Expected C:\\, got %s\n", str);
715 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
716
717 memset(too_long, 'a', LONG_LEN);
718 too_long[LONG_LEN - 1] = '\0';
719
720 /* try a file longer than MAX_PATH */
721 SetLastError(0xdeadbeef);
722 lstrcpyA(dest, "control");
723 str = PathCombineA(dest, "C:\\", too_long);
724 ok(str == NULL, "Expected str == NULL, got %p\n", str);
725 ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */
726 "Expected 0 length, got %i\n", lstrlenA(dest));
727 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
728
729 /* try a directory longer than MAX_PATH */
730 SetLastError(0xdeadbeef);
731 lstrcpyA(dest, "control");
732 str = PathCombineA(dest, too_long, "one\\two\\three");
733 ok(str == NULL, "Expected str == NULL, got %p\n", str);
734 ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */
735 "Expected 0 length, got %i\n", lstrlenA(dest));
736 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
737
738 memset(one, 'b', HALF_LEN);
739 memset(two, 'c', HALF_LEN);
740 one[HALF_LEN - 1] = '\0';
741 two[HALF_LEN - 1] = '\0';
742
743 /* destination string is longer than MAX_PATH, but not the constituent parts */
744 SetLastError(0xdeadbeef);
745 lstrcpyA(dest, "control");
746 str = PathCombineA(dest, one, two);
747 ok(str == NULL, "Expected str == NULL, got %p\n", str);
748 ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */
749 "Expected 0 length, got %i\n", lstrlenA(dest));
750 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
751 }
752
753 static void test_PathAddBackslash(void)
754 {
755 LPSTR str;
756 char path[MAX_PATH];
757 char too_long[LONG_LEN];
758
759 /* try a NULL path */
760 SetLastError(0xdeadbeef);
761 str = PathAddBackslashA(NULL);
762 ok(str == NULL, "Expected str == NULL, got %p\n", str);
763 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
764
765 /* try an empty path */
766 path[0] = '\0';
767 SetLastError(0xdeadbeef);
768 str = PathAddBackslashA(path);
769 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
770 ok(!path[0], "Expected empty string, got %i\n", lstrlenA(path));
771 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
772
773 /* try a relative path */
774 lstrcpyA(path, "one\\two");
775 SetLastError(0xdeadbeef);
776 str = PathAddBackslashA(path);
777 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
778 ok(!lstrcmpA(path, "one\\two\\"), "Expected one\\two\\, got %s\n", path);
779 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
780
781 /* try periods */
782 lstrcpyA(path, "one\\..\\two");
783 SetLastError(0xdeadbeef);
784 str = PathAddBackslashA(path);
785 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
786 ok(!lstrcmpA(path, "one\\..\\two\\"), "Expected one\\..\\two\\, got %s\n", path);
787 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
788
789 /* try just a space */
790 lstrcpyA(path, " ");
791 SetLastError(0xdeadbeef);
792 str = PathAddBackslashA(path);
793 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
794 ok(!lstrcmpA(path, " \\"), "Expected \\, got %s\n", path);
795 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
796
797 /* path already has backslash */
798 lstrcpyA(path, "C:\\one\\");
799 SetLastError(0xdeadbeef);
800 str = PathAddBackslashA(path);
801 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
802 ok(!lstrcmpA(path, "C:\\one\\"), "Expected C:\\one\\, got %s\n", path);
803 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
804
805 memset(too_long, 'a', LONG_LEN);
806 too_long[LONG_LEN - 1] = '\0';
807
808 /* path is longer than MAX_PATH */
809 SetLastError(0xdeadbeef);
810 str = PathAddBackslashA(too_long);
811 ok(str == NULL, "Expected str == NULL, got %p\n", str);
812 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
813 }
814
815 static void test_PathAppendA(void)
816 {
817 char path[MAX_PATH];
818 char too_long[LONG_LEN];
819 char half[HALF_LEN];
820 BOOL res;
821
822 lstrcpyA(path, "C:\\one");
823
824 /* try NULL pszMore */
825 SetLastError(0xdeadbeef);
826 res = PathAppendA(path, NULL);
827 ok(!res, "Expected failure\n");
828 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
829 ok(!lstrcmpA(path, "C:\\one"), "Expected C:\\one, got %s\n", path);
830
831 /* try empty pszMore */
832 SetLastError(0xdeadbeef);
833 res = PathAppendA(path, "");
834 ok(res, "Expected success\n");
835 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
836 ok(!lstrcmpA(path, "C:\\one"), "Expected C:\\one, got %s\n", path);
837
838 /* try NULL pszPath */
839 SetLastError(0xdeadbeef);
840 res = PathAppendA(NULL, "two\\three");
841 ok(!res, "Expected failure\n");
842 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
843
844 /* try empty pszPath */
845 path[0] = '\0';
846 SetLastError(0xdeadbeef);
847 res = PathAppendA(path, "two\\three");
848 ok(res, "Expected success\n");
849 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
850 ok(!lstrcmpA(path, "two\\three"), "Expected \\two\\three, got %s\n", path);
851
852 /* try empty pszPath and empty pszMore */
853 path[0] = '\0';
854 SetLastError(0xdeadbeef);
855 res = PathAppendA(path, "");
856 ok(res, "Expected success\n");
857 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
858 ok(!lstrcmpA(path, "\\"), "Expected \\, got %s\n", path);
859
860 /* try legit params */
861 lstrcpyA(path, "C:\\one");
862 SetLastError(0xdeadbeef);
863 res = PathAppendA(path, "two\\three");
864 ok(res, "Expected success\n");
865 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
866 ok(!lstrcmpA(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
867
868 /* try pszPath with backslash after it */
869 lstrcpyA(path, "C:\\one\\");
870 SetLastError(0xdeadbeef);
871 res = PathAppendA(path, "two\\three");
872 ok(res, "Expected success\n");
873 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
874 ok(!lstrcmpA(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
875
876 /* try pszMore with backslash before it */
877 lstrcpyA(path, "C:\\one");
878 SetLastError(0xdeadbeef);
879 res = PathAppendA(path, "\\two\\three");
880 ok(res, "Expected success\n");
881 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
882 ok(!lstrcmpA(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
883
884 /* try pszMore with backslash after it */
885 lstrcpyA(path, "C:\\one");
886 SetLastError(0xdeadbeef);
887 res = PathAppendA(path, "two\\three\\");
888 ok(res, "Expected success\n");
889 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
890 ok(!lstrcmpA(path, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", path);
891
892 /* try spaces in pszPath */
893 lstrcpyA(path, "C: \\ one ");
894 SetLastError(0xdeadbeef);
895 res = PathAppendA(path, "two\\three");
896 ok(res, "Expected success\n");
897 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
898 ok(!lstrcmpA(path, "C: \\ one \\two\\three"), "Expected C: \\ one \\two\\three, got %s\n", path);
899
900 /* try spaces in pszMore */
901 lstrcpyA(path, "C:\\one");
902 SetLastError(0xdeadbeef);
903 res = PathAppendA(path, " two \\ three ");
904 ok(res, "Expected success\n");
905 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
906 ok(!lstrcmpA(path, "C:\\one\\ two \\ three "), "Expected 'C:\\one\\ two \\ three ', got %s\n", path);
907
908 /* pszPath is too long */
909 memset(too_long, 'a', LONG_LEN);
910 too_long[LONG_LEN - 1] = '\0';
911 SetLastError(0xdeadbeef);
912 res = PathAppendA(too_long, "two\\three");
913 ok(!res, "Expected failure\n");
914 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
915 ok(!too_long[0] || broken(lstrlenA(too_long) == (LONG_LEN - 1)), /* Win95 and some W2K */
916 "Expected length of too_long to be zero, got %i\n", lstrlenA(too_long));
917
918 /* pszMore is too long */
919 lstrcpyA(path, "C:\\one");
920 memset(too_long, 'a', LONG_LEN);
921 too_long[LONG_LEN - 1] = '\0';
922 SetLastError(0xdeadbeef);
923 res = PathAppendA(path, too_long);
924 ok(!res, "Expected failure\n");
925 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
926 ok(!path[0] || broken(!lstrcmpA(path, "C:\\one")), /* Win95 and some W2K */
927 "Expected length of path to be zero, got %i\n", lstrlenA(path));
928
929 /* both params combined are too long */
930 memset(path, 'a', HALF_LEN);
931 path[HALF_LEN - 1] = '\0';
932 memset(half, 'b', HALF_LEN);
933 half[HALF_LEN - 1] = '\0';
934 SetLastError(0xdeadbeef);
935 res = PathAppendA(path, half);
936 ok(!res, "Expected failure\n");
937 ok(!path[0] || broken(lstrlenA(path) == (HALF_LEN - 1)), /* Win95 and some W2K */
938 "Expected length of path to be zero, got %i\n", lstrlenA(path));
939 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
940 }
941
942 static void test_PathCanonicalizeA(void)
943 {
944 char dest[LONG_LEN + MAX_PATH];
945 char too_long[LONG_LEN];
946 BOOL res;
947
948 /* try a NULL source */
949 lstrcpyA(dest, "test");
950 SetLastError(0xdeadbeef);
951 res = PathCanonicalizeA(dest, NULL);
952 ok(!res, "Expected failure\n");
953 ok(GetLastError() == ERROR_INVALID_PARAMETER,
954 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
955 ok(dest[0] == 0 || !lstrcmpA(dest, "test"),
956 "Expected either an empty string (Vista) or test, got %s\n", dest);
957
958 /* try an empty source */
959 lstrcpyA(dest, "test");
960 SetLastError(0xdeadbeef);
961 res = PathCanonicalizeA(dest, "");
962 ok(res, "Expected success\n");
963 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
964 ok(!lstrcmpA(dest, "\\") ||
965 broken(!lstrcmpA(dest, "test")), /* Win95 and some W2K */
966 "Expected \\, got %s\n", dest);
967
968 /* try a NULL dest */
969 SetLastError(0xdeadbeef);
970 res = PathCanonicalizeA(NULL, "C:\\");
971 ok(!res, "Expected failure\n");
972 ok(GetLastError() == ERROR_INVALID_PARAMETER,
973 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
974
975 /* try empty dest */
976 dest[0] = '\0';
977 SetLastError(0xdeadbeef);
978 res = PathCanonicalizeA(dest, "C:\\");
979 ok(res, "Expected success\n");
980 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
981 ok(!lstrcmpA(dest, "C:\\"), "Expected C:\\, got %s\n", dest);
982
983 /* try non-empty dest */
984 lstrcpyA(dest, "test");
985 SetLastError(0xdeadbeef);
986 res = PathCanonicalizeA(dest, "C:\\");
987 ok(res, "Expected success\n");
988 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
989 ok(!lstrcmpA(dest, "C:\\"), "Expected C:\\, got %s\n", dest);
990
991 /* try a space for source */
992 lstrcpyA(dest, "test");
993 SetLastError(0xdeadbeef);
994 res = PathCanonicalizeA(dest, " ");
995 ok(res, "Expected success\n");
996 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
997 ok(!lstrcmpA(dest, " "), "Expected ' ', got %s\n", dest);
998
999 /* try a relative path */
1000 lstrcpyA(dest, "test");
1001 SetLastError(0xdeadbeef);
1002 res = PathCanonicalizeA(dest, "one\\two");
1003 ok(res, "Expected success\n");
1004 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1005 ok(!lstrcmpA(dest, "one\\two"), "Expected one\\two, got %s\n", dest);
1006
1007 /* try current dir and previous dir */
1008 lstrcpyA(dest, "test");
1009 SetLastError(0xdeadbeef);
1010 res = PathCanonicalizeA(dest, "C:\\one\\.\\..\\two\\three\\..");
1011 ok(res, "Expected success\n");
1012 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1013 ok(!lstrcmpA(dest, "C:\\two"), "Expected C:\\two, got %s\n", dest);
1014
1015 /* try simple forward slashes */
1016 lstrcpyA(dest, "test");
1017 SetLastError(0xdeadbeef);
1018 res = PathCanonicalizeA(dest, "C:\\one/two/three\\four/five\\six");
1019 ok(res, "Expected success\n");
1020 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1021 ok(!lstrcmpA(dest, "C:\\one/two/three\\four/five\\six"),
1022 "Expected C:\\one/two/three\\four/five\\six, got %s\n", dest);
1023
1024 /* try simple forward slashes with same dir */
1025 lstrcpyA(dest, "test");
1026 SetLastError(0xdeadbeef);
1027 res = PathCanonicalizeA(dest, "C:\\one/.\\two");
1028 ok(res, "Expected success\n");
1029 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1030 ok(!lstrcmpA(dest, "C:\\one/.\\two"), "Expected C:\\one/.\\two, got %s\n", dest);
1031
1032 /* try simple forward slashes with change dir */
1033 lstrcpyA(dest, "test");
1034 SetLastError(0xdeadbeef);
1035 res = PathCanonicalizeA(dest, "C:\\one/.\\two\\..");
1036 ok(res, "Expected success\n");
1037 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1038 ok(!lstrcmpA(dest, "C:\\one/.") ||
1039 !lstrcmpA(dest, "C:\\one/"), /* Vista */
1040 "Expected \"C:\\one/.\" or \"C:\\one/\", got \"%s\"\n", dest);
1041
1042 /* try forward slashes with change dirs
1043 * NOTE: if there is a forward slash in between two backslashes,
1044 * everything in between the two backslashes is considered on dir
1045 */
1046 lstrcpyA(dest, "test");
1047 SetLastError(0xdeadbeef);
1048 res = PathCanonicalizeA(dest, "C:\\one/.\\..\\two/three\\..\\four/.five");
1049 ok(res, "Expected success\n");
1050 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1051 ok(!lstrcmpA(dest, "C:\\four/.five"), "Expected C:\\four/.five, got %s\n", dest);
1052
1053 /* try src is too long */
1054 memset(too_long, 'a', LONG_LEN);
1055 too_long[LONG_LEN - 1] = '\0';
1056 lstrcpyA(dest, "test");
1057 SetLastError(0xdeadbeef);
1058 res = PathCanonicalizeA(dest, too_long);
1059 ok(!res ||
1060 broken(res), /* Win95, some W2K and XP-SP1 */
1061 "Expected failure\n");
1062 todo_wine
1063 {
1064 ok(GetLastError() == 0xdeadbeef || GetLastError() == ERROR_FILENAME_EXCED_RANGE /* Vista */,
1065 "Expected 0xdeadbeef or ERROR_FILENAME_EXCED_RANGE, got %d\n", GetLastError());
1066 }
1067 ok(lstrlenA(too_long) == LONG_LEN - 1, "Expected length LONG_LEN - 1, got %i\n", lstrlenA(too_long));
1068 }
1069
1070 static void test_PathFindExtensionA(void)
1071 {
1072 LPSTR ext;
1073 char path[MAX_PATH];
1074 char too_long[LONG_LEN];
1075
1076 /* try a NULL path */
1077 SetLastError(0xdeadbeef);
1078 ext = PathFindExtensionA(NULL);
1079 ok(ext == NULL, "Expected NULL, got %p\n", ext);
1080 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1081
1082 /* try an empty path */
1083 path[0] = '\0';
1084 SetLastError(0xdeadbeef);
1085 ext = PathFindExtensionA(path);
1086 ok(ext == path, "Expected ext == path, got %p\n", ext);
1087 ok(!ext[0], "Expected length 0, got %i\n", lstrlenA(ext));
1088 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1089
1090 /* try a path without an extension */
1091 lstrcpyA(path, "file");
1092 SetLastError(0xdeadbeef);
1093 ext = PathFindExtensionA(path);
1094 ok(ext == path + lstrlenA(path), "Expected ext == path, got %p\n", ext);
1095 ok(!ext[0], "Expected length 0, got %i\n", lstrlenA(ext));
1096 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1097
1098 /* try a path with an extension */
1099 lstrcpyA(path, "file.txt");
1100 SetLastError(0xdeadbeef);
1101 ext = PathFindExtensionA(path);
1102 ok(ext == path + lstrlenA("file"),
1103 "Expected ext == path + lstrlenA(\"file\"), got %p\n", ext);
1104 ok(!lstrcmpA(ext, ".txt"), "Expected .txt, got %s\n", ext);
1105 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1106
1107 /* try a path with two extensions */
1108 lstrcpyA(path, "file.txt.doc");
1109 SetLastError(0xdeadbeef);
1110 ext = PathFindExtensionA(path);
1111 ok(ext == path + lstrlenA("file.txt"),
1112 "Expected ext == path + lstrlenA(\"file.txt\"), got %p\n", ext);
1113 ok(!lstrcmpA(ext, ".doc"), "Expected .txt, got %s\n", ext);
1114 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1115
1116 /* try a path longer than MAX_PATH without an extension*/
1117 memset(too_long, 'a', LONG_LEN);
1118 too_long[LONG_LEN - 1] = '\0';
1119 SetLastError(0xdeadbeef);
1120 ext = PathFindExtensionA(too_long);
1121 ok(ext == too_long + LONG_LEN - 1, "Expected ext == too_long + LONG_LEN - 1, got %p\n", ext);
1122 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1123
1124 /* try a path longer than MAX_PATH with an extension*/
1125 memset(too_long, 'a', LONG_LEN);
1126 too_long[LONG_LEN - 1] = '\0';
1127 lstrcpyA(too_long + 300, ".abcde");
1128 too_long[lstrlenA(too_long)] = 'a';
1129 SetLastError(0xdeadbeef);
1130 ext = PathFindExtensionA(too_long);
1131 ok(ext == too_long + 300, "Expected ext == too_long + 300, got %p\n", ext);
1132 ok(lstrlenA(ext) == LONG_LEN - 301, "Expected LONG_LEN - 301, got %i\n", lstrlenA(ext));
1133 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1134 }
1135
1136 static void test_PathBuildRootA(void)
1137 {
1138 LPSTR root;
1139 char path[10];
1140 char root_expected[26][4];
1141 char drive;
1142 int j;
1143
1144 /* set up the expected paths */
1145 for (drive = 'A'; drive <= 'Z'; drive++)
1146 sprintf(root_expected[drive - 'A'], "%c:\\", drive);
1147
1148 /* test the expected values */
1149 for (j = 0; j < 26; j++)
1150 {
1151 SetLastError(0xdeadbeef);
1152 lstrcpyA(path, "aaaaaaaaa");
1153 root = PathBuildRootA(path, j);
1154 ok(root == path, "Expected root == path, got %p\n", root);
1155 ok(!lstrcmpA(root, root_expected[j]), "Expected %s, got %s\n", root_expected[j], root);
1156 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1157 }
1158
1159 /* test a negative drive number */
1160 SetLastError(0xdeadbeef);
1161 lstrcpyA(path, "aaaaaaaaa");
1162 root = PathBuildRootA(path, -1);
1163 ok(root == path, "Expected root == path, got %p\n", root);
1164 ok(!lstrcmpA(path, "aaaaaaaaa") || !path[0], /* Vista */
1165 "Expected aaaaaaaaa or empty string, got %s\n", path);
1166 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1167
1168 /* test a drive number greater than 25 */
1169 SetLastError(0xdeadbeef);
1170 lstrcpyA(path, "aaaaaaaaa");
1171 root = PathBuildRootA(path, 26);
1172 ok(root == path, "Expected root == path, got %p\n", root);
1173 ok(!lstrcmpA(path, "aaaaaaaaa") || !path[0], /* Vista */
1174 "Expected aaaaaaaaa or empty string, got %s\n", path);
1175 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1176
1177 /* length of path is less than 4 */
1178 SetLastError(0xdeadbeef);
1179 lstrcpyA(path, "aa");
1180 root = PathBuildRootA(path, 0);
1181 ok(root == path, "Expected root == path, got %p\n", root);
1182 ok(!lstrcmpA(path, "A:\\"), "Expected A:\\, got %s\n", path);
1183 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1184
1185 /* path is NULL */
1186 SetLastError(0xdeadbeef);
1187 root = PathBuildRootA(NULL, 0);
1188 ok(root == NULL, "Expected root == NULL, got %p\n", root);
1189 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1190 }
1191
1192 static void test_PathCommonPrefixA(void)
1193 {
1194 char path1[MAX_PATH], path2[MAX_PATH];
1195 char out[MAX_PATH];
1196 int count;
1197
1198 /* test NULL path1 */
1199 SetLastError(0xdeadbeef);
1200 lstrcpyA(path2, "C:\\");
1201 lstrcpyA(out, "aaa");
1202 count = PathCommonPrefixA(NULL, path2, out);
1203 ok(count == 0, "Expected 0, got %i\n", count);
1204 todo_wine
1205 {
1206 ok(!lstrcmpA(out, "aaa"), "Expected aaa, got %s\n", out);
1207 }
1208 ok(!lstrcmpA(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1209 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1210
1211 /* test NULL path2 */
1212 SetLastError(0xdeadbeef);
1213 lstrcpyA(path1, "C:\\");
1214 lstrcpyA(out, "aaa");
1215 count = PathCommonPrefixA(path1, NULL, out);
1216 ok(count == 0, "Expected 0, got %i\n", count);
1217 todo_wine
1218 {
1219 ok(!lstrcmpA(out, "aaa"), "Expected aaa, got %s\n", out);
1220 }
1221 ok(!lstrcmpA(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1222 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1223
1224 /* test empty path1 */
1225 SetLastError(0xdeadbeef);
1226 path1[0] = '\0';
1227 lstrcpyA(path2, "C:\\");
1228 lstrcpyA(out, "aaa");
1229 count = PathCommonPrefixA(path1, path2, out);
1230 ok(count == 0, "Expected 0, got %i\n", count);
1231 ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out));
1232 ok(!path1[0], "Expected 0 length path1, got %i\n", lstrlenA(path1));
1233 ok(!lstrcmpA(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1234 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1235
1236 /* test empty path1 */
1237 SetLastError(0xdeadbeef);
1238 path2[0] = '\0';
1239 lstrcpyA(path1, "C:\\");
1240 lstrcpyA(out, "aaa");
1241 count = PathCommonPrefixA(path1, path2, out);
1242 ok(count == 0, "Expected 0, got %i\n", count);
1243 ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out));
1244 ok(!path2[0], "Expected 0 length path2, got %i\n", lstrlenA(path2));
1245 ok(!lstrcmpA(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1246 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1247
1248 /* paths are legit, out is NULL */
1249 SetLastError(0xdeadbeef);
1250 lstrcpyA(path1, "C:\\");
1251 lstrcpyA(path2, "C:\\");
1252 count = PathCommonPrefixA(path1, path2, NULL);
1253 ok(count == 3, "Expected 3, got %i\n", count);
1254 ok(!lstrcmpA(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1255 ok(!lstrcmpA(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1256 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1257
1258 /* all parameters legit */
1259 SetLastError(0xdeadbeef);
1260 lstrcpyA(path1, "C:\\");
1261 lstrcpyA(path2, "C:\\");
1262 lstrcpyA(out, "aaa");
1263 count = PathCommonPrefixA(path1, path2, out);
1264 ok(count == 3, "Expected 3, got %i\n", count);
1265 ok(!lstrcmpA(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1266 ok(!lstrcmpA(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1267 ok(!lstrcmpA(out, "C:\\"), "Expected C:\\, got %s\n", out);
1268 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1269
1270 /* path1 and path2 not the same, but common prefix */
1271 SetLastError(0xdeadbeef);
1272 lstrcpyA(path1, "C:\\one\\two");
1273 lstrcpyA(path2, "C:\\one\\three");
1274 lstrcpyA(out, "aaa");
1275 count = PathCommonPrefixA(path1, path2, out);
1276 ok(count == 6, "Expected 6, got %i\n", count);
1277 ok(!lstrcmpA(path1, "C:\\one\\two"), "Expected C:\\one\\two, got %s\n", path1);
1278 ok(!lstrcmpA(path2, "C:\\one\\three"), "Expected C:\\one\\three, got %s\n", path2);
1279 ok(!lstrcmpA(out, "C:\\one"), "Expected C:\\one, got %s\n", out);
1280 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1281
1282 /* try . prefix */
1283 SetLastError(0xdeadbeef);
1284 lstrcpyA(path1, "one\\.two");
1285 lstrcpyA(path2, "one\\.three");
1286 lstrcpyA(out, "aaa");
1287 count = PathCommonPrefixA(path1, path2, out);
1288 ok(count == 3, "Expected 3, got %i\n", count);
1289 ok(!lstrcmpA(path1, "one\\.two"), "Expected one\\.two, got %s\n", path1);
1290 ok(!lstrcmpA(path2, "one\\.three"), "Expected one\\.three, got %s\n", path2);
1291 ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out);
1292 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1293
1294 /* try .. prefix */
1295 SetLastError(0xdeadbeef);
1296 lstrcpyA(path1, "one\\..two");
1297 lstrcpyA(path2, "one\\..three");
1298 lstrcpyA(out, "aaa");
1299 count = PathCommonPrefixA(path1, path2, out);
1300 ok(count == 3, "Expected 3, got %i\n", count);
1301 ok(!lstrcmpA(path1, "one\\..two"), "Expected one\\..two, got %s\n", path1);
1302 ok(!lstrcmpA(path2, "one\\..three"), "Expected one\\..three, got %s\n", path2);
1303 ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out);
1304 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1305
1306 /* try ... prefix */
1307 SetLastError(0xdeadbeef);
1308 lstrcpyA(path1, "one\\...two");
1309 lstrcpyA(path2, "one\\...three");
1310 lstrcpyA(out, "aaa");
1311 count = PathCommonPrefixA(path1, path2, out);
1312 ok(count == 3, "Expected 3, got %i\n", count);
1313 ok(!lstrcmpA(path1, "one\\...two"), "Expected one\\...two, got %s\n", path1);
1314 ok(!lstrcmpA(path2, "one\\...three"), "Expected one\\...three, got %s\n", path2);
1315 ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out);
1316 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1317
1318 /* try .\ prefix */
1319 SetLastError(0xdeadbeef);
1320 lstrcpyA(path1, "one\\.\\two");
1321 lstrcpyA(path2, "one\\.\\three");
1322 lstrcpyA(out, "aaa");
1323 count = PathCommonPrefixA(path1, path2, out);
1324 ok(count == 5, "Expected 5, got %i\n", count);
1325 ok(!lstrcmpA(path1, "one\\.\\two"), "Expected one\\.\\two, got %s\n", path1);
1326 ok(!lstrcmpA(path2, "one\\.\\three"), "Expected one\\.\\three, got %s\n", path2);
1327 ok(!lstrcmpA(out, "one\\."), "Expected one\\., got %s\n", out);
1328 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1329
1330 /* try ..\ prefix */
1331 SetLastError(0xdeadbeef);
1332 lstrcpyA(path1, "one\\..\\two");
1333 lstrcpyA(path2, "one\\..\\three");
1334 lstrcpyA(out, "aaa");
1335 count = PathCommonPrefixA(path1, path2, out);
1336 ok(count == 6, "Expected 6, got %i\n", count);
1337 ok(!lstrcmpA(path1, "one\\..\\two"), "Expected one\\..\\two, got %s\n", path1);
1338 ok(!lstrcmpA(path2, "one\\..\\three"), "Expected one\\..\\three, got %s\n", path2);
1339 ok(!lstrcmpA(out, "one\\.."), "Expected one\\.., got %s\n", out);
1340 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1341
1342 /* try ...\\ prefix */
1343 SetLastError(0xdeadbeef);
1344 lstrcpyA(path1, "one\\...\\two");
1345 lstrcpyA(path2, "one\\...\\three");
1346 lstrcpyA(out, "aaa");
1347 count = PathCommonPrefixA(path1, path2, out);
1348 ok(count == 7, "Expected 7, got %i\n", count);
1349 ok(!lstrcmpA(path1, "one\\...\\two"), "Expected one\\...\\two, got %s\n", path1);
1350 ok(!lstrcmpA(path2, "one\\...\\three"), "Expected one\\...\\three, got %s\n", path2);
1351 ok(!lstrcmpA(out, "one\\..."), "Expected one\\..., got %s\n", out);
1352 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1353
1354 /* try prefix that is not an msdn labeled prefix type */
1355 SetLastError(0xdeadbeef);
1356 lstrcpyA(path1, "same");
1357 lstrcpyA(path2, "same");
1358 lstrcpyA(out, "aaa");
1359 count = PathCommonPrefixA(path1, path2, out);
1360 ok(count == 4, "Expected 4, got %i\n", count);
1361 ok(!lstrcmpA(path1, "same"), "Expected same, got %s\n", path1);
1362 ok(!lstrcmpA(path2, "same"), "Expected same, got %s\n", path2);
1363 ok(!lstrcmpA(out, "same"), "Expected same, got %s\n", out);
1364 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1365
1366 /* try . after directory */
1367 SetLastError(0xdeadbeef);
1368 lstrcpyA(path1, "one\\mid.\\two");
1369 lstrcpyA(path2, "one\\mid.\\three");
1370 lstrcpyA(out, "aaa");
1371 count = PathCommonPrefixA(path1, path2, out);
1372 ok(count == 8, "Expected 8, got %i\n", count);
1373 ok(!lstrcmpA(path1, "one\\mid.\\two"), "Expected one\\mid.\\two, got %s\n", path1);
1374 ok(!lstrcmpA(path2, "one\\mid.\\three"), "Expected one\\mid.\\three, got %s\n", path2);
1375 ok(!lstrcmpA(out, "one\\mid."), "Expected one\\mid., got %s\n", out);
1376 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1377
1378 /* try . in the middle of a directory */
1379 SetLastError(0xdeadbeef);
1380 lstrcpyA(path1, "one\\mid.end\\two");
1381 lstrcpyA(path2, "one\\mid.end\\three");
1382 lstrcpyA(out, "aaa");
1383 count = PathCommonPrefixA(path1, path2, out);
1384 ok(count == 11, "Expected 11, got %i\n", count);
1385 ok(!lstrcmpA(path1, "one\\mid.end\\two"), "Expected one\\mid.end\\two, got %s\n", path1);
1386 ok(!lstrcmpA(path2, "one\\mid.end\\three"), "Expected one\\mid.end\\three, got %s\n", path2);
1387 ok(!lstrcmpA(out, "one\\mid.end"), "Expected one\\mid.end, got %s\n", out);
1388 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1389
1390 /* try comparing a .. with the expanded path */
1391 SetLastError(0xdeadbeef);
1392 lstrcpyA(path1, "one\\..\\two");
1393 lstrcpyA(path2, "two");
1394 lstrcpyA(out, "aaa");
1395 count = PathCommonPrefixA(path1, path2, out);
1396 ok(count == 0, "Expected 0, got %i\n", count);
1397 ok(!lstrcmpA(path1, "one\\..\\two"), "Expected one\\..\\two, got %s\n", path1);
1398 ok(!lstrcmpA(path2, "two"), "Expected two, got %s\n", path2);
1399 ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out));
1400 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1401 }
1402
1403 static void test_PathUnquoteSpaces(void)
1404 {
1405 int i;
1406 for(i = 0; i < sizeof(TEST_PATH_UNQUOTE_SPACES) / sizeof(TEST_PATH_UNQUOTE_SPACES[0]); i++)
1407 {
1408 char *path = strdupA(TEST_PATH_UNQUOTE_SPACES[i].path);
1409 WCHAR *pathW = GetWideString(TEST_PATH_UNQUOTE_SPACES[i].path);
1410 WCHAR *resultW = GetWideString(TEST_PATH_UNQUOTE_SPACES[i].result);
1411
1412 PathUnquoteSpacesA(path);
1413 ok(!strcmp(path, TEST_PATH_UNQUOTE_SPACES[i].result), "%s (A): got %s expected %s\n",
1414 TEST_PATH_UNQUOTE_SPACES[i].path, path,
1415 TEST_PATH_UNQUOTE_SPACES[i].result);
1416
1417 PathUnquoteSpacesW(pathW);
1418 ok(!lstrcmpW(pathW, resultW), "%s (W): strings differ\n",
1419 TEST_PATH_UNQUOTE_SPACES[i].path);
1420 FreeWideString(pathW);
1421 FreeWideString(resultW);
1422 HeapFree(GetProcessHeap(), 0, path);
1423 }
1424 }
1425
1426 static void test_PathGetDriveNumber(void)
1427 {
1428 static const CHAR test1A[] = "a:\\test.file";
1429 static const CHAR test2A[] = "file:////b:\\test.file";
1430 static const CHAR test3A[] = "file:///c:\\test.file";
1431 static const CHAR test4A[] = "file:\\\\c:\\test.file";
1432 static const CHAR test5A[] = "\\\\?\\C:\\dir\\file.txt";
1433 static const WCHAR test1W[] =
1434 {'a',':','\\',0};
1435 static const WCHAR test5W[] =
1436 {'\\','\\','?','\\','C',':','\\','d','i','r','\\','f','i','l','e',0};
1437 int ret;
1438
1439 SetLastError(0xdeadbeef);
1440 ret = PathGetDriveNumberA(NULL);
1441 ok(ret == -1, "got %d\n", ret);
1442 ok(GetLastError() == 0xdeadbeef, "got %d\n", GetLastError());
1443
1444 ret = PathGetDriveNumberA(test1A);
1445 ok(ret == 0, "got %d\n", ret);
1446 ret = PathGetDriveNumberW(test1W);
1447 ok(ret == 0, "got %d\n", ret);
1448 ret = PathGetDriveNumberA(test2A);
1449 ok(ret == -1, "got %d\n", ret);
1450 ret = PathGetDriveNumberA(test3A);
1451 ok(ret == -1, "got %d\n", ret);
1452 ret = PathGetDriveNumberA(test4A);
1453 ok(ret == -1, "got %d\n", ret);
1454
1455 ret = PathGetDriveNumberA(test5A);
1456 ok(ret == -1, "got %d\n", ret);
1457 ret = PathGetDriveNumberW(test5W);
1458 ok(ret == 2 || broken(ret == -1) /* winxp */, "got = %d\n", ret);
1459 }
1460
1461 static void test_PathUnExpandEnvStrings(void)
1462 {
1463 static const WCHAR sysrootW[] = {'%','S','y','s','t','e','m','R','o','o','t','%',0};
1464 static const WCHAR sysdriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%',0};
1465 static const WCHAR nonpathW[] = {'p','a','t','h',0};
1466 static const WCHAR computernameW[] = {'C','O','M','P','U','T','E','R','N','A','M','E',0};
1467 static const char sysrootA[] = "%SystemRoot%";
1468 static const char sysdriveA[] = "%SystemDrive%";
1469 WCHAR pathW[MAX_PATH], buffW[MAX_PATH], sysdrvW[3], envvarW[30];
1470 char path[MAX_PATH], buff[MAX_PATH], sysdrvA[3], envvarA[30];
1471 BOOL ret;
1472 UINT len;
1473
1474 if (!pPathUnExpandEnvStringsA || !pPathUnExpandEnvStringsW)
1475 {
1476 win_skip("PathUnExpandEnvStrings not available\n");
1477 return;
1478 }
1479
1480 /* The value of ComputerName is not a path */
1481 ret = GetEnvironmentVariableA("COMPUTERNAME", envvarA, sizeof(envvarA));
1482 ok(ret, "got %d\n", ret);
1483 SetLastError(0xdeadbeef);
1484 ret = pPathUnExpandEnvStringsA(envvarA, buff, sizeof(buff));
1485 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1486
1487 ret = GetEnvironmentVariableW(computernameW, envvarW, sizeof(envvarW)/sizeof(WCHAR));
1488 ok(ret, "got %d\n", ret);
1489 SetLastError(0xdeadbeef);
1490 ret = pPathUnExpandEnvStringsW(envvarW, buffW, sizeof(buffW)/sizeof(WCHAR));
1491 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1492
1493 /* something that can't be represented with env var */
1494 strcpy(path, "somepath_name");
1495 strcpy(buff, "xx");
1496 SetLastError(0xdeadbeef);
1497 ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff));
1498 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1499 ok(buff[0] == 'x', "wrong return string %s\n", buff);
1500
1501 len = GetSystemDirectoryA(path, MAX_PATH);
1502 ok(len > 0, "failed to get sysdir\n");
1503
1504 sysdrvA[0] = path[0];
1505 strcpy(&sysdrvA[1], ":");
1506
1507 /* buffer size is not enough */
1508 strcpy(buff, "xx");
1509 SetLastError(0xdeadbeef);
1510 ret = pPathUnExpandEnvStringsA(path, buff, 5);
1511 ok(!ret && GetLastError() == 0xdeadbeef, "got %d\n", ret);
1512 ok(buff[0] == 'x', "wrong return string %s\n", buff);
1513
1514 /* buffer size is enough to hold variable name only */
1515 strcpy(buff, "xx");
1516 SetLastError(0xdeadbeef);
1517 ret = pPathUnExpandEnvStringsA(path, buff, sizeof(sysrootA));
1518 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1519 ok(buff[0] == 'x', "wrong return string %s\n", buff);
1520
1521 /* enough size */
1522 buff[0] = 0;
1523 ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff));
1524 ok(ret, "got %d\n", ret);
1525 ok(!strncmp(buff, sysrootA, sizeof(sysrootA)-1), "wrong return string %s\n", buff);
1526
1527 /* expanded value occurs multiple times */
1528 /* for drive C: it unexpands it like 'C:C:' -> '%SystemDrive%C:' */
1529 buff[0] = 0;
1530 strcpy(path, sysdrvA);
1531 strcat(path, sysdrvA);
1532 ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff));
1533 ok(ret, "got %d\n", ret);
1534 /* expected string */
1535 strcpy(path, sysdriveA);
1536 strcat(path, sysdrvA);
1537 ok(!strcmp(buff, path), "wrong unexpanded string %s, expected %s\n", buff, path);
1538
1539 /* now with altered variable */
1540 ret = GetEnvironmentVariableA("SystemDrive", envvarA, sizeof(envvarA));
1541 ok(ret, "got %d\n", ret);
1542
1543 ret = SetEnvironmentVariableA("SystemDrive", "WW");
1544 ok(ret, "got %d\n", ret);
1545
1546 /* variables are not cached */
1547 strcpy(path, sysdrvA);
1548 strcat(path, sysdrvA);
1549 SetLastError(0xdeadbeef);
1550 ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff));
1551 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1552
1553 ret = SetEnvironmentVariableA("SystemDrive", envvarA);
1554 ok(ret, "got %d\n", ret);
1555
1556 /* PathUnExpandEnvStringsW */
1557
1558 /* something that can't be represented with env var */
1559 lstrcpyW(pathW, nonpathW);
1560 buffW[0] = 'x'; buffW[1] = 0;
1561 SetLastError(0xdeadbeef);
1562 ret = pPathUnExpandEnvStringsW(pathW, buffW, sizeof(buffW)/sizeof(WCHAR));
1563 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1564 ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
1565
1566 len = GetSystemDirectoryW(pathW, MAX_PATH);
1567 ok(len > 0, "failed to get sysdir\n");
1568
1569 sysdrvW[0] = pathW[0];
1570 sysdrvW[1] = ':';
1571 sysdrvW[2] = 0;
1572
1573 /* buffer size is not enough */
1574 buffW[0] = 'x'; buffW[1] = 0;
1575 SetLastError(0xdeadbeef);
1576 ret = pPathUnExpandEnvStringsW(pathW, buffW, 5);
1577 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1578 ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
1579
1580 /* buffer size is enough to hold variable name only */
1581 buffW[0] = 'x'; buffW[1] = 0;
1582 SetLastError(0xdeadbeef);
1583 ret = pPathUnExpandEnvStringsW(pathW, buffW, sizeof(sysrootW)/sizeof(WCHAR));
1584 ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError());
1585 ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
1586
1587 /* enough size */
1588 buffW[0] = 0;
1589 ret = pPathUnExpandEnvStringsW(pathW, buffW, sizeof(buffW)/sizeof(WCHAR));
1590 ok(ret, "got %d\n", ret);
1591 ok(!memcmp(buffW, sysrootW, sizeof(sysrootW) - sizeof(WCHAR)), "wrong return string %s\n", wine_dbgstr_w(buffW));
1592
1593 /* expanded value occurs multiple times */
1594 /* for drive C: it unexpands it like 'C:C:' -> '%SystemDrive%C:' */
1595 buffW[0] = 0;
1596 lstrcpyW(pathW, sysdrvW);
1597 lstrcatW(pathW, sysdrvW);
1598 ret = pPathUnExpandEnvStringsW(pathW, buffW, sizeof(buff)/sizeof(WCHAR));
1599 ok(ret, "got %d\n", ret);
1600 /* expected string */
1601 lstrcpyW(pathW, sysdriveW);
1602 lstrcatW(pathW, sysdrvW);
1603 ok(!lstrcmpW(buffW, pathW), "wrong unexpanded string %s, expected %s\n", wine_dbgstr_w(buffW), wine_dbgstr_w(pathW));
1604 }
1605
1606 static const struct {
1607 const char *path;
1608 BOOL expect;
1609 } test_path_is_relative[] = {
1610 {NULL, TRUE},
1611 {"\0", TRUE},
1612 {"test.txt", TRUE},
1613 {"\\\\folder\\test.txt", FALSE},
1614 {"file://folder/test.txt", TRUE},
1615 {"C:\\test.txt", FALSE},
1616 {"file:///C:/test.txt", TRUE}
1617 };
1618
1619 static void test_PathIsRelativeA(void)
1620 {
1621 BOOL ret;
1622 int i, num;
1623
1624 if (!pPathIsRelativeA) {
1625 win_skip("PathIsRelativeA not available\n");
1626 return;
1627 }
1628
1629 num = sizeof(test_path_is_relative) / sizeof(test_path_is_relative[0]);
1630 for (i = 0; i < num; i++) {
1631 ret = pPathIsRelativeA(test_path_is_relative[i].path);
1632 ok(ret == test_path_is_relative[i].expect,
1633 "PathIsRelativeA(\"%s\") expects %d, got %d.\n",
1634 test_path_is_relative[i].path, test_path_is_relative[i].expect, ret);
1635 }
1636 }
1637
1638 static void test_PathIsRelativeW(void)
1639 {
1640 BOOL ret;
1641 int i, num;
1642 LPWSTR path;
1643
1644 if (!pPathIsRelativeW) {
1645 win_skip("PathIsRelativeW not available\n");
1646 return;
1647 }
1648
1649 num = sizeof(test_path_is_relative) / sizeof(test_path_is_relative[0]);
1650 for (i = 0; i < num; i++) {
1651 path = GetWideString(test_path_is_relative[i].path);
1652
1653 ret = pPathIsRelativeW(path);
1654 ok(ret == test_path_is_relative[i].expect,
1655 "PathIsRelativeW(\"%s\") expects %d, got %d.\n",
1656 test_path_is_relative[i].path, test_path_is_relative[i].expect, ret);
1657
1658 FreeWideString(path);
1659 }
1660 }
1661
1662 static void test_PathStripPathA(void)
1663 {
1664 const char const_path[] = "test";
1665 char path[] = "short//path\\file.txt";
1666
1667 PathStripPathA(path);
1668 ok(!strcmp(path, "file.txt"), "path = %s\n", path);
1669
1670 /* following test should not crash */
1671 /* LavView 2013 depends on that behaviour */
1672 PathStripPathA((char*)const_path);
1673 }
1674
1675 START_TEST(path)
1676 {
1677 HMODULE hShlwapi = GetModuleHandleA("shlwapi.dll");
1678
1679 /* SHCreateStreamOnFileEx was introduced in shlwapi v6.0 */
1680 if(!GetProcAddress(hShlwapi, "SHCreateStreamOnFileEx")){
1681 win_skip("Too old shlwapi version\n");
1682 return;
1683 }
1684
1685 pPathCreateFromUrlA = (void*)GetProcAddress(hShlwapi, "PathCreateFromUrlA");
1686 pPathCreateFromUrlW = (void*)GetProcAddress(hShlwapi, "PathCreateFromUrlW");
1687 pPathCreateFromUrlAlloc = (void*)GetProcAddress(hShlwapi, "PathCreateFromUrlAlloc");
1688 pPathCombineW = (void*)GetProcAddress(hShlwapi, "PathCombineW");
1689 pPathIsValidCharA = (void*)GetProcAddress(hShlwapi, (LPSTR)455);
1690 pPathIsValidCharW = (void*)GetProcAddress(hShlwapi, (LPSTR)456);
1691 pPathAppendA = (void*)GetProcAddress(hShlwapi, "PathAppendA");
1692 pPathUnExpandEnvStringsA = (void*)GetProcAddress(hShlwapi, "PathUnExpandEnvStringsA");
1693 pPathUnExpandEnvStringsW = (void*)GetProcAddress(hShlwapi, "PathUnExpandEnvStringsW");
1694 pPathIsRelativeA = (void*)GetProcAddress(hShlwapi, "PathIsRelativeA");
1695 pPathIsRelativeW = (void*)GetProcAddress(hShlwapi, "PathIsRelativeW");
1696
1697 test_PathSearchAndQualify();
1698 test_PathCreateFromUrl();
1699 test_PathIsUrl();
1700
1701 test_PathAddBackslash();
1702 test_PathMakePretty();
1703 test_PathMatchSpec();
1704
1705 test_PathIsValidCharA();
1706 test_PathIsValidCharW();
1707
1708 test_PathCombineW();
1709 test_PathCombineA();
1710 test_PathAppendA();
1711 test_PathCanonicalizeA();
1712 test_PathFindExtensionA();
1713 test_PathBuildRootA();
1714 test_PathCommonPrefixA();
1715 test_PathUnquoteSpaces();
1716 test_PathGetDriveNumber();
1717 test_PathUnExpandEnvStrings();
1718 test_PathIsRelativeA();
1719 test_PathIsRelativeW();
1720 test_PathStripPathA();
1721 }