?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 92ef5b88da02911741c0a2f56030fd2e20189321
[wine/hacks.git] / dlls / shlwapi / tests / path.c
blob7eb02b2c42fa56a4d9a6ed123efc91f2cd966dfd
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 <assert.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #include "wine/test.h"
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winreg.h"
28 #include "shlwapi.h"
29 #include "wininet.h"
30
31 static HMODULE hShlwapi;
32 static HRESULT (WINAPI *pPathIsValidCharA)(char,DWORD);
33 static HRESULT (WINAPI *pPathIsValidCharW)(WCHAR,DWORD);
34 static LPWSTR (WINAPI *pPathCombineW)(LPWSTR, LPCWSTR, LPCWSTR);
35
36 const char* TEST_URL_1 = "http://www.winehq.org/tests?date=10/10/1923";
37 const char* TEST_URL_2 = "http://localhost:8080/tests%2e.html?date=Mon%2010/10/1923";
38 const char* TEST_URL_3 = "http://foo:bar@localhost:21/internal.php?query=x&return=y";
39
40 typedef struct _TEST_URL_CANONICALIZE {
41 const char *url;
42 DWORD flags;
43 HRESULT expectret;
44 const char *expecturl;
45 } TEST_URL_CANONICALIZE;
46
47 const TEST_URL_CANONICALIZE TEST_CANONICALIZE[] = {
48 /*FIXME {"http://www.winehq.org/tests/../tests/../..", 0, S_OK, "http://www.winehq.org/"},*/
49 {"http://www.winehq.org/tests/../tests", 0, S_OK, "http://www.winehq.org/tests"},
50 {"http://www.winehq.org/tests\n", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, S_OK, "http://www.winehq.org/tests"},
51 {"http://www.winehq.org/tests\r", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, S_OK, "http://www.winehq.org/tests"},
52 {"http://www.winehq.org/tests\r", 0, S_OK, "http://www.winehq.org/tests"},
53 {"http://www.winehq.org/tests\r", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests"},
54 {"http://www.winehq.org/tests/../tests/", 0, S_OK, "http://www.winehq.org/tests/"},
55 {"http://www.winehq.org/tests/../tests/..", 0, S_OK, "http://www.winehq.org/"},
56 {"http://www.winehq.org/tests/../tests/../", 0, S_OK, "http://www.winehq.org/"},
57 {"http://www.winehq.org/tests/..", 0, S_OK, "http://www.winehq.org/"},
58 {"http://www.winehq.org/tests/../", 0, S_OK, "http://www.winehq.org/"},
59 {"http://www.winehq.org/tests/..?query=x&return=y", 0, S_OK, "http://www.winehq.org/?query=x&return=y"},
60 {"http://www.winehq.org/tests/../?query=x&return=y", 0, S_OK, "http://www.winehq.org/?query=x&return=y"},
61 {"http://www.winehq.org/tests/..#example", 0, S_OK, "http://www.winehq.org/#example"},
62 {"http://www.winehq.org/tests/../#example", 0, S_OK, "http://www.winehq.org/#example"},
63 {"http://www.winehq.org/tests\\../#example", 0, S_OK, "http://www.winehq.org/#example"},
64 {"http://www.winehq.org/tests/..\\#example", 0, S_OK, "http://www.winehq.org/#example"},
65 {"http://www.winehq.org\\tests/../#example", 0, S_OK, "http://www.winehq.org/#example"},
66 {"http://www.winehq.org/tests/../#example", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests/../#example"},
67 {"http://www.winehq.org/tests/foo bar", URL_ESCAPE_SPACES_ONLY| URL_DONT_ESCAPE_EXTRA_INFO , S_OK, "http://www.winehq.org/tests/foo%20bar"},
68 {"http://www.winehq.org/tests/foo%20bar", URL_UNESCAPE , S_OK, "http://www.winehq.org/tests/foo bar"},
69 {"file:///c:/tests/foo%20bar", URL_UNESCAPE , S_OK, "file:///c:/tests/foo bar"},
70 {"file:///c:/tests\\foo%20bar", URL_UNESCAPE , S_OK, "file:///c:/tests/foo bar"},
71 {"file:///c:/tests/foo%20bar", 0, S_OK, "file:///c:/tests/foo%20bar"},
72 {"file:///c:/tests/foo%20bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\tests\\foo bar"},
73 {"file://c:/tests/../tests/foo%20bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\tests\\foo bar"},
74 {"file://c:/tests\\../tests/foo%20bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\tests\\foo bar"},
75 {"file://c:/tests/foo%20bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\tests\\foo bar"},
76 {"file:///c://tests/foo%20bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\\\tests\\foo bar"},
77 {"file:///c:\\tests\\foo bar", 0, S_OK, "file:///c:/tests/foo bar"},
78 {"file:///c:\\tests\\foo bar", URL_DONT_SIMPLIFY, S_OK, "file:///c:/tests/foo bar"},
79 {"http://www.winehq.org/site/about", URL_FILE_USE_PATHURL, S_OK, "http://www.winehq.org/site/about"},
80 {"file_://www.winehq.org/site/about", URL_FILE_USE_PATHURL, S_OK, "file_://www.winehq.org/site/about"},
81 {"c:\\dir\\file", 0, S_OK, "file:///c:/dir/file"},
82 {"file:///c:\\dir\\file", 0, S_OK, "file:///c:/dir/file"},
83 {"c:dir\\file", 0, S_OK, "file:///c:dir/file"},
84 {"c:\\tests\\foo bar", URL_FILE_USE_PATHURL, S_OK, "file://c:\\tests\\foo bar"},
85 {"c:\\tests\\foo bar", 0, S_OK, "file:///c:/tests/foo%20bar"},
86 {"A", 0, S_OK, "A"},
87 {"", 0, S_OK, ""}
88 };
89
90 typedef struct _TEST_URL_ESCAPE {
91 const char *url;
92 DWORD flags;
93 DWORD expectescaped;
94 HRESULT expectret;
95 const char *expecturl;
96 } TEST_URL_ESCAPE;
97
98 const TEST_URL_ESCAPE TEST_ESCAPE[] = {
99 {"http://www.winehq.org/tests0", 0, 0, S_OK, "http://www.winehq.org/tests0"},
100 {"http://www.winehq.org/tests1\n", 0, 0, S_OK, "http://www.winehq.org/tests1%0A"},
101 {"http://www.winehq.org/tests2\r", 0, 0, S_OK, "http://www.winehq.org/tests2%0D"},
102 {"http://www.winehq.org/tests3\r", URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, 0, S_OK, "http://www.winehq.org/tests3\r"},
103 {"http://www.winehq.org/tests4\r", URL_ESCAPE_SPACES_ONLY, 0, S_OK, "http://www.winehq.org/tests4\r"},
104 {"http://www.winehq.org/tests5\r", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY, 0, S_OK, "http://www.winehq.org/tests5\r"},
105 {"/direct/swhelp/series6/6.2i_latestservicepack.dat\r", URL_ESCAPE_SPACES_ONLY, 0, S_OK, "/direct/swhelp/series6/6.2i_latestservicepack.dat\r"},
106
107 {"file://////foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
108 {"file://///foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
109 {"file:////foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
110 {"file:///localhost/foo/bar\\baz", 0, 0, S_OK, "file:///localhost/foo/bar/baz"},
111 {"file:///foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
112 {"file://loCalHost/foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
113 {"file://foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
114 {"file:/localhost/foo/bar\\baz", 0, 0, S_OK, "file:///localhost/foo/bar/baz"},
115 {"file:/foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
116 {"file:foo/bar\\baz", 0, 0, S_OK, "file:foo/bar/baz"},
117 {"file:\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
118 {"file:\\\\foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
119 {"file:\\\\\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
120 {"file:\\\\localhost\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
121 {"file:///f oo/b?a r\\baz", 0, 0, S_OK, "file:///f%20oo/b?a r\\baz"},
122 {"file:///foo/b#a r\\baz", 0, 0, S_OK, "file:///foo/b%23a%20r/baz"},
123 {"file:///f o^&`{}|][\"<>\\%o/b#a r\\baz", 0, 0, S_OK, "file:///f%20o%5E%26%60%7B%7D%7C%5D%5B%22%3C%3E/%o/b%23a%20r/baz"},
124 {"file:///f o%o/b?a r\\b%az", URL_ESCAPE_PERCENT, 0, S_OK, "file:///f%20o%25o/b?a r\\b%az"},
125 {"file:/foo/bar\\baz", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "file:%2Ffoo%2Fbar%5Cbaz"},
126
127 {"foo/b%ar\\ba?z\\", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "foo%2Fb%ar%5Cba%3Fz%5C"},
128 {"foo/b%ar\\ba?z\\", URL_ESCAPE_PERCENT | URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "foo%2Fb%25ar%5Cba%3Fz%5C"},
129 {"foo/bar\\ba?z\\", 0, 0, S_OK, "foo/bar%5Cba?z\\"},
130 {"/foo/bar\\ba?z\\", 0, 0, S_OK, "/foo/bar%5Cba?z\\"},
131 {"/foo/bar\\ba#z\\", 0, 0, S_OK, "/foo/bar%5Cba#z\\"},
132 {"/foo/%5C", 0, 0, S_OK, "/foo/%5C"},
133 {"/foo/%5C", URL_ESCAPE_PERCENT, 0, S_OK, "/foo/%255C"},
134
135 {"http://////foo/bar\\baz", 0, 0, S_OK, "http://////foo/bar/baz"},
136 {"http://///foo/bar\\baz", 0, 0, S_OK, "http://///foo/bar/baz"},
137 {"http:////foo/bar\\baz", 0, 0, S_OK, "http:////foo/bar/baz"},
138 {"http:///foo/bar\\baz", 0, 0, S_OK, "http:///foo/bar/baz"},
139 {"http://localhost/foo/bar\\baz", 0, 0, S_OK, "http://localhost/foo/bar/baz"},
140 {"http://foo/bar\\baz", 0, 0, S_OK, "http://foo/bar/baz"},
141 {"http:/foo/bar\\baz", 0, 0, S_OK, "http:/foo/bar/baz"},
142 {"http:foo/bar\\ba?z\\", 0, 0, S_OK, "http:foo%2Fbar%2Fba?z\\"},
143 {"http:foo/bar\\ba#z\\", 0, 0, S_OK, "http:foo%2Fbar%2Fba#z\\"},
144 {"http:\\foo/bar\\baz", 0, 0, S_OK, "http:/foo/bar/baz"},
145 {"http:\\\\foo/bar\\baz", 0, 0, S_OK, "http://foo/bar/baz"},
146 {"http:\\\\\\foo/bar\\baz", 0, 0, S_OK, "http:///foo/bar/baz"},
147 {"http:\\\\\\\\foo/bar\\baz", 0, 0, S_OK, "http:////foo/bar/baz"},
148 {"http:/fo ?o/b ar\\baz", 0, 0, S_OK, "http:/fo%20?o/b ar\\baz"},
149 {"http:fo ?o/b ar\\baz", 0, 0, S_OK, "http:fo%20?o/b ar\\baz"},
150 {"http:/foo/bar\\baz", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "http:%2Ffoo%2Fbar%5Cbaz"},
151
152 {"https://foo/bar\\baz", 0, 0, S_OK, "https://foo/bar/baz"},
153 {"https:/foo/bar\\baz", 0, 0, S_OK, "https:/foo/bar/baz"},
154 {"https:\\foo/bar\\baz", 0, 0, S_OK, "https:/foo/bar/baz"},
155
156 {"foo:////foo/bar\\baz", 0, 0, S_OK, "foo:////foo/bar%5Cbaz"},
157 {"foo:///foo/bar\\baz", 0, 0, S_OK, "foo:///foo/bar%5Cbaz"},
158 {"foo://localhost/foo/bar\\baz", 0, 0, S_OK, "foo://localhost/foo/bar%5Cbaz"},
159 {"foo://foo/bar\\baz", 0, 0, S_OK, "foo://foo/bar%5Cbaz"},
160 {"foo:/foo/bar\\baz", 0, 0, S_OK, "foo:/foo/bar%5Cbaz"},
161 {"foo:foo/bar\\baz", 0, 0, S_OK, "foo:foo%2Fbar%5Cbaz"},
162 {"foo:\\foo/bar\\baz", 0, 0, S_OK, "foo:%5Cfoo%2Fbar%5Cbaz"},
163 {"foo:/foo/bar\\ba?\\z", 0, 0, S_OK, "foo:/foo/bar%5Cba?\\z"},
164 {"foo:/foo/bar\\ba#\\z", 0, 0, S_OK, "foo:/foo/bar%5Cba#\\z"},
165
166 {"mailto:/fo/o@b\\%a?\\r.b#\\az", 0, 0, S_OK, "mailto:%2Ffo%2Fo@b%5C%a%3F%5Cr.b%23%5Caz"},
167 {"mailto:fo/o@b\\%a?\\r.b#\\az", 0, 0, S_OK, "mailto:fo%2Fo@b%5C%a%3F%5Cr.b%23%5Caz"},
168 {"mailto:fo/o@b\\%a?\\r.b#\\az", URL_ESCAPE_PERCENT, 0, S_OK, "mailto:fo%2Fo@b%5C%25a%3F%5Cr.b%23%5Caz"},
169
170 {"ftp:fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:fo%2Fo@bar.baz%2Ffoo%2Fbar"},
171 {"ftp:/fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:/fo/o@bar.baz/foo/bar"},
172 {"ftp://fo/o@bar.baz/fo?o\\bar", 0, 0, S_OK, "ftp://fo/o@bar.baz/fo?o\\bar"},
173 {"ftp://fo/o@bar.baz/fo#o\\bar", 0, 0, S_OK, "ftp://fo/o@bar.baz/fo#o\\bar"},
174 {"ftp://localhost/o@bar.baz/fo#o\\bar", 0, 0, S_OK, "ftp://localhost/o@bar.baz/fo#o\\bar"},
175 {"ftp:///fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:///fo/o@bar.baz/foo/bar"},
176 {"ftp:////fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:////fo/o@bar.baz/foo/bar"}
177 };
178
179 typedef struct _TEST_URL_COMBINE {
180 const char *url1;
181 const char *url2;
182 DWORD flags;
183 HRESULT expectret;
184 const char *expecturl;
185 } TEST_URL_COMBINE;
186
187 const TEST_URL_COMBINE TEST_COMBINE[] = {
188 {"http://www.winehq.org/tests", "tests1", 0, S_OK, "http://www.winehq.org/tests1"},
189 {"http://www.%77inehq.org/tests", "tests1", 0, S_OK, "http://www.%77inehq.org/tests1"},
190 /*FIXME {"http://www.winehq.org/tests", "../tests2", 0, S_OK, "http://www.winehq.org/tests2"},*/
191 {"http://www.winehq.org/tests/", "../tests3", 0, S_OK, "http://www.winehq.org/tests3"},
192 {"http://www.winehq.org/tests/test1", "test2", 0, S_OK, "http://www.winehq.org/tests/test2"},
193 {"http://www.winehq.org/tests/../tests", "tests4", 0, S_OK, "http://www.winehq.org/tests4"},
194 {"http://www.winehq.org/tests/../tests/", "tests5", 0, S_OK, "http://www.winehq.org/tests/tests5"},
195 {"http://www.winehq.org/tests/../tests/", "/tests6/..", 0, S_OK, "http://www.winehq.org/"},
196 {"http://www.winehq.org/tests/../tests/..", "tests7/..", 0, S_OK, "http://www.winehq.org/"},
197 {"http://www.winehq.org/tests/?query=x&return=y", "tests8", 0, S_OK, "http://www.winehq.org/tests/tests8"},
198 {"http://www.winehq.org/tests/#example", "tests9", 0, S_OK, "http://www.winehq.org/tests/tests9"},
199 {"http://www.winehq.org/tests/../tests/", "/tests10/..", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests10/.."},
200 {"http://www.winehq.org/tests/../", "tests11", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests/../tests11"},
201 {"file:///C:\\dir\\file.txt", "test.txt", 0, S_OK, "file:///C:/dir/test.txt"},
202 {"http://www.winehq.org/test/", "test%20file.txt", 0, S_OK, "http://www.winehq.org/test/test%20file.txt"},
203 {"http://www.winehq.org/test/", "test%20file.txt", URL_FILE_USE_PATHURL, S_OK, "http://www.winehq.org/test/test%20file.txt"},
204 {"http://www.winehq.org%2ftest/", "test%20file.txt", URL_FILE_USE_PATHURL, S_OK, "http://www.winehq.org%2ftest/test%20file.txt"},
205 {"xxx:@MSITStore:file.chm/file.html", "dir/file", 0, S_OK, "xxx:dir/file"},
206 {"mk:@MSITStore:file.chm::/file.html", "/dir/file", 0, S_OK, "mk:@MSITStore:file.chm::/dir/file"},
207 {"mk:@MSITStore:file.chm::/file.html", "mk:@MSITStore:file.chm::/dir/file", 0, S_OK, "mk:@MSITStore:file.chm::/dir/file"},
208 {"foo:today", "foo:calendar", 0, S_OK, "foo:calendar"},
209 {"foo:today", "bar:calendar", 0, S_OK, "bar:calendar"},
210 {"foo:/today", "foo:calendar", 0, S_OK, "foo:/calendar"},
211 {"foo:/today/", "foo:calendar", 0, S_OK, "foo:/today/calendar"},
212 };
213
214 struct {
215 const char *path;
216 const char *url;
217 DWORD ret;
218 } TEST_URLFROMPATH [] = {
219 {"foo", "file:foo", S_OK},
220 {"foo\\bar", "file:foo/bar", S_OK},
221 {"\\foo\\bar", "file:///foo/bar", S_OK},
222 {"c:\\foo\\bar", "file:///c:/foo/bar", S_OK},
223 {"c:foo\\bar", "file:///c:foo/bar", S_OK},
224 {"c:\\foo/b a%r", "file:///c:/foo/b%20a%25r", S_OK},
225 {"c:\\foo\\foo bar", "file:///c:/foo/foo%20bar", S_OK},
226 #if 0
227 /* The following test fails on native shlwapi as distributed with Win95/98.
228 * Wine matches the behaviour of later versions.
229 */
230 {"xx:c:\\foo\\bar", "xx:c:\\foo\\bar", S_FALSE}
231 #endif
232 };
233
234 struct {
235 const char *url;
236 const char *path;
237 DWORD ret;
238 } TEST_PATHFROMURL[] = {
239 {"file:///c:/foo/ba%5Cr", "c:\\foo\\ba\\r", S_OK},
240 {"file:///c:/foo/../ba%5Cr", "c:\\foo\\..\\ba\\r", S_OK},
241 {"file:///host/c:/foo/bar", "\\host\\c:\\foo\\bar", S_OK},
242 {"file://host/c:/foo/bar", "\\\\hostc:\\foo\\bar", S_OK},
243 {"file://host/c:/foo/bar", "\\\\hostc:\\foo\\bar", S_OK},
244 {"file:\\\\host\\c:\\foo\\bar", "\\\\hostc:\\foo\\bar", S_OK},
245 {"file:\\\\host\\ca\\foo\\bar", "\\\\host\\ca\\foo\\bar", S_OK},
246 {"file:\\\\host\\c|\\foo\\bar", "\\\\hostc|\\foo\\bar", S_OK},
247 {"file:\\%5Chost\\c:\\foo\\bar", "\\\\host\\c:\\foo\\bar", S_OK},
248 {"file:\\\\host\\cx:\\foo\\bar", "\\\\host\\cx:\\foo\\bar", S_OK},
249 {"file://c:/foo/bar", "c:\\foo\\bar", S_OK},
250 {"file://c:/d:/foo/bar", "c:\\d:\\foo\\bar", S_OK},
251 {"file://c|/d|/foo/bar", "c:\\d|\\foo\\bar", S_OK},
252 {"file://host/foo/bar", "\\\\host\\foo\\bar", S_OK},
253 {"file:/foo/bar", "\\foo\\bar", S_OK},
254 {"file:/foo/bar/", "\\foo\\bar\\", S_OK},
255 {"file:foo/bar", "foo\\bar", S_OK},
256 {"file:c:/foo/bar", "c:\\foo\\bar", S_OK},
257 {"file:c|/foo/bar", "c:\\foo\\bar", S_OK},
258 {"file:cx|/foo/bar", "cx|\\foo\\bar", S_OK},
259 {"file:////c:/foo/bar", "c:\\foo\\bar", S_OK},
260 /* {"file:////c:/foo/foo%20bar", "c:\\foo\\foo%20bar", S_OK},*/
261
262 {"c:\\foo\\bar", NULL, E_INVALIDARG},
263 {"foo/bar", NULL, E_INVALIDARG},
264 {"http://foo/bar", NULL, E_INVALIDARG},
265
266 };
267
268 struct {
269 char url[30];
270 const char *expect;
271 } TEST_URL_UNESCAPE[] = {
272 {"file://foo/bar", "file://foo/bar"},
273 {"file://fo%20o%5Ca/bar", "file://fo o\\a/bar"}
274 };
275
276
277 struct {
278 const char *path;
279 BOOL expect;
280 } TEST_PATH_IS_URL[] = {
281 {"http://foo/bar", TRUE},
282 {"c:\\foo\\bar", FALSE},
283 {"foo://foo/bar", TRUE},
284 {"foo\\bar", FALSE},
285 {"foo.bar", FALSE},
286 {"bogusscheme:", TRUE},
287 {"http:partial", TRUE}
288 };
289
290 struct {
291 const char *url;
292 BOOL expectOpaque;
293 BOOL expectFile;
294 } TEST_URLIS_ATTRIBS[] = {
295 { "ftp:", FALSE, FALSE },
296 { "http:", FALSE, FALSE },
297 { "gopher:", FALSE, FALSE },
298 { "mailto:", TRUE, FALSE },
299 { "news:", FALSE, FALSE },
300 { "nntp:", FALSE, FALSE },
301 { "telnet:", FALSE, FALSE },
302 { "wais:", FALSE, FALSE },
303 { "file:", FALSE, TRUE },
304 { "mk:", FALSE, FALSE },
305 { "https:", FALSE, FALSE },
306 { "shell:", TRUE, FALSE },
307 { "https:", FALSE, FALSE },
308 { "snews:", FALSE, FALSE },
309 { "local:", FALSE, FALSE },
310 { "javascript:", TRUE, FALSE },
311 { "vbscript:", TRUE, FALSE },
312 { "about:", TRUE, FALSE },
313 { "res:", FALSE, FALSE },
314 { "bogusscheme:", FALSE, FALSE },
315 { "file:\\\\e:\\b\\c", FALSE, TRUE },
316 { "file://e:/b/c", FALSE, TRUE },
317 { "http:partial", FALSE, FALSE },
318 { "mailto://www.winehq.org/test.html", TRUE, FALSE },
319 { "file:partial", FALSE, TRUE }
320 };
321
322 struct {
323 const char *path;
324 const char *result;
325 } TEST_PATH_UNQUOTE_SPACES[] = {
326 { "abcdef", "abcdef" },
327 { "\"abcdef\"", "abcdef" },
328 { "\"abcdef", "\"abcdef" },
329 { "abcdef\"", "abcdef\"" },
330 { "\"\"abcdef\"\"", "\"abcdef\"" },
331 { "abc\"def", "abc\"def" },
332 { "\"abc\"def", "\"abc\"def" },
333 { "\"abc\"def\"", "abc\"def" },
334 { "\'abcdef\'", "\'abcdef\'" },
335 { "\"\"", "" },
336 { "\"", "" }
337 };
338
339 static LPWSTR GetWideString(const char* szString)
340 {
341 LPWSTR wszString = HeapAlloc(GetProcessHeap(), 0, (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
342
343 MultiByteToWideChar(0, 0, szString, -1, wszString, INTERNET_MAX_URL_LENGTH);
344
345 return wszString;
346 }
347
348 static void FreeWideString(LPWSTR wszString)
349 {
350 HeapFree(GetProcessHeap(), 0, wszString);
351 }
352
353 static LPSTR strdupA(LPCSTR p)
354 {
355 LPSTR ret;
356 DWORD len = (strlen(p) + 1);
357 ret = HeapAlloc(GetProcessHeap(), 0, len);
358 memcpy(ret, p, len);
359 return ret;
360 }
361
362 static void hash_url(const char* szUrl)
363 {
364 LPCSTR szTestUrl = szUrl;
365 LPWSTR wszTestUrl = GetWideString(szTestUrl);
366
367 DWORD cbSize = sizeof(DWORD);
368 DWORD dwHash1, dwHash2;
369 ok(UrlHashA(szTestUrl, (LPBYTE)&dwHash1, cbSize) == S_OK, "UrlHashA didn't return S_OK\n");
370 ok(UrlHashW(wszTestUrl, (LPBYTE)&dwHash2, cbSize) == S_OK, "UrlHashW didn't return S_OK\n");
371
372 FreeWideString(wszTestUrl);
373
374 ok(dwHash1 == dwHash2, "Hashes didn't compare\n");
375 }
376
377 static void test_UrlHash(void)
378 {
379 hash_url(TEST_URL_1);
380 hash_url(TEST_URL_2);
381 hash_url(TEST_URL_3);
382 }
383
384 static void test_url_part(const char* szUrl, DWORD dwPart, DWORD dwFlags, const char* szExpected)
385 {
386 CHAR szPart[INTERNET_MAX_URL_LENGTH];
387 WCHAR wszPart[INTERNET_MAX_URL_LENGTH];
388 LPWSTR wszUrl = GetWideString(szUrl);
389 LPWSTR wszConvertedPart;
390
391 DWORD dwSize;
392
393 dwSize = INTERNET_MAX_URL_LENGTH;
394 ok( UrlGetPartA(szUrl, szPart, &dwSize, dwPart, dwFlags) == S_OK, "UrlGetPartA for \"%s\" part 0x%08x didn't return S_OK but \"%s\"\n", szUrl, dwPart, szPart);
395 dwSize = INTERNET_MAX_URL_LENGTH;
396 ok( UrlGetPartW(wszUrl, wszPart, &dwSize, dwPart, dwFlags) == S_OK, "UrlGetPartW didn't return S_OK\n" );
397
398 wszConvertedPart = GetWideString(szPart);
399
400 ok(lstrcmpW(wszPart,wszConvertedPart)==0, "Strings didn't match between ascii and unicode UrlGetPart!\n");
401
402 FreeWideString(wszUrl);
403 FreeWideString(wszConvertedPart);
404
405 /* Note that v6.0 and later don't return '?' with the query */
406 ok(strcmp(szPart,szExpected)==0 ||
407 (*szExpected=='?' && !strcmp(szPart,szExpected+1)),
408 "Expected %s, but got %s\n", szExpected, szPart);
409 }
410
411 static void test_UrlGetPart(void)
412 {
413 CHAR szPart[INTERNET_MAX_URL_LENGTH];
414 DWORD dwSize;
415 HRESULT res;
416
417 dwSize = sizeof szPart;
418 szPart[0]='x'; szPart[1]=0;
419 res = UrlGetPartA("hi", szPart, &dwSize, URL_PART_SCHEME, 0);
420 todo_wine {
421 ok (res==S_FALSE, "UrlGetPartA(\"hi\") returned %08X\n", res);
422 ok(szPart[0]==0, "UrlGetPartA(\"hi\") return \"%s\" instead of \"\"\n", szPart);
423 }
424 dwSize = sizeof szPart;
425 szPart[0]='x'; szPart[1]=0;
426 res = UrlGetPartA("hi", szPart, &dwSize, URL_PART_QUERY, 0);
427 todo_wine {
428 ok (res==S_FALSE, "UrlGetPartA(\"hi\") returned %08X\n", res);
429 ok(szPart[0]==0, "UrlGetPartA(\"hi\") return \"%s\" instead of \"\"\n", szPart);
430 }
431
432 test_url_part(TEST_URL_3, URL_PART_HOSTNAME, 0, "localhost");
433 test_url_part(TEST_URL_3, URL_PART_PORT, 0, "21");
434 test_url_part(TEST_URL_3, URL_PART_USERNAME, 0, "foo");
435 test_url_part(TEST_URL_3, URL_PART_PASSWORD, 0, "bar");
436 test_url_part(TEST_URL_3, URL_PART_SCHEME, 0, "http");
437 test_url_part(TEST_URL_3, URL_PART_QUERY, 0, "?query=x&return=y");
438 }
439
440 static void test_url_escape(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
441 {
442 CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
443 DWORD dwEscaped;
444 WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
445 WCHAR *urlW, *expected_urlW;
446 dwEscaped=INTERNET_MAX_URL_LENGTH;
447
448 ok(UrlEscapeA(szUrl, szReturnUrl, &dwEscaped, dwFlags) == dwExpectReturn, "UrlEscapeA didn't return 0x%08x from \"%s\"\n", dwExpectReturn, szUrl);
449 ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected \"%s\", but got \"%s\" from \"%s\"\n", szExpectUrl, szReturnUrl, szUrl);
450
451 dwEscaped = INTERNET_MAX_URL_LENGTH;
452 urlW = GetWideString(szUrl);
453 expected_urlW = GetWideString(szExpectUrl);
454 ok(UrlEscapeW(urlW, ret_urlW, &dwEscaped, dwFlags) == dwExpectReturn, "UrlEscapeW didn't return 0x%08x from \"%s\"\n", dwExpectReturn, szUrl);
455 WideCharToMultiByte(CP_ACP,0,ret_urlW,-1,szReturnUrl,INTERNET_MAX_URL_LENGTH,0,0);
456 ok(lstrcmpW(ret_urlW, expected_urlW)==0, "Expected \"%s\", but got \"%s\" from \"%s\" flags %08x\n", szExpectUrl, szReturnUrl, szUrl, dwFlags);
457 FreeWideString(urlW);
458 FreeWideString(expected_urlW);
459
460 }
461
462 static void test_url_canonicalize(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
463 {
464 CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
465 WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
466 LPWSTR wszUrl = GetWideString(szUrl);
467 LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
468 LPWSTR wszConvertedUrl;
469
470 DWORD dwSize;
471
472 dwSize = INTERNET_MAX_URL_LENGTH;
473 ok(UrlCanonicalizeA(szUrl, NULL, &dwSize, dwFlags) != dwExpectReturn, "Unexpected return for NULL buffer\n");
474 ok(UrlCanonicalizeA(szUrl, szReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeA didn't return 0x%08x\n", dwExpectReturn);
475 ok(strcmp(szReturnUrl,szExpectUrl)==0, "UrlCanonicalizeA dwFlags 0x%08x Expected \"%s\", but got \"%s\"\n", dwFlags, szExpectUrl, szReturnUrl);
476
477 dwSize = INTERNET_MAX_URL_LENGTH;
478 ok(UrlCanonicalizeW(wszUrl, NULL, &dwSize, dwFlags) != dwExpectReturn, "Unexpected return for NULL buffer\n");
479 ok(UrlCanonicalizeW(wszUrl, wszReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeW didn't return 0x%08x\n", dwExpectReturn);
480 wszConvertedUrl = GetWideString(szReturnUrl);
481 ok(lstrcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCanonicalize!\n");
482 FreeWideString(wszConvertedUrl);
483
484
485 FreeWideString(wszUrl);
486 FreeWideString(wszExpectUrl);
487 }
488
489
490 static void test_UrlEscape(void)
491 {
492 DWORD size;
493 HRESULT ret;
494 unsigned int i;
495
496 ret = UrlEscapeA("/woningplan/woonkamer basis.swf", NULL, &size, URL_ESCAPE_SPACES_ONLY);
497 ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG);
498
499 for(i=0; i<sizeof(TEST_ESCAPE)/sizeof(TEST_ESCAPE[0]); i++) {
500 test_url_escape(TEST_ESCAPE[i].url, TEST_ESCAPE[i].flags,
501 TEST_ESCAPE[i].expectret, TEST_ESCAPE[i].expecturl);
502 }
503 }
504
505 static void test_UrlCanonicalize(void)
506 {
507 unsigned int i;
508 CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
509 DWORD dwSize;
510 HRESULT hr;
511
512 for(i=0; i<sizeof(TEST_CANONICALIZE)/sizeof(TEST_CANONICALIZE[0]); i++) {
513 test_url_canonicalize(TEST_CANONICALIZE[i].url, TEST_CANONICALIZE[i].flags,
514 TEST_CANONICALIZE[i].expectret, TEST_CANONICALIZE[i].expecturl);
515 }
516
517 /* move to TEST_CANONICALIZE when fixed */
518 dwSize = sizeof szReturnUrl;
519 /*LimeWire online installer calls this*/
520 hr = UrlCanonicalizeA("/uri-res/N2R?urn:sha1:B3K", szReturnUrl, &dwSize,URL_DONT_ESCAPE_EXTRA_INFO | URL_WININET_COMPATIBILITY /*0x82000000*/);
521 ok(hr==S_OK,"UrlCanonicalizeA returned 0x%08x instead of S_OK\n", hr);
522 todo_wine {
523 ok(strcmp(szReturnUrl,"/uri-res/N2R?urn:sha1:B3K")==0, "UrlCanonicalizeA got \"%s\" instead of \"/uri-res/N2R?urn:sha1:B3K\"\n", szReturnUrl);
524 }
525 }
526
527 static void test_url_combine(const char *szUrl1, const char *szUrl2, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
528 {
529 HRESULT hr;
530 CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
531 WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
532 LPWSTR wszUrl1 = GetWideString(szUrl1);
533 LPWSTR wszUrl2 = GetWideString(szUrl2);
534 LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
535 LPWSTR wszConvertedUrl;
536
537 DWORD dwSize;
538 DWORD dwExpectLen = lstrlen(szExpectUrl);
539
540 hr = UrlCombineA(szUrl1, szUrl2, NULL, NULL, dwFlags);
541 ok(hr == E_INVALIDARG, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, E_INVALIDARG);
542
543 dwSize = 0;
544 hr = UrlCombineA(szUrl1, szUrl2, NULL, &dwSize, dwFlags);
545 ok(hr == E_POINTER, "Checking length of string, return was 0x%08x, expected 0x%08x\n", hr, E_POINTER);
546 ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1);
547
548 dwSize--;
549 hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
550 ok(hr == E_POINTER, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, E_POINTER);
551 ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1);
552
553 hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
554 ok(hr == dwExpectReturn, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, dwExpectReturn);
555 ok(dwSize == dwExpectLen, "Got length %d, expected %d\n", dwSize, dwExpectLen);
556 if(SUCCEEDED(hr)) {
557 ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected %s, but got %s\n", szExpectUrl, szReturnUrl);
558 }
559
560 dwSize = 0;
561 hr = UrlCombineW(wszUrl1, wszUrl2, NULL, &dwSize, dwFlags);
562 ok(hr == E_POINTER, "Checking length of string, return was 0x%08x, expected 0x%08x\n", hr, E_POINTER);
563 ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1);
564
565 dwSize--;
566 hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
567 ok(hr == E_POINTER, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, E_POINTER);
568 ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1);
569
570 hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
571 ok(hr == dwExpectReturn, "UrlCombineW returned 0x%08x, expected 0x%08x\n", hr, dwExpectReturn);
572 ok(dwSize == dwExpectLen, "Got length %d, expected %d\n", dwSize, dwExpectLen);
573 if(SUCCEEDED(hr)) {
574 wszConvertedUrl = GetWideString(szReturnUrl);
575 ok(lstrcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCombine!\n");
576 FreeWideString(wszConvertedUrl);
577 }
578
579 FreeWideString(wszUrl1);
580 FreeWideString(wszUrl2);
581 FreeWideString(wszExpectUrl);
582 }
583
584 static void test_UrlCombine(void)
585 {
586 unsigned int i;
587 for(i=0; i<sizeof(TEST_COMBINE)/sizeof(TEST_COMBINE[0]); i++) {
588 test_url_combine(TEST_COMBINE[i].url1, TEST_COMBINE[i].url2, TEST_COMBINE[i].flags,
589 TEST_COMBINE[i].expectret, TEST_COMBINE[i].expecturl);
590 }
591 }
592
593 static void test_UrlCreateFromPath(void)
594 {
595 size_t i;
596 char ret_url[INTERNET_MAX_URL_LENGTH];
597 DWORD len, ret;
598 WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
599 WCHAR *pathW, *urlW;
600
601 for(i = 0; i < sizeof(TEST_URLFROMPATH) / sizeof(TEST_URLFROMPATH[0]); i++) {
602 len = INTERNET_MAX_URL_LENGTH;
603 ret = UrlCreateFromPathA(TEST_URLFROMPATH[i].path, ret_url, &len, 0);
604 ok(ret == TEST_URLFROMPATH[i].ret, "ret %08x from path %s\n", ret, TEST_URLFROMPATH[i].path);
605 ok(!lstrcmpi(ret_url, TEST_URLFROMPATH[i].url), "url %s from path %s\n", ret_url, TEST_URLFROMPATH[i].path);
606 ok(len == strlen(ret_url), "ret len %d from path %s\n", len, TEST_URLFROMPATH[i].path);
607
608 len = INTERNET_MAX_URL_LENGTH;
609 pathW = GetWideString(TEST_URLFROMPATH[i].path);
610 urlW = GetWideString(TEST_URLFROMPATH[i].url);
611 ret = UrlCreateFromPathW(pathW, ret_urlW, &len, 0);
612 WideCharToMultiByte(CP_ACP, 0, ret_urlW, -1, ret_url, sizeof(ret_url),0,0);
613 ok(ret == TEST_URLFROMPATH[i].ret, "ret %08x from path L\"%s\", expected %08x\n",
614 ret, TEST_URLFROMPATH[i].path, TEST_URLFROMPATH[i].ret);
615 ok(!lstrcmpiW(ret_urlW, urlW), "got %s expected %s from path L\"%s\"\n", ret_url, TEST_URLFROMPATH[i].url, TEST_URLFROMPATH[i].path);
616 ok(len == lstrlenW(ret_urlW), "ret len %d from path L\"%s\"\n", len, TEST_URLFROMPATH[i].path);
617 FreeWideString(urlW);
618 FreeWideString(pathW);
619 }
620 }
621
622 static void test_UrlIs(void)
623 {
624 BOOL ret;
625 size_t i;
626 WCHAR wurl[80];
627
628 for(i = 0; i < sizeof(TEST_PATH_IS_URL) / sizeof(TEST_PATH_IS_URL[0]); i++) {
629 MultiByteToWideChar(CP_ACP, 0, TEST_PATH_IS_URL[i].path, -1, wurl, 80);
630
631 ret = UrlIsA( TEST_PATH_IS_URL[i].path, URLIS_URL );
632 ok( ret == TEST_PATH_IS_URL[i].expect,
633 "returned %d from path %s, expected %d\n", ret, TEST_PATH_IS_URL[i].path,
634 TEST_PATH_IS_URL[i].expect );
635
636 ret = UrlIsW( wurl, URLIS_URL );
637 ok( ret == TEST_PATH_IS_URL[i].expect,
638 "returned %d from path (UrlIsW) %s, expected %d\n", ret, TEST_PATH_IS_URL[i].path,
639 TEST_PATH_IS_URL[i].expect );
640 }
641 for(i = 0; i < sizeof(TEST_URLIS_ATTRIBS) / sizeof(TEST_URLIS_ATTRIBS[0]); i++) {
642 MultiByteToWideChar(CP_ACP, 0, TEST_URLIS_ATTRIBS[i].url, -1, wurl, 80);
643
644 ret = UrlIsA( TEST_URLIS_ATTRIBS[i].url, URLIS_OPAQUE);
645 ok( ret == TEST_URLIS_ATTRIBS[i].expectOpaque,
646 "returned %d for URLIS_OPAQUE, url \"%s\", expected %d\n", ret, TEST_URLIS_ATTRIBS[i].url,
647 TEST_URLIS_ATTRIBS[i].expectOpaque );
648 ret = UrlIsA( TEST_URLIS_ATTRIBS[i].url, URLIS_FILEURL);
649 ok( ret == TEST_URLIS_ATTRIBS[i].expectFile,
650 "returned %d for URLIS_FILEURL, url \"%s\", expected %d\n", ret, TEST_URLIS_ATTRIBS[i].url,
651 TEST_URLIS_ATTRIBS[i].expectFile );
652
653 ret = UrlIsW( wurl, URLIS_OPAQUE);
654 ok( ret == TEST_URLIS_ATTRIBS[i].expectOpaque,
655 "returned %d for URLIS_OPAQUE (UrlIsW), url \"%s\", expected %d\n", ret, TEST_URLIS_ATTRIBS[i].url,
656 TEST_URLIS_ATTRIBS[i].expectOpaque );
657 ret = UrlIsW( wurl, URLIS_FILEURL);
658 ok( ret == TEST_URLIS_ATTRIBS[i].expectFile,
659 "returned %d for URLIS_FILEURL (UrlIsW), url \"%s\", expected %d\n", ret, TEST_URLIS_ATTRIBS[i].url,
660 TEST_URLIS_ATTRIBS[i].expectFile );
661 }
662 }
663
664 static void test_UrlUnescape(void)
665 {
666 CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
667 WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
668 WCHAR *urlW, *expected_urlW;
669 DWORD dwEscaped;
670 size_t i;
671 static char inplace[] = "file:///C:/Program%20Files";
672 static WCHAR inplaceW[] = {'f','i','l','e',':','/','/','/','C',':','/',
673 'P','r','o','g','r','a','m','%','2','0','F','i','l','e','s',0};
674
675 for(i=0; i<sizeof(TEST_URL_UNESCAPE)/sizeof(TEST_URL_UNESCAPE[0]); i++) {
676 dwEscaped=INTERNET_MAX_URL_LENGTH;
677 ok(UrlUnescapeA(TEST_URL_UNESCAPE[i].url, szReturnUrl, &dwEscaped, 0) == S_OK, "UrlUnescapeA didn't return 0x%08x from \"%s\"\n", S_OK, TEST_URL_UNESCAPE[i].url);
678 ok(strcmp(szReturnUrl,TEST_URL_UNESCAPE[i].expect)==0, "Expected \"%s\", but got \"%s\" from \"%s\"\n", TEST_URL_UNESCAPE[i].expect, szReturnUrl, TEST_URL_UNESCAPE[i].url);
679
680 dwEscaped = INTERNET_MAX_URL_LENGTH;
681 urlW = GetWideString(TEST_URL_UNESCAPE[i].url);
682 expected_urlW = GetWideString(TEST_URL_UNESCAPE[i].expect);
683 ok(UrlUnescapeW(urlW, ret_urlW, &dwEscaped, 0) == S_OK, "UrlUnescapeW didn't return 0x%08x from \"%s\"\n", S_OK, TEST_URL_UNESCAPE[i].url);
684 WideCharToMultiByte(CP_ACP,0,ret_urlW,-1,szReturnUrl,INTERNET_MAX_URL_LENGTH,0,0);
685 ok(lstrcmpW(ret_urlW, expected_urlW)==0, "Expected \"%s\", but got \"%s\" from \"%s\" flags %08lx\n", TEST_URL_UNESCAPE[i].expect, szReturnUrl, TEST_URL_UNESCAPE[i].url, 0L);
686 FreeWideString(urlW);
687 FreeWideString(expected_urlW);
688 }
689
690 dwEscaped = sizeof(inplace);
691 ok(UrlUnescapeA(inplace, NULL, &dwEscaped, URL_UNESCAPE_INPLACE) == S_OK, "UrlUnescapeA failed unexpectedly\n");
692
693 dwEscaped = sizeof(inplaceW);
694 ok(UrlUnescapeW(inplaceW, NULL, &dwEscaped, URL_UNESCAPE_INPLACE) == S_OK, "UrlUnescapeW failed unexpectedly\n");
695 }
696
697 static void test_PathSearchAndQualify(void)
698 {
699 WCHAR path1[] = {'c',':','\\','f','o','o',0};
700 WCHAR expect1[] = {'c',':','\\','f','o','o',0};
701 WCHAR path2[] = {'c',':','f','o','o',0};
702 WCHAR c_drive[] = {'c',':',0};
703 WCHAR foo[] = {'f','o','o',0};
704 WCHAR path3[] = {'\\','f','o','o',0};
705 WCHAR winini[] = {'w','i','n','.','i','n','i',0};
706 WCHAR out[MAX_PATH];
707 WCHAR cur_dir[MAX_PATH];
708 WCHAR dot[] = {'.',0};
709
710 /* c:\foo */
711 ok(PathSearchAndQualifyW(path1, out, MAX_PATH) != 0,
712 "PathSearchAndQualify rets 0\n");
713 ok(!lstrcmpiW(out, expect1), "strings don't match\n");
714
715 /* c:foo */
716 ok(PathSearchAndQualifyW(path2, out, MAX_PATH) != 0,
717 "PathSearchAndQualify rets 0\n");
718 GetFullPathNameW(c_drive, MAX_PATH, cur_dir, NULL);
719 PathAddBackslashW(cur_dir);
720 lstrcatW(cur_dir, foo);
721 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
722
723 /* foo */
724 ok(PathSearchAndQualifyW(foo, out, MAX_PATH) != 0,
725 "PathSearchAndQualify rets 0\n");
726 GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
727 PathAddBackslashW(cur_dir);
728 lstrcatW(cur_dir, foo);
729 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
730
731 /* \foo */
732 ok(PathSearchAndQualifyW(path3, out, MAX_PATH) != 0,
733 "PathSearchAndQualify rets 0\n");
734 GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
735 lstrcpyW(cur_dir + 2, path3);
736 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
737
738 /* win.ini */
739 ok(PathSearchAndQualifyW(winini, out, MAX_PATH) != 0,
740 "PathSearchAndQualify rets 0\n");
741 if(!SearchPathW(NULL, winini, NULL, MAX_PATH, cur_dir, NULL))
742 GetFullPathNameW(winini, MAX_PATH, cur_dir, NULL);
743 ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
744
745 }
746
747 static void test_PathCreateFromUrl(void)
748 {
749 size_t i;
750 char ret_path[INTERNET_MAX_URL_LENGTH];
751 DWORD len, ret;
752 WCHAR ret_pathW[INTERNET_MAX_URL_LENGTH];
753 WCHAR *pathW, *urlW;
754 static const char url[] = "http://www.winehq.org";
755
756 /* Check ret_path = NULL */
757 len = sizeof(url);
758 ret = PathCreateFromUrlA(url, NULL, &len, 0);
759 ok ( ret == E_INVALIDARG, "got 0x%08x expected E_INVALIDARG\n", ret);
760
761 for(i = 0; i < sizeof(TEST_PATHFROMURL) / sizeof(TEST_PATHFROMURL[0]); i++) {
762 len = INTERNET_MAX_URL_LENGTH;
763 ret = PathCreateFromUrlA(TEST_PATHFROMURL[i].url, ret_path, &len, 0);
764 ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url %s\n", ret, TEST_PATHFROMURL[i].url);
765 if(TEST_PATHFROMURL[i].path) {
766 ok(!lstrcmpi(ret_path, TEST_PATHFROMURL[i].path), "got %s expected %s from url %s\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
767 ok(len == strlen(ret_path), "ret len %d from url %s\n", len, TEST_PATHFROMURL[i].url);
768 }
769 len = INTERNET_MAX_URL_LENGTH;
770 pathW = GetWideString(TEST_PATHFROMURL[i].path);
771 urlW = GetWideString(TEST_PATHFROMURL[i].url);
772 ret = PathCreateFromUrlW(urlW, ret_pathW, &len, 0);
773 WideCharToMultiByte(CP_ACP, 0, ret_pathW, -1, ret_path, sizeof(ret_path),0,0);
774 ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url L\"%s\"\n", ret, TEST_PATHFROMURL[i].url);
775 if(TEST_PATHFROMURL[i].path) {
776 ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L\"%s\"\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
777 ok(len == lstrlenW(ret_pathW), "ret len %d from url L\"%s\"\n", len, TEST_PATHFROMURL[i].url);
778 }
779 FreeWideString(urlW);
780 FreeWideString(pathW);
781 }
782 }
783
784
785 static void test_PathIsUrl(void)
786 {
787 size_t i;
788 BOOL ret;
789
790 for(i = 0; i < sizeof(TEST_PATH_IS_URL)/sizeof(TEST_PATH_IS_URL[0]); i++) {
791 ret = PathIsURLA(TEST_PATH_IS_URL[i].path);
792 ok(ret == TEST_PATH_IS_URL[i].expect,
793 "returned %d from path %s, expected %d\n", ret, TEST_PATH_IS_URL[i].path,
794 TEST_PATH_IS_URL[i].expect);
795 }
796 }
797
798 static const DWORD SHELL_charclass[] =
799 {
800 0x00000000, 0x00000000, 0x00000000, 0x00000000,
801 0x00000000, 0x00000000, 0x00000000, 0x00000000,
802 0x00000000, 0x00000000, 0x00000000, 0x00000000,
803 0x00000000, 0x00000000, 0x00000000, 0x00000000,
804 0x00000000, 0x00000000, 0x00000000, 0x00000000,
805 0x00000000, 0x00000000, 0x00000000, 0x00000000,
806 0x00000000, 0x00000000, 0x00000000, 0x00000000,
807 0x00000000, 0x00000000, 0x00000000, 0x00000000,
808 0x00000080, 0x00000100, 0x00000200, 0x00000100,
809 0x00000100, 0x00000100, 0x00000100, 0x00000100,
810 0x00000100, 0x00000100, 0x00000002, 0x00000100,
811 0x00000040, 0x00000100, 0x00000004, 0x00000000,
812 0x00000100, 0x00000100, 0x00000100, 0x00000100,
813 0x00000100, 0x00000100, 0x00000100, 0x00000100,
814 0x00000100, 0x00000100, 0x00000010, 0x00000020,
815 0x00000000, 0x00000100, 0x00000000, 0x00000001,
816 0x00000100, 0xffffffff, 0xffffffff, 0xffffffff,
817 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
818 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
819 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
820 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
821 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
822 0xffffffff, 0xffffffff, 0xffffffff, 0x00000100,
823 0x00000008, 0x00000100, 0x00000100, 0x00000100,
824 0x00000100, 0xffffffff, 0xffffffff, 0xffffffff,
825 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
826 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
827 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
828 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
829 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
830 0xffffffff, 0xffffffff, 0xffffffff, 0x00000100,
831 0x00000000, 0x00000100, 0x00000100
832 };
833
834 static void test_PathIsValidCharA(void)
835 {
836 BOOL ret;
837 unsigned int c;
838
839 ret = pPathIsValidCharA( 0x7f, 0 );
840 ok ( !ret, "PathIsValidCharA succeeded: 0x%08x\n", (DWORD)ret );
841
842 ret = pPathIsValidCharA( 0x7f, 1 );
843 ok ( !ret, "PathIsValidCharA succeeded: 0x%08x\n", (DWORD)ret );
844
845 for (c = 0; c < 0x7f; c++)
846 {
847 ret = pPathIsValidCharA( c, ~0U );
848 ok ( ret == SHELL_charclass[c] || (ret == 1 && SHELL_charclass[c] == 0xffffffff),
849 "PathIsValidCharA failed: 0x%02x got 0x%08x expected 0x%08x\n",
850 c, (DWORD)ret, SHELL_charclass[c] );
851 }
852
853 for (c = 0x7f; c <= 0xff; c++)
854 {
855 ret = pPathIsValidCharA( c, ~0U );
856 ok ( ret == 0x00000100,
857 "PathIsValidCharA failed: 0x%02x got 0x%08x expected 0x00000100\n",
858 c, (DWORD)ret );
859 }
860 }
861
862 static void test_PathIsValidCharW(void)
863 {
864 BOOL ret;
865 unsigned int c, err_count = 0;
866
867 ret = pPathIsValidCharW( 0x7f, 0 );
868 ok ( !ret, "PathIsValidCharW succeeded: 0x%08x\n", (DWORD)ret );
869
870 ret = pPathIsValidCharW( 0x7f, 1 );
871 ok ( !ret, "PathIsValidCharW succeeded: 0x%08x\n", (DWORD)ret );
872
873 for (c = 0; c < 0x7f; c++)
874 {
875 ret = pPathIsValidCharW( c, ~0U );
876 ok ( ret == SHELL_charclass[c] || (ret == 1 && SHELL_charclass[c] == 0xffffffff),
877 "PathIsValidCharW failed: 0x%02x got 0x%08x expected 0x%08x\n",
878 c, (DWORD)ret, SHELL_charclass[c] );
879 }
880
881 for (c = 0x007f; c <= 0xffff; c++)
882 {
883 ret = pPathIsValidCharW( c, ~0U );
884 ok ( ret == 0x00000100,
885 "PathIsValidCharW failed: 0x%02x got 0x%08x expected 0x00000100\n",
886 c, (DWORD)ret );
887 if (ret != 0x00000100)
888 {
889 if(++err_count > 100 ) {
890 trace("skipping rest of PathIsValidCharW tests "
891 "because of the current number of errors\n");
892 break;
893 }
894 }
895 }
896 }
897
898 static void test_PathMakePretty(void)
899 {
900 char buff[MAX_PATH];
901
902 ok (PathMakePrettyA(NULL) == FALSE, "PathMakePretty: NULL path succeeded\n");
903 buff[0] = '\0';
904 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Empty path failed\n");
905
906 strcpy(buff, "C:\\A LONG FILE NAME WITH \\SPACES.TXT");
907 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Long UC name failed\n");
908 ok (strcmp(buff, "C:\\a long file name with \\spaces.txt") == 0,
909 "PathMakePretty: Long UC name not changed\n");
910
911 strcpy(buff, "C:\\A LONG FILE NAME WITH \\MixedCase.TXT");
912 ok (PathMakePrettyA(buff) == FALSE, "PathMakePretty: Long MC name succeeded\n");
913 ok (strcmp(buff, "C:\\A LONG FILE NAME WITH \\MixedCase.TXT") == 0,
914 "PathMakePretty: Failed but modified path\n");
915
916 strcpy(buff, "TEST");
917 ok (PathMakePrettyA(buff) == TRUE, "PathMakePretty: Short name failed\n");
918 ok (strcmp(buff, "Test") == 0, "PathMakePretty: 1st char lowercased %s\n", buff);
919 }
920
921 static void test_PathMatchSpec(void)
922 {
923 static const char file[] = "c:\\foo\\bar\\filename.ext";
924 static const char spec1[] = ".ext";
925 static const char spec2[] = "*.ext";
926 static const char spec3[] = "*.ext ";
927 static const char spec4[] = " *.ext";
928 static const char spec5[] = "* .ext";
929 static const char spec6[] = "*. ext";
930 static const char spec7[] = "* . ext";
931 static const char spec8[] = "*.e?t";
932 static const char spec9[] = "filename.ext";
933 static const char spec10[] = "*bar\\filename.ext";
934 static const char spec11[] = " foo; *.ext";
935 static const char spec12[] = "*.ext;*.bar";
936 static const char spec13[] = "*bar*";
937
938 ok (PathMatchSpecA(file, spec1) == FALSE, "PathMatchSpec: Spec1 failed\n");
939 ok (PathMatchSpecA(file, spec2) == TRUE, "PathMatchSpec: Spec2 failed\n");
940 ok (PathMatchSpecA(file, spec3) == FALSE, "PathMatchSpec: Spec3 failed\n");
941 ok (PathMatchSpecA(file, spec4) == TRUE, "PathMatchSpec: Spec4 failed\n");
942 todo_wine ok (PathMatchSpecA(file, spec5) == TRUE, "PathMatchSpec: Spec5 failed\n");
943 todo_wine ok (PathMatchSpecA(file, spec6) == TRUE, "PathMatchSpec: Spec6 failed\n");
944 ok (PathMatchSpecA(file, spec7) == FALSE, "PathMatchSpec: Spec7 failed\n");
945 ok (PathMatchSpecA(file, spec8) == TRUE, "PathMatchSpec: Spec8 failed\n");
946 ok (PathMatchSpecA(file, spec9) == FALSE, "PathMatchSpec: Spec9 failed\n");
947 ok (PathMatchSpecA(file, spec10) == TRUE, "PathMatchSpec: Spec10 failed\n");
948 ok (PathMatchSpecA(file, spec11) == TRUE, "PathMatchSpec: Spec11 failed\n");
949 ok (PathMatchSpecA(file, spec12) == TRUE, "PathMatchSpec: Spec12 failed\n");
950 ok (PathMatchSpecA(file, spec13) == TRUE, "PathMatchSpec: Spec13 failed\n");
951 }
952
953 static void test_PathCombineW(void)
954 {
955 LPWSTR wszString, wszString2;
956 WCHAR wbuf[MAX_PATH+1], wstr1[MAX_PATH] = {'C',':','\\',0}, wstr2[MAX_PATH];
957 static const WCHAR expout[] = {'C',':','\\','A','A',0};
958 int i;
959
960 wszString2 = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
961
962 /* NULL test */
963 wszString = pPathCombineW(NULL, NULL, NULL);
964 ok (wszString == NULL, "Expected a NULL return\n");
965
966 /* Some NULL */
967 wszString2[0] = 'a';
968 wszString = pPathCombineW(wszString2, NULL, NULL);
969 ok (wszString == NULL, "Expected a NULL return\n");
970 ok (wszString2[0] == 0, "Destination string not empty\n");
971
972 HeapFree(GetProcessHeap(), 0, wszString2);
973
974 /* overflow test */
975 wstr2[0] = wstr2[1] = wstr2[2] = 'A';
976 for (i=3; i<MAX_PATH/2; i++)
977 wstr1[i] = wstr2[i] = 'A';
978 wstr1[(MAX_PATH/2) - 1] = wstr2[MAX_PATH/2] = 0;
979 memset(wbuf, 0xbf, sizeof(wbuf));
980
981 wszString = pPathCombineW(wbuf, wstr1, wstr2);
982 ok(wszString == NULL, "Expected a NULL return\n");
983 ok(wbuf[0] == 0, "Buffer contains data\n");
984
985 /* PathCombineW can be used in place */
986 wstr1[3] = 0;
987 wstr2[2] = 0;
988 ok(PathCombineW(wstr1, wstr1, wstr2) == wstr1, "Expected a wstr1 return\n");
989 ok(StrCmpW(wstr1, expout) == 0, "Unexpected PathCombine output\n");
990 }
991
992
993 #define LONG_LEN (MAX_PATH * 2)
994 #define HALF_LEN (MAX_PATH / 2 + 1)
995
996 static void test_PathCombineA(void)
997 {
998 LPSTR str;
999 char dest[MAX_PATH];
1000 char too_long[LONG_LEN];
1001 char one[HALF_LEN], two[HALF_LEN];
1002
1003 /* try NULL dest */
1004 SetLastError(0xdeadbeef);
1005 str = PathCombineA(NULL, "C:\\", "one\\two\\three");
1006 ok(str == NULL, "Expected NULL, got %p\n", str);
1007 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1008
1009 /* try NULL dest and NULL directory */
1010 SetLastError(0xdeadbeef);
1011 str = PathCombineA(NULL, NULL, "one\\two\\three");
1012 ok(str == NULL, "Expected NULL, got %p\n", str);
1013 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1014
1015 /* try all NULL*/
1016 SetLastError(0xdeadbeef);
1017 str = PathCombineA(NULL, NULL, NULL);
1018 ok(str == NULL, "Expected NULL, got %p\n", str);
1019 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1020
1021 /* try NULL file part */
1022 SetLastError(0xdeadbeef);
1023 lstrcpyA(dest, "control");
1024 str = PathCombineA(dest, "C:\\", NULL);
1025 ok(str == dest, "Expected str == dest, got %p\n", str);
1026 ok(!lstrcmp(str, "C:\\"), "Expected C:\\, got %s\n", str);
1027 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1028
1029 /* try empty file part */
1030 SetLastError(0xdeadbeef);
1031 lstrcpyA(dest, "control");
1032 str = PathCombineA(dest, "C:\\", "");
1033 ok(str == dest, "Expected str == dest, got %p\n", str);
1034 ok(!lstrcmp(str, "C:\\"), "Expected C:\\, got %s\n", str);
1035 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1036
1037 /* try empty directory and file part */
1038 SetLastError(0xdeadbeef);
1039 lstrcpyA(dest, "control");
1040 str = PathCombineA(dest, "", "");
1041 ok(str == dest, "Expected str == dest, got %p\n", str);
1042 ok(!lstrcmp(str, "\\"), "Expected \\, got %s\n", str);
1043 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1044
1045 /* try NULL directory */
1046 SetLastError(0xdeadbeef);
1047 lstrcpyA(dest, "control");
1048 str = PathCombineA(dest, NULL, "one\\two\\three");
1049 ok(str == dest, "Expected str == dest, got %p\n", str);
1050 ok(!lstrcmp(str, "one\\two\\three"), "Expected one\\two\\three, got %s\n", str);
1051 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1052
1053 /* try NULL directory and empty file part */
1054 SetLastError(0xdeadbeef);
1055 lstrcpyA(dest, "control");
1056 str = PathCombineA(dest, NULL, "");
1057 ok(str == dest, "Expected str == dest, got %p\n", str);
1058 ok(!lstrcmp(str, "\\"), "Expected \\, got %s\n", str);
1059 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1060
1061 /* try NULL directory and file part */
1062 SetLastError(0xdeadbeef);
1063 lstrcpyA(dest, "control");
1064 str = PathCombineA(dest, NULL, NULL);
1065 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1066 ok(lstrlenA(dest) == 0, "Expected 0 length, got %i\n", lstrlenA(dest));
1067 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1068
1069 /* try directory without backslash */
1070 SetLastError(0xdeadbeef);
1071 lstrcpyA(dest, "control");
1072 str = PathCombineA(dest, "C:", "one\\two\\three");
1073 ok(str == dest, "Expected str == dest, got %p\n", str);
1074 ok(!lstrcmp(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
1075 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1076
1077 /* try directory with backslash */
1078 SetLastError(0xdeadbeef);
1079 lstrcpyA(dest, "control");
1080 str = PathCombineA(dest, "C:\\", "one\\two\\three");
1081 ok(str == dest, "Expected str == dest, got %p\n", str);
1082 ok(!lstrcmp(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
1083 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1084
1085 /* try directory with backslash and file with prepended backslash */
1086 SetLastError(0xdeadbeef);
1087 lstrcpyA(dest, "control");
1088 str = PathCombineA(dest, "C:\\", "\\one\\two\\three");
1089 ok(str == dest, "Expected str == dest, got %p\n", str);
1090 ok(!lstrcmp(str, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", str);
1091 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1092
1093 /* try previous test, with backslash appended as well */
1094 SetLastError(0xdeadbeef);
1095 lstrcpyA(dest, "control");
1096 str = PathCombineA(dest, "C:\\", "\\one\\two\\three\\");
1097 ok(str == dest, "Expected str == dest, got %p\n", str);
1098 ok(!lstrcmp(str, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", str);
1099 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1100
1101 /* try a relative directory */
1102 SetLastError(0xdeadbeef);
1103 lstrcpyA(dest, "control");
1104 str = PathCombineA(dest, "relative\\dir", "\\one\\two\\three\\");
1105 ok(str == dest, "Expected str == dest, got %p\n", str);
1106 ok(!lstrcmp(str, "one\\two\\three\\"), "Expected one\\two\\three\\, got %s\n", str);
1107 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1108
1109 /* try forward slashes */
1110 SetLastError(0xdeadbeef);
1111 lstrcpyA(dest, "control");
1112 str = PathCombineA(dest, "C:\\", "one/two/three\\");
1113 ok(str == dest, "Expected str == dest, got %p\n", str);
1114 ok(!lstrcmp(str, "C:\\one/two/three\\"), "Expected one/two/three\\, got %s\n", str);
1115 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1116
1117 /* try a really weird directory */
1118 SetLastError(0xdeadbeef);
1119 lstrcpyA(dest, "control");
1120 str = PathCombineA(dest, "C:\\/\\/", "\\one\\two\\three\\");
1121 ok(str == dest, "Expected str == dest, got %p\n", str);
1122 ok(!lstrcmp(str, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", str);
1123 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1124
1125 /* try periods */
1126 SetLastError(0xdeadbeef);
1127 lstrcpyA(dest, "control");
1128 str = PathCombineA(dest, "C:\\", "one\\..\\two\\.\\three");
1129 ok(str == dest, "Expected str == dest, got %p\n", str);
1130 ok(!lstrcmp(str, "C:\\two\\three"), "Expected C:\\two\\three, got %s\n", str);
1131 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1132
1133 /* try .. as file */
1134 /* try forward slashes */
1135 SetLastError(0xdeadbeef);
1136 lstrcpyA(dest, "control");
1137 str = PathCombineA(dest, "C:\\", "..");
1138 ok(str == dest, "Expected str == dest, got %p\n", str);
1139 ok(!lstrcmp(str, "C:\\"), "Expected C:\\, got %s\n", str);
1140 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1141
1142 memset(too_long, 'a', LONG_LEN);
1143 too_long[LONG_LEN - 1] = '\0';
1144
1145 /* try a file longer than MAX_PATH */
1146 SetLastError(0xdeadbeef);
1147 lstrcpyA(dest, "control");
1148 str = PathCombineA(dest, "C:\\", too_long);
1149 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1150 ok(lstrlenA(dest) == 0, "Expected 0 length, got %i\n", lstrlenA(dest));
1151 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1152
1153 /* try a directory longer than MAX_PATH */
1154 SetLastError(0xdeadbeef);
1155 lstrcpyA(dest, "control");
1156 str = PathCombineA(dest, too_long, "one\\two\\three");
1157 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1158 ok(lstrlenA(dest) == 0, "Expected 0 length, got %i\n", lstrlenA(dest));
1159 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1160
1161 memset(one, 'b', HALF_LEN);
1162 memset(two, 'c', HALF_LEN);
1163 one[HALF_LEN - 1] = '\0';
1164 two[HALF_LEN - 1] = '\0';
1165
1166 /* destination string is longer than MAX_PATH, but not the constituent parts */
1167 SetLastError(0xdeadbeef);
1168 lstrcpyA(dest, "control");
1169 str = PathCombineA(dest, one, two);
1170 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1171 ok(lstrlenA(dest) == 0, "Expected 0 length, got %i\n", lstrlenA(dest));
1172 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1173 }
1174
1175 static void test_PathAddBackslash(void)
1176 {
1177 LPSTR str;
1178 char path[MAX_PATH];
1179 char too_long[LONG_LEN];
1180
1181 /* try a NULL path */
1182 SetLastError(0xdeadbeef);
1183 str = PathAddBackslashA(NULL);
1184 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1185 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1186
1187 /* try an empty path */
1188 path[0] = '\0';
1189 SetLastError(0xdeadbeef);
1190 str = PathAddBackslashA(path);
1191 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
1192 ok(lstrlenA(path) == 0, "Expected empty string, got %i\n", lstrlenA(path));
1193 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1194
1195 /* try a relative path */
1196 lstrcpyA(path, "one\\two");
1197 SetLastError(0xdeadbeef);
1198 str = PathAddBackslashA(path);
1199 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
1200 ok(!lstrcmp(path, "one\\two\\"), "Expected one\\two\\, got %s\n", path);
1201 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1202
1203 /* try periods */
1204 lstrcpyA(path, "one\\..\\two");
1205 SetLastError(0xdeadbeef);
1206 str = PathAddBackslashA(path);
1207 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
1208 ok(!lstrcmp(path, "one\\..\\two\\"), "Expected one\\..\\two\\, got %s\n", path);
1209 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1210
1211 /* try just a space */
1212 lstrcpyA(path, " ");
1213 SetLastError(0xdeadbeef);
1214 str = PathAddBackslashA(path);
1215 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
1216 ok(!lstrcmp(path, " \\"), "Expected \\, got %s\n", path);
1217 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1218
1219 /* path already has backslash */
1220 lstrcpyA(path, "C:\\one\\");
1221 SetLastError(0xdeadbeef);
1222 str = PathAddBackslashA(path);
1223 ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str);
1224 ok(!lstrcmp(path, "C:\\one\\"), "Expected C:\\one\\, got %s\n", path);
1225 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1226
1227 memset(too_long, 'a', LONG_LEN);
1228 too_long[LONG_LEN - 1] = '\0';
1229
1230 /* path is longer than MAX_PATH */
1231 SetLastError(0xdeadbeef);
1232 str = PathAddBackslashA(too_long);
1233 ok(str == NULL, "Expected str == NULL, got %p\n", str);
1234 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1235 }
1236
1237 static void test_PathAppendA(void)
1238 {
1239 char path[MAX_PATH];
1240 char too_long[LONG_LEN];
1241 char one[HALF_LEN], two[HALF_LEN];
1242 BOOL res;
1243
1244 lstrcpy(path, "C:\\one");
1245
1246 /* try NULL pszMore */
1247 SetLastError(0xdeadbeef);
1248 res = PathAppendA(path, NULL);
1249 ok(!res, "Expected failure\n");
1250 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1251 ok(!lstrcmp(path, "C:\\one"), "Expected C:\\one, got %s\n", path);
1252
1253 /* try empty pszMore */
1254 SetLastError(0xdeadbeef);
1255 res = PathAppendA(path, "");
1256 ok(res, "Expected success\n");
1257 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1258 ok(!lstrcmp(path, "C:\\one"), "Expected C:\\one, got %s\n", path);
1259
1260 /* try NULL pszPath */
1261 SetLastError(0xdeadbeef);
1262 res = PathAppendA(NULL, "two\\three");
1263 ok(!res, "Expected failure\n");
1264 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1265
1266 /* try empty pszPath */
1267 path[0] = '\0';
1268 SetLastError(0xdeadbeef);
1269 res = PathAppendA(path, "two\\three");
1270 ok(res, "Expected success\n");
1271 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1272 ok(!lstrcmp(path, "two\\three"), "Expected \\two\\three, got %s\n", path);
1273
1274 /* try empty pszPath and empty pszMore */
1275 path[0] = '\0';
1276 SetLastError(0xdeadbeef);
1277 res = PathAppendA(path, "");
1278 ok(res, "Expected success\n");
1279 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1280 ok(!lstrcmp(path, "\\"), "Expected \\, got %s\n", path);
1281
1282 /* try legit params */
1283 lstrcpy(path, "C:\\one");
1284 SetLastError(0xdeadbeef);
1285 res = PathAppendA(path, "two\\three");
1286 ok(res, "Expected success\n");
1287 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1288 ok(!lstrcmp(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
1289
1290 /* try pszPath with backslash after it */
1291 lstrcpy(path, "C:\\one\\");
1292 SetLastError(0xdeadbeef);
1293 res = PathAppendA(path, "two\\three");
1294 ok(res, "Expected success\n");
1295 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1296 ok(!lstrcmp(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
1297
1298 /* try pszMore with backslash before it */
1299 lstrcpy(path, "C:\\one");
1300 SetLastError(0xdeadbeef);
1301 res = PathAppendA(path, "\\two\\three");
1302 ok(res, "Expected success\n");
1303 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1304 ok(!lstrcmp(path, "C:\\one\\two\\three"), "Expected C:\\one\\two\\three, got %s\n", path);
1305
1306 /* try pszMore with backslash after it */
1307 lstrcpy(path, "C:\\one");
1308 SetLastError(0xdeadbeef);
1309 res = PathAppendA(path, "two\\three\\");
1310 ok(res, "Expected success\n");
1311 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1312 ok(!lstrcmp(path, "C:\\one\\two\\three\\"), "Expected C:\\one\\two\\three\\, got %s\n", path);
1313
1314 /* try spaces in pszPath */
1315 lstrcpy(path, "C: \\ one ");
1316 SetLastError(0xdeadbeef);
1317 res = PathAppendA(path, "two\\three");
1318 ok(res, "Expected success\n");
1319 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1320 ok(!lstrcmp(path, "C: \\ one \\two\\three"), "Expected C: \\ one \\two\\three, got %s\n", path);
1321
1322 /* try spaces in pszMore */
1323 lstrcpy(path, "C:\\one");
1324 SetLastError(0xdeadbeef);
1325 res = PathAppendA(path, " two \\ three ");
1326 ok(res, "Expected success\n");
1327 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1328 ok(!lstrcmp(path, "C:\\one\\ two \\ three "), "Expected 'C:\\one\\ two \\ three ', got %s\n", path);
1329
1330 /* pszPath is too long */
1331 memset(too_long, 'a', LONG_LEN);
1332 too_long[LONG_LEN - 1] = '\0';
1333 SetLastError(0xdeadbeef);
1334 res = PathAppendA(too_long, "two\\three");
1335 ok(!res, "Expected failure\n");
1336 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1337 ok(lstrlen(too_long) == 0, "Expected length of too_long to be zero, got %i\n", lstrlen(too_long));
1338
1339 /* pszMore is too long */
1340 lstrcpy(path, "C:\\one");
1341 memset(too_long, 'a', LONG_LEN);
1342 too_long[LONG_LEN - 1] = '\0';
1343 SetLastError(0xdeadbeef);
1344 res = PathAppendA(path, too_long);
1345 ok(!res, "Expected failure\n");
1346 todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1347 ok(lstrlen(path) == 0, "Expected length of path to be zero, got %i\n", lstrlen(path));
1348
1349 /* both params combined are too long */
1350 memset(one, 'a', HALF_LEN);
1351 one[HALF_LEN - 1] = '\0';
1352 memset(two, 'b', HALF_LEN);
1353 two[HALF_LEN - 1] = '\0';
1354 SetLastError(0xdeadbeef);
1355 res = PathAppendA(one, two);
1356 ok(!res, "Expected failure\n");
1357 ok(lstrlen(one) == 0, "Expected length of one to be zero, got %i\n", lstrlen(one));
1358 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1359 }
1360
1361 static void test_PathCanonicalizeA(void)
1362 {
1363 char dest[MAX_PATH];
1364 char too_long[LONG_LEN];
1365 BOOL res;
1366
1367 /* try a NULL source */
1368 lstrcpy(dest, "test");
1369 SetLastError(0xdeadbeef);
1370 res = PathCanonicalizeA(dest, NULL);
1371 ok(!res, "Expected failure\n");
1372 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1373 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1374 todo_wine
1375 {
1376 ok(!lstrcmp(dest, "test"), "Expected test, got %s\n", dest);
1377 }
1378
1379 /* try an empty source */
1380 lstrcpy(dest, "test");
1381 SetLastError(0xdeadbeef);
1382 res = PathCanonicalizeA(dest, "");
1383 ok(res, "Expected success\n");
1384 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1385 ok(!lstrcmp(dest, "\\"), "Expected \\, got %s\n", dest);
1386
1387 /* try a NULL dest */
1388 SetLastError(0xdeadbeef);
1389 res = PathCanonicalizeA(NULL, "C:\\");
1390 ok(!res, "Expected failure\n");
1391 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1392 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1393
1394 /* try empty dest */
1395 dest[0] = '\0';
1396 SetLastError(0xdeadbeef);
1397 res = PathCanonicalizeA(dest, "C:\\");
1398 ok(res, "Expected success\n");
1399 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1400 ok(!lstrcmp(dest, "C:\\"), "Expected C:\\, got %s\n", dest);
1401
1402 /* try non-empty dest */
1403 lstrcpy(dest, "test");
1404 SetLastError(0xdeadbeef);
1405 res = PathCanonicalizeA(dest, "C:\\");
1406 ok(res, "Expected success\n");
1407 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1408 ok(!lstrcmp(dest, "C:\\"), "Expected C:\\, got %s\n", dest);
1409
1410 /* try a space for source */
1411 lstrcpy(dest, "test");
1412 SetLastError(0xdeadbeef);
1413 res = PathCanonicalizeA(dest, " ");
1414 ok(res, "Expected success\n");
1415 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1416 ok(!lstrcmp(dest, " "), "Expected ' ', got %s\n", dest);
1417
1418 /* try a relative path */
1419 lstrcpy(dest, "test");
1420 SetLastError(0xdeadbeef);
1421 res = PathCanonicalizeA(dest, "one\\two");
1422 ok(res, "Expected success\n");
1423 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1424 ok(!lstrcmp(dest, "one\\two"), "Expected one\\two, got %s\n", dest);
1425
1426 /* try current dir and previous dir */
1427 lstrcpy(dest, "test");
1428 SetLastError(0xdeadbeef);
1429 res = PathCanonicalizeA(dest, "C:\\one\\.\\..\\two\\three\\..");
1430 ok(res, "Expected success\n");
1431 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1432 ok(!lstrcmp(dest, "C:\\two"), "Expected C:\\two, got %s\n", dest);
1433
1434 /* try simple forward slashes */
1435 lstrcpy(dest, "test");
1436 SetLastError(0xdeadbeef);
1437 res = PathCanonicalizeA(dest, "C:\\one/two/three\\four/five\\six");
1438 ok(res, "Expected success\n");
1439 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1440 ok(!lstrcmp(dest, "C:\\one/two/three\\four/five\\six"),
1441 "Expected C:\\one/two/three\\four/five\\six, got %s\n", dest);
1442
1443 /* try simple forward slashes with same dir */
1444 lstrcpy(dest, "test");
1445 SetLastError(0xdeadbeef);
1446 res = PathCanonicalizeA(dest, "C:\\one/.\\two");
1447 ok(res, "Expected success\n");
1448 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1449 ok(!lstrcmp(dest, "C:\\one/.\\two"), "Expected C:\\one/.\\two, got %s\n", dest);
1450
1451 /* try simple forward slashes with change dir */
1452 lstrcpy(dest, "test");
1453 SetLastError(0xdeadbeef);
1454 res = PathCanonicalizeA(dest, "C:\\one/.\\two\\..");
1455 ok(res, "Expected success\n");
1456 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1457 ok(!lstrcmp(dest, "C:\\one/."), "Expected C:\\one/., got %s\n", dest);
1458
1459 /* try forward slashes with change dirs
1460 * NOTE: if there is a forward slash in between two backslashes,
1461 * everything in between the two backslashes is considered on dir
1462 */
1463 lstrcpy(dest, "test");
1464 SetLastError(0xdeadbeef);
1465 res = PathCanonicalizeA(dest, "C:\\one/.\\..\\two/three\\..\\four/.five");
1466 ok(res, "Expected success\n");
1467 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1468 ok(!lstrcmp(dest, "C:\\four/.five"), "Expected C:\\four/.five, got %s\n", dest);
1469
1470 /* try src is too long */
1471 memset(too_long, 'a', LONG_LEN);
1472 too_long[LONG_LEN - 1] = '\0';
1473 lstrcpy(dest, "test");
1474 SetLastError(0xdeadbeef);
1475 res = PathCanonicalizeA(dest, too_long);
1476 todo_wine
1477 {
1478 ok(!res, "Expected failure\n");
1479 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1480 }
1481 ok(lstrlen(too_long) == LONG_LEN - 1, "Expected length LONG_LEN - 1, got %i\n", lstrlen(too_long));
1482 }
1483
1484 static void test_PathFindExtensionA(void)
1485 {
1486 LPSTR ext;
1487 char path[MAX_PATH];
1488 char too_long[LONG_LEN];
1489
1490 /* try a NULL path */
1491 SetLastError(0xdeadbeef);
1492 ext = PathFindExtensionA(NULL);
1493 ok(ext == NULL, "Expected NULL, got %p\n", ext);
1494 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1495
1496 /* try an empty path */
1497 path[0] = '\0';
1498 SetLastError(0xdeadbeef);
1499 ext = PathFindExtensionA(path);
1500 ok(ext == path, "Expected ext == path, got %p\n", ext);
1501 ok(lstrlen(ext) == 0, "Expected length 0, got %i\n", lstrlen(ext));
1502 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1503
1504 /* try a path without an extension */
1505 lstrcpy(path, "file");
1506 SetLastError(0xdeadbeef);
1507 ext = PathFindExtensionA(path);
1508 ok(ext == path + lstrlen(path), "Expected ext == path, got %p\n", ext);
1509 ok(lstrlen(ext) == 0, "Expected length 0, got %i\n", lstrlen(ext));
1510 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1511
1512 /* try a path with an extension */
1513 lstrcpy(path, "file.txt");
1514 SetLastError(0xdeadbeef);
1515 ext = PathFindExtensionA(path);
1516 ok(ext == path + lstrlen("file"),
1517 "Expected ext == path + lstrlen(\"file\"), got %p\n", ext);
1518 ok(!lstrcmp(ext, ".txt"), "Expected .txt, got %s\n", ext);
1519 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1520
1521 /* try a path with two extensions */
1522 lstrcpy(path, "file.txt.doc");
1523 SetLastError(0xdeadbeef);
1524 ext = PathFindExtensionA(path);
1525 ok(ext == path + lstrlen("file.txt"),
1526 "Expected ext == path + lstrlen(\"file.txt\"), got %p\n", ext);
1527 ok(!lstrcmp(ext, ".doc"), "Expected .txt, got %s\n", ext);
1528 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1529
1530 /* try a path longer than MAX_PATH without an extension*/
1531 memset(too_long, 'a', LONG_LEN);
1532 too_long[LONG_LEN - 1] = '\0';
1533 SetLastError(0xdeadbeef);
1534 ext = PathFindExtensionA(too_long);
1535 ok(ext == too_long + LONG_LEN - 1, "Expected ext == too_long + LONG_LEN - 1, got %p\n", ext);
1536 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1537
1538 /* try a path longer than MAX_PATH with an extension*/
1539 memset(too_long, 'a', LONG_LEN);
1540 too_long[LONG_LEN - 1] = '\0';
1541 lstrcpy(too_long + 300, ".abcde");
1542 too_long[lstrlen(too_long)] = 'a';
1543 SetLastError(0xdeadbeef);
1544 ext = PathFindExtensionA(too_long);
1545 ok(ext == too_long + 300, "Expected ext == too_long + 300, got %p\n", ext);
1546 ok(lstrlen(ext) == LONG_LEN - 301, "Expected LONG_LEN - 301, got %i\n", lstrlen(ext));
1547 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1548 }
1549
1550 static void test_PathBuildRootA(void)
1551 {
1552 LPSTR root;
1553 char path[10];
1554 char root_expected[26][4];
1555 char drive;
1556 int j;
1557
1558 /* set up the expected paths */
1559 for (drive = 'A'; drive <= 'Z'; drive++)
1560 sprintf(root_expected[drive - 'A'], "%c:\\", drive);
1561
1562 /* test the expected values */
1563 for (j = 0; j < 26; j++)
1564 {
1565 SetLastError(0xdeadbeef);
1566 lstrcpy(path, "aaaaaaaaa");
1567 root = PathBuildRootA(path, j);
1568 ok(root == path, "Expected root == path, got %p\n", root);
1569 ok(!lstrcmp(root, root_expected[j]), "Expected %s, got %s\n", root_expected[j], root);
1570 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1571 }
1572
1573 /* test a negative drive number */
1574 SetLastError(0xdeadbeef);
1575 lstrcpy(path, "aaaaaaaaa");
1576 root = PathBuildRootA(path, -1);
1577 ok(root == path, "Expected root == path, got %p\n", root);
1578 ok(!lstrcmp(path, "aaaaaaaaa"), "Expected aaaaaaaaa, got %s\n", path);
1579 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1580
1581 /* test a drive number greater than 25 */
1582 SetLastError(0xdeadbeef);
1583 lstrcpy(path, "aaaaaaaaa");
1584 root = PathBuildRootA(path, 26);
1585 ok(root == path, "Expected root == path, got %p\n", root);
1586 ok(!lstrcmp(path, "aaaaaaaaa"), "Expected aaaaaaaaa, got %s\n", path);
1587 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1588
1589 /* length of path is less than 4 */
1590 SetLastError(0xdeadbeef);
1591 lstrcpy(path, "aa");
1592 root = PathBuildRootA(path, 0);
1593 ok(root == path, "Expected root == path, got %p\n", root);
1594 ok(!lstrcmp(path, "A:\\"), "Expected A:\\, got %s\n", path);
1595 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1596
1597 /* path is NULL */
1598 SetLastError(0xdeadbeef);
1599 root = PathBuildRootA(NULL, 0);
1600 ok(root == NULL, "Expected root == NULL, got %p\n", root);
1601 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1602 }
1603
1604 static void test_PathCommonPrefixA(void)
1605 {
1606 char path1[MAX_PATH], path2[MAX_PATH];
1607 char out[MAX_PATH];
1608 int count;
1609
1610 /* test NULL path1 */
1611 SetLastError(0xdeadbeef);
1612 lstrcpy(path2, "C:\\");
1613 lstrcpy(out, "aaa");
1614 count = PathCommonPrefixA(NULL, path2, out);
1615 ok(count == 0, "Expected 0, got %i\n", count);
1616 todo_wine
1617 {
1618 ok(!lstrcmp(out, "aaa"), "Expected aaa, got %s\n", out);
1619 }
1620 ok(!lstrcmp(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1621 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1622
1623 /* test NULL path2 */
1624 SetLastError(0xdeadbeef);
1625 lstrcpy(path1, "C:\\");
1626 lstrcpy(out, "aaa");
1627 count = PathCommonPrefixA(path1, NULL, out);
1628 ok(count == 0, "Expected 0, got %i\n", count);
1629 todo_wine
1630 {
1631 ok(!lstrcmp(out, "aaa"), "Expected aaa, got %s\n", out);
1632 }
1633 ok(!lstrcmp(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1634 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1635
1636 /* test empty path1 */
1637 SetLastError(0xdeadbeef);
1638 path1[0] = '\0';
1639 lstrcpy(path2, "C:\\");
1640 lstrcpy(out, "aaa");
1641 count = PathCommonPrefixA(path1, path2, out);
1642 ok(count == 0, "Expected 0, got %i\n", count);
1643 ok(lstrlen(out) == 0, "Expected 0 length out, got %i\n", lstrlen(out));
1644 ok(lstrlen(path1) == 0, "Expected 0 length path1, got %i\n", lstrlen(path1));
1645 ok(!lstrcmp(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1646 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1647
1648 /* test empty path1 */
1649 SetLastError(0xdeadbeef);
1650 path2[0] = '\0';
1651 lstrcpy(path1, "C:\\");
1652 lstrcpy(out, "aaa");
1653 count = PathCommonPrefixA(path1, path2, out);
1654 ok(count == 0, "Expected 0, got %i\n", count);
1655 ok(lstrlen(out) == 0, "Expected 0 length out, got %i\n", lstrlen(out));
1656 ok(lstrlen(path2) == 0, "Expected 0 length path2, got %i\n", lstrlen(path2));
1657 ok(!lstrcmp(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1658 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1659
1660 /* paths are legit, out is NULL */
1661 SetLastError(0xdeadbeef);
1662 lstrcpy(path1, "C:\\");
1663 lstrcpy(path2, "C:\\");
1664 count = PathCommonPrefixA(path1, path2, NULL);
1665 ok(count == 3, "Expected 3, got %i\n", count);
1666 ok(!lstrcmp(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1667 ok(!lstrcmp(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1668 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1669
1670 /* all parameters legit */
1671 SetLastError(0xdeadbeef);
1672 lstrcpy(path1, "C:\\");
1673 lstrcpy(path2, "C:\\");
1674 lstrcpy(out, "aaa");
1675 count = PathCommonPrefixA(path1, path2, out);
1676 ok(count == 3, "Expected 3, got %i\n", count);
1677 ok(!lstrcmp(path1, "C:\\"), "Expected C:\\, got %s\n", path1);
1678 ok(!lstrcmp(path2, "C:\\"), "Expected C:\\, got %s\n", path2);
1679 ok(!lstrcmp(out, "C:\\"), "Expected C:\\, got %s\n", out);
1680 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1681
1682 /* path1 and path2 not the same, but common prefix */
1683 SetLastError(0xdeadbeef);
1684 lstrcpy(path1, "C:\\one\\two");
1685 lstrcpy(path2, "C:\\one\\three");
1686 lstrcpy(out, "aaa");
1687 count = PathCommonPrefixA(path1, path2, out);
1688 ok(count == 6, "Expected 6, got %i\n", count);
1689 ok(!lstrcmp(path1, "C:\\one\\two"), "Expected C:\\one\\two, got %s\n", path1);
1690 ok(!lstrcmp(path2, "C:\\one\\three"), "Expected C:\\one\\three, got %s\n", path2);
1691 ok(!lstrcmp(out, "C:\\one"), "Expected C:\\one, got %s\n", out);
1692 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1693
1694 /* try . prefix */
1695 SetLastError(0xdeadbeef);
1696 lstrcpy(path1, "one\\.two");
1697 lstrcpy(path2, "one\\.three");
1698 lstrcpy(out, "aaa");
1699 count = PathCommonPrefixA(path1, path2, out);
1700 ok(count == 3, "Expected 3, got %i\n", count);
1701 ok(!lstrcmp(path1, "one\\.two"), "Expected one\\.two, got %s\n", path1);
1702 ok(!lstrcmp(path2, "one\\.three"), "Expected one\\.three, got %s\n", path2);
1703 ok(!lstrcmp(out, "one"), "Expected one, got %s\n", out);
1704 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1705
1706 /* try .. prefix */
1707 SetLastError(0xdeadbeef);
1708 lstrcpy(path1, "one\\..two");
1709 lstrcpy(path2, "one\\..three");
1710 lstrcpy(out, "aaa");
1711 count = PathCommonPrefixA(path1, path2, out);
1712 ok(count == 3, "Expected 3, got %i\n", count);
1713 ok(!lstrcmp(path1, "one\\..two"), "Expected one\\..two, got %s\n", path1);
1714 ok(!lstrcmp(path2, "one\\..three"), "Expected one\\..three, got %s\n", path2);
1715 ok(!lstrcmp(out, "one"), "Expected one, got %s\n", out);
1716 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1717
1718 /* try ... prefix */
1719 SetLastError(0xdeadbeef);
1720 lstrcpy(path1, "one\\...two");
1721 lstrcpy(path2, "one\\...three");
1722 lstrcpy(out, "aaa");
1723 count = PathCommonPrefixA(path1, path2, out);
1724 ok(count == 3, "Expected 3, got %i\n", count);
1725 ok(!lstrcmp(path1, "one\\...two"), "Expected one\\...two, got %s\n", path1);
1726 ok(!lstrcmp(path2, "one\\...three"), "Expected one\\...three, got %s\n", path2);
1727 ok(!lstrcmp(out, "one"), "Expected one, got %s\n", out);
1728 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1729
1730 /* try .\ prefix */
1731 SetLastError(0xdeadbeef);
1732 lstrcpy(path1, "one\\.\\two");
1733 lstrcpy(path2, "one\\.\\three");
1734 lstrcpy(out, "aaa");
1735 count = PathCommonPrefixA(path1, path2, out);
1736 ok(count == 5, "Expected 5, got %i\n", count);
1737 ok(!lstrcmp(path1, "one\\.\\two"), "Expected one\\.\\two, got %s\n", path1);
1738 ok(!lstrcmp(path2, "one\\.\\three"), "Expected one\\.\\three, got %s\n", path2);
1739 ok(!lstrcmp(out, "one\\."), "Expected one\\., got %s\n", out);
1740 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1741
1742 /* try ..\ prefix */
1743 SetLastError(0xdeadbeef);
1744 lstrcpy(path1, "one\\..\\two");
1745 lstrcpy(path2, "one\\..\\three");
1746 lstrcpy(out, "aaa");
1747 count = PathCommonPrefixA(path1, path2, out);
1748 ok(count == 6, "Expected 6, got %i\n", count);
1749 ok(!lstrcmp(path1, "one\\..\\two"), "Expected one\\..\\two, got %s\n", path1);
1750 ok(!lstrcmp(path2, "one\\..\\three"), "Expected one\\..\\three, got %s\n", path2);
1751 ok(!lstrcmp(out, "one\\.."), "Expected one\\.., got %s\n", out);
1752 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1753
1754 /* try ...\\ prefix */
1755 SetLastError(0xdeadbeef);
1756 lstrcpy(path1, "one\\...\\two");
1757 lstrcpy(path2, "one\\...\\three");
1758 lstrcpy(out, "aaa");
1759 count = PathCommonPrefixA(path1, path2, out);
1760 ok(count == 7, "Expected 7, got %i\n", count);
1761 ok(!lstrcmp(path1, "one\\...\\two"), "Expected one\\...\\two, got %s\n", path1);
1762 ok(!lstrcmp(path2, "one\\...\\three"), "Expected one\\...\\three, got %s\n", path2);
1763 ok(!lstrcmp(out, "one\\..."), "Expected one\\..., got %s\n", out);
1764 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1765
1766 /* try prefix that is not an msdn labeled prefix type */
1767 SetLastError(0xdeadbeef);
1768 lstrcpy(path1, "same");
1769 lstrcpy(path2, "same");
1770 lstrcpy(out, "aaa");
1771 count = PathCommonPrefixA(path1, path2, out);
1772 ok(count == 4, "Expected 4, got %i\n", count);
1773 ok(!lstrcmp(path1, "same"), "Expected same, got %s\n", path1);
1774 ok(!lstrcmp(path2, "same"), "Expected same, got %s\n", path2);
1775 ok(!lstrcmp(out, "same"), "Expected same, got %s\n", out);
1776 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1777
1778 /* try . after directory */
1779 SetLastError(0xdeadbeef);
1780 lstrcpy(path1, "one\\mid.\\two");
1781 lstrcpy(path2, "one\\mid.\\three");
1782 lstrcpy(out, "aaa");
1783 count = PathCommonPrefixA(path1, path2, out);
1784 ok(count == 8, "Expected 8, got %i\n", count);
1785 ok(!lstrcmp(path1, "one\\mid.\\two"), "Expected one\\mid.\\two, got %s\n", path1);
1786 ok(!lstrcmp(path2, "one\\mid.\\three"), "Expected one\\mid.\\three, got %s\n", path2);
1787 ok(!lstrcmp(out, "one\\mid."), "Expected one\\mid., got %s\n", out);
1788 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1789
1790 /* try . in the middle of a directory */
1791 SetLastError(0xdeadbeef);
1792 lstrcpy(path1, "one\\mid.end\\two");
1793 lstrcpy(path2, "one\\mid.end\\three");
1794 lstrcpy(out, "aaa");
1795 count = PathCommonPrefixA(path1, path2, out);
1796 ok(count == 11, "Expected 11, got %i\n", count);
1797 ok(!lstrcmp(path1, "one\\mid.end\\two"), "Expected one\\mid.end\\two, got %s\n", path1);
1798 ok(!lstrcmp(path2, "one\\mid.end\\three"), "Expected one\\mid.end\\three, got %s\n", path2);
1799 ok(!lstrcmp(out, "one\\mid.end"), "Expected one\\mid.end, got %s\n", out);
1800 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1801
1802 /* try comparing a .. with the expanded path */
1803 SetLastError(0xdeadbeef);
1804 lstrcpy(path1, "one\\..\\two");
1805 lstrcpy(path2, "two");
1806 lstrcpy(out, "aaa");
1807 count = PathCommonPrefixA(path1, path2, out);
1808 ok(count == 0, "Expected 0, got %i\n", count);
1809 ok(!lstrcmp(path1, "one\\..\\two"), "Expected one\\..\\two, got %s\n", path1);
1810 ok(!lstrcmp(path2, "two"), "Expected two, got %s\n", path2);
1811 ok(lstrlen(out) == 0, "Expected 0 length out, got %i\n", lstrlen(out));
1812 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError());
1813 }
1814
1815 static void test_PathUnquoteSpaces(void)
1816 {
1817 int i;
1818 for(i = 0; i < sizeof(TEST_PATH_UNQUOTE_SPACES) / sizeof(TEST_PATH_UNQUOTE_SPACES[0]); i++)
1819 {
1820 char *path = strdupA(TEST_PATH_UNQUOTE_SPACES[i].path);
1821 WCHAR *pathW = GetWideString(TEST_PATH_UNQUOTE_SPACES[i].path);
1822 WCHAR *resultW = GetWideString(TEST_PATH_UNQUOTE_SPACES[i].result);
1823
1824 PathUnquoteSpacesA(path);
1825 ok(!strcmp(path, TEST_PATH_UNQUOTE_SPACES[i].result), "%s (A): got %s expected %s\n",
1826 TEST_PATH_UNQUOTE_SPACES[i].path, path,
1827 TEST_PATH_UNQUOTE_SPACES[i].result);
1828
1829 PathUnquoteSpacesW(pathW);
1830 ok(!lstrcmpW(pathW, resultW), "%s (W): strings differ\n",
1831 TEST_PATH_UNQUOTE_SPACES[i].path);
1832 FreeWideString(pathW);
1833 FreeWideString(resultW);
1834 HeapFree(GetProcessHeap(), 0, path);
1835 }
1836 }
1837
1838 START_TEST(path)
1839 {
1840 hShlwapi = GetModuleHandleA("shlwapi.dll");
1841
1842 test_UrlHash();
1843 test_UrlGetPart();
1844 test_UrlCanonicalize();
1845 test_UrlEscape();
1846 test_UrlCombine();
1847 test_UrlCreateFromPath();
1848 test_UrlIs();
1849 test_UrlUnescape();
1850
1851 test_PathSearchAndQualify();
1852 test_PathCreateFromUrl();
1853 test_PathIsUrl();
1854
1855 test_PathAddBackslash();
1856 test_PathMakePretty();
1857 test_PathMatchSpec();
1858
1859 /* For whatever reason, PathIsValidCharA and PathAppendA share the same
1860 * ordinal number in some native versions. Check this to prevent a crash.
1861 */
1862 pPathIsValidCharA = (void*)GetProcAddress(hShlwapi, (LPSTR)455);
1863 if (pPathIsValidCharA && pPathIsValidCharA != (void*)GetProcAddress(hShlwapi, "PathAppendA"))
1864 {
1865 test_PathIsValidCharA();
1866
1867 pPathIsValidCharW = (void*)GetProcAddress(hShlwapi, (LPSTR)456);
1868 if (pPathIsValidCharW) test_PathIsValidCharW();
1869 }
1870
1871 pPathCombineW = (void*)GetProcAddress(hShlwapi, "PathCombineW");
1872 if (pPathCombineW)
1873 test_PathCombineW();
1874
1875 test_PathCombineA();
1876 test_PathAppendA();
1877 test_PathCanonicalizeA();
1878 test_PathFindExtensionA();
1879 test_PathBuildRootA();
1880 test_PathCommonPrefixA();
1881 test_PathUnquoteSpaces();
1882 }
useful hacks and other patches not (yet) suitable for mainline