dlls/shlwapi/tests/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wine/unicode.h"
  29 #include "winreg.h"
  30 #include "shlwapi.h"
  31 #include "wininet.h"
  32
  33 const char* TEST_URL_1 = "http://www.winehq.org/tests?date=10/10/1923";
  34 const char* TEST_URL_2 = "http://localhost:8080/tests%2e.html?date=Mon%2010/10/1923";
  35 const char* TEST_URL_3 = "http://foo:bar@localhost:21/internal.php?query=x&return=y";
  36
  37 typedef struct _TEST_URL_CANONICALIZE {
  38     char *url;
  39     DWORD flags;
  40     HRESULT expectret;
  41     char *expecturl;
  42 } TEST_URL_CANONICALIZE;
  43
  44 const TEST_URL_CANONICALIZE TEST_CANONICALIZE[] = {
  45     /*FIXME {"http://www.winehq.org/tests/../tests/../..", 0, S_OK, "http://www.winehq.org/"},*/
  46     {"http://www.winehq.org/tests/../tests", 0, S_OK, "http://www.winehq.org/tests"},
  47     {"http://www.winehq.org/tests\n", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, S_OK, "http://www.winehq.org/tests"},
  48     {"http://www.winehq.org/tests\r", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, S_OK, "http://www.winehq.org/tests"},
  49     {"http://www.winehq.org/tests\r", 0, S_OK, "http://www.winehq.org/tests"},
  50     {"http://www.winehq.org/tests\r", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests"},
  51     {"http://www.winehq.org/tests/../tests/", 0, S_OK, "http://www.winehq.org/tests/"},
  52     {"http://www.winehq.org/tests/../tests/..", 0, S_OK, "http://www.winehq.org/"},
  53     {"http://www.winehq.org/tests/../tests/../", 0, S_OK, "http://www.winehq.org/"},
  54     {"http://www.winehq.org/tests/..", 0, S_OK, "http://www.winehq.org/"},
  55     {"http://www.winehq.org/tests/../", 0, S_OK, "http://www.winehq.org/"},
  56     {"http://www.winehq.org/tests/..?query=x&return=y", 0, S_OK, "http://www.winehq.org/?query=x&return=y"},
  57     {"http://www.winehq.org/tests/../?query=x&return=y", 0, S_OK, "http://www.winehq.org/?query=x&return=y"},
  58     {"http://www.winehq.org/tests/..#example", 0, S_OK, "http://www.winehq.org/#example"},
  59     {"http://www.winehq.org/tests/../#example", 0, S_OK, "http://www.winehq.org/#example"},
  60     {"http://www.winehq.org/tests/../#example", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests/../#example"},
  61 };
  62
  63 typedef struct _TEST_URL_ESCAPE {
  64     char *url;
  65     DWORD flags;
  66     DWORD expectescaped;
  67     HRESULT expectret;
  68     char *expecturl;
  69 } TEST_URL_ESCAPE;
  70
  71 const TEST_URL_ESCAPE TEST_ESCAPE[] = {
  72     {"http://www.winehq.org/tests0", 0, 0, S_OK, "http://www.winehq.org/tests0"},
  73     {"http://www.winehq.org/tests1\n", 0, 0, S_OK, "http://www.winehq.org/tests1%0A"},
  74     {"http://www.winehq.org/tests2\r", 0, 0, S_OK, "http://www.winehq.org/tests2%0D"},
  75     {"http://www.winehq.org/tests3\r", URL_ESCAPE_SPACES_ONLY|URL_ESCAPE_UNSAFE, 0, S_OK, "http://www.winehq.org/tests3\r"},
  76     {"http://www.winehq.org/tests4\r", URL_ESCAPE_SPACES_ONLY, 0, S_OK, "http://www.winehq.org/tests4\r"},
  77     {"http://www.winehq.org/tests5\r", URL_WININET_COMPATIBILITY|URL_ESCAPE_SPACES_ONLY, 0, S_OK, "http://www.winehq.org/tests5\r"},
  78     {"/direct/swhelp/series6/6.2i_latestservicepack.dat\r", URL_ESCAPE_SPACES_ONLY, 0, S_OK, "/direct/swhelp/series6/6.2i_latestservicepack.dat\r"},
  79
  80     {"file://////foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
  81     {"file://///foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
  82     {"file:////foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
  83     {"file:///localhost/foo/bar\\baz", 0, 0, S_OK, "file:///localhost/foo/bar/baz"},
  84     {"file:///foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  85     {"file://loCalHost/foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  86     {"file://foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
  87     {"file:/localhost/foo/bar\\baz", 0, 0, S_OK, "file:///localhost/foo/bar/baz"},
  88     {"file:/foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  89     {"file:foo/bar\\baz", 0, 0, S_OK, "file:foo/bar/baz"},
  90     {"file:\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  91     {"file:\\\\foo/bar\\baz", 0, 0, S_OK, "file://foo/bar/baz"},
  92     {"file:\\\\\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  93     {"file:\\\\localhost\\foo/bar\\baz", 0, 0, S_OK, "file:///foo/bar/baz"},
  94     {"file:///f oo/b?a r\\baz", 0, 0, S_OK, "file:///f%20oo/b?a r\\baz"},
  95     {"file:///foo/b#a r\\baz", 0, 0, S_OK, "file:///foo/b%23a%20r/baz"},
  96     {"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"},
  97     {"file:///f o%o/b?a r\\b%az", URL_ESCAPE_PERCENT, 0, S_OK, "file:///f%20o%25o/b?a r\\b%az"},
  98     {"file:/foo/bar\\baz", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "file:%2Ffoo%2Fbar%5Cbaz"},
  99
 100     {"foo/b%ar\\ba?z\\", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "foo%2Fb%ar%5Cba%3Fz%5C"},
 101     {"foo/b%ar\\ba?z\\", URL_ESCAPE_PERCENT | URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "foo%2Fb%25ar%5Cba%3Fz%5C"},
 102     {"foo/bar\\ba?z\\", 0, 0, S_OK, "foo/bar%5Cba?z\\"},
 103     {"/foo/bar\\ba?z\\", 0, 0, S_OK, "/foo/bar%5Cba?z\\"},
 104     {"/foo/bar\\ba#z\\", 0, 0, S_OK, "/foo/bar%5Cba#z\\"},
 105     {"/foo/%5C", 0, 0, S_OK, "/foo/%5C"},
 106     {"/foo/%5C", URL_ESCAPE_PERCENT, 0, S_OK, "/foo/%255C"},
 107
 108     {"http://////foo/bar\\baz", 0, 0, S_OK, "http://////foo/bar/baz"},
 109     {"http://///foo/bar\\baz", 0, 0, S_OK, "http://///foo/bar/baz"},
 110     {"http:////foo/bar\\baz", 0, 0, S_OK, "http:////foo/bar/baz"},
 111     {"http:///foo/bar\\baz", 0, 0, S_OK, "http:///foo/bar/baz"},
 112     {"http://localhost/foo/bar\\baz", 0, 0, S_OK, "http://localhost/foo/bar/baz"},
 113     {"http://foo/bar\\baz", 0, 0, S_OK, "http://foo/bar/baz"},
 114     {"http:/foo/bar\\baz", 0, 0, S_OK, "http:/foo/bar/baz"},
 115     {"http:foo/bar\\ba?z\\", 0, 0, S_OK, "http:foo%2Fbar%2Fba?z\\"},
 116     {"http:foo/bar\\ba#z\\", 0, 0, S_OK, "http:foo%2Fbar%2Fba#z\\"},
 117     {"http:\\foo/bar\\baz", 0, 0, S_OK, "http:/foo/bar/baz"},
 118     {"http:\\\\foo/bar\\baz", 0, 0, S_OK, "http://foo/bar/baz"},
 119     {"http:\\\\\\foo/bar\\baz", 0, 0, S_OK, "http:///foo/bar/baz"},
 120     {"http:\\\\\\\\foo/bar\\baz", 0, 0, S_OK, "http:////foo/bar/baz"},
 121     {"http:/fo ?o/b ar\\baz", 0, 0, S_OK, "http:/fo%20?o/b ar\\baz"},
 122     {"http:fo ?o/b ar\\baz", 0, 0, S_OK, "http:fo%20?o/b ar\\baz"},
 123     {"http:/foo/bar\\baz", URL_ESCAPE_SEGMENT_ONLY, 0, S_OK, "http:%2Ffoo%2Fbar%5Cbaz"},
 124
 125     {"https://foo/bar\\baz", 0, 0, S_OK, "https://foo/bar/baz"},
 126     {"https:/foo/bar\\baz", 0, 0, S_OK, "https:/foo/bar/baz"},
 127     {"https:\\foo/bar\\baz", 0, 0, S_OK, "https:/foo/bar/baz"},
 128
 129     {"foo:////foo/bar\\baz", 0, 0, S_OK, "foo:////foo/bar%5Cbaz"},
 130     {"foo:///foo/bar\\baz", 0, 0, S_OK, "foo:///foo/bar%5Cbaz"},
 131     {"foo://localhost/foo/bar\\baz", 0, 0, S_OK, "foo://localhost/foo/bar%5Cbaz"},
 132     {"foo://foo/bar\\baz", 0, 0, S_OK, "foo://foo/bar%5Cbaz"},
 133     {"foo:/foo/bar\\baz", 0, 0, S_OK, "foo:/foo/bar%5Cbaz"},
 134     {"foo:foo/bar\\baz", 0, 0, S_OK, "foo:foo%2Fbar%5Cbaz"},
 135     {"foo:\\foo/bar\\baz", 0, 0, S_OK, "foo:%5Cfoo%2Fbar%5Cbaz"},
 136     {"foo:/foo/bar\\ba?\\z", 0, 0, S_OK, "foo:/foo/bar%5Cba?\\z"},
 137     {"foo:/foo/bar\\ba#\\z", 0, 0, S_OK, "foo:/foo/bar%5Cba#\\z"},
 138
 139     {"mailto:/fo/o@b\\%a?\\r.b#\\az", 0, 0, S_OK, "mailto:%2Ffo%2Fo@b%5C%a%3F%5Cr.b%23%5Caz"},
 140     {"mailto:fo/o@b\\%a?\\r.b#\\az", 0, 0, S_OK, "mailto:fo%2Fo@b%5C%a%3F%5Cr.b%23%5Caz"},
 141     {"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"},
 142
 143     {"ftp:fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:fo%2Fo@bar.baz%2Ffoo%2Fbar"},
 144     {"ftp:/fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:/fo/o@bar.baz/foo/bar"},
 145     {"ftp://fo/o@bar.baz/fo?o\\bar", 0, 0, S_OK, "ftp://fo/o@bar.baz/fo?o\\bar"},
 146     {"ftp://fo/o@bar.baz/fo#o\\bar", 0, 0, S_OK, "ftp://fo/o@bar.baz/fo#o\\bar"},
 147     {"ftp://localhost/o@bar.baz/fo#o\\bar", 0, 0, S_OK, "ftp://localhost/o@bar.baz/fo#o\\bar"},
 148     {"ftp:///fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:///fo/o@bar.baz/foo/bar"},
 149     {"ftp:////fo/o@bar.baz/foo/bar", 0, 0, S_OK, "ftp:////fo/o@bar.baz/foo/bar"}
 150 };
 151
 152 typedef struct _TEST_URL_COMBINE {
 153     char *url1;
 154     char *url2;
 155     DWORD flags;
 156     HRESULT expectret;
 157     char *expecturl;
 158 } TEST_URL_COMBINE;
 159
 160 const TEST_URL_COMBINE TEST_COMBINE[] = {
 161     {"http://www.winehq.org/tests", "tests1", 0, S_OK, "http://www.winehq.org/tests1"},
 162     /*FIXME {"http://www.winehq.org/tests", "../tests2", 0, S_OK, "http://www.winehq.org/tests2"},*/
 163     {"http://www.winehq.org/tests/", "../tests3", 0, S_OK, "http://www.winehq.org/tests3"},
 164     {"http://www.winehq.org/tests/../tests", "tests4", 0, S_OK, "http://www.winehq.org/tests4"},
 165     {"http://www.winehq.org/tests/../tests/", "tests5", 0, S_OK, "http://www.winehq.org/tests/tests5"},
 166     {"http://www.winehq.org/tests/../tests/", "/tests6/..", 0, S_OK, "http://www.winehq.org/"},
 167     {"http://www.winehq.org/tests/../tests/..", "tests7/..", 0, S_OK, "http://www.winehq.org/"},
 168     {"http://www.winehq.org/tests/?query=x&return=y", "tests8", 0, S_OK, "http://www.winehq.org/tests/tests8"},
 169     {"http://www.winehq.org/tests/#example", "tests9", 0, S_OK, "http://www.winehq.org/tests/tests9"},
 170     {"http://www.winehq.org/tests/../tests/", "/tests10/..", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests10/.."},
 171     {"http://www.winehq.org/tests/../", "tests11", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests/../tests11"},
 172 };
 173
 174 struct {
 175     char *path;
 176     char *url;
 177     DWORD ret;
 178 } TEST_URLFROMPATH [] = {
 179     {"foo", "file:foo", S_OK},
 180     {"foo\\bar", "file:foo/bar", S_OK},
 181     {"\\foo\\bar", "file:///foo/bar", S_OK},
 182     {"c:\\foo\\bar", "file:///c:/foo/bar", S_OK},
 183     {"c:foo\\bar", "file:///c:foo/bar", S_OK},
 184     {"c:\\foo/b a%r", "file:///c:/foo/b%20a%25r", S_OK},
 185
 186     {"xx:c:\\foo\\bar", "xx:c:\\foo\\bar", S_FALSE}
 187 };
 188
 189 struct {
 190     char *url;
 191     char *path;
 192     DWORD ret;
 193 } TEST_PATHFROMURL[] = {
 194     {"file:///c:/foo/ba%5Cr", "c:\\foo\\ba\\r", S_OK},
 195     {"file:///c:/foo/../ba%5Cr", "c:\\foo\\..\\ba\\r", S_OK},
 196     {"file:///host/c:/foo/bar", "\\host\\c:\\foo\\bar", S_OK},
 197     {"file://host/c:/foo/bar", "\\\\hostc:\\foo\\bar", S_OK},
 198     {"file://host/c:/foo/bar", "\\\\hostc:\\foo\\bar", S_OK},
 199     {"file:\\\\host\\c:\\foo\\bar", "\\\\hostc:\\foo\\bar", S_OK},
 200     {"file:\\\\host\\ca\\foo\\bar", "\\\\host\\ca\\foo\\bar", S_OK},
 201     {"file:\\\\host\\c|\\foo\\bar", "\\\\hostc|\\foo\\bar", S_OK},
 202     {"file:\\%5Chost\\c:\\foo\\bar", "\\\\host\\c:\\foo\\bar", S_OK},
 203     {"file:\\\\host\\cx:\\foo\\bar", "\\\\host\\cx:\\foo\\bar", S_OK},
 204     {"file://c:/foo/bar", "c:\\foo\\bar", S_OK},
 205     {"file://c:/d:/foo/bar", "c:\\d:\\foo\\bar", S_OK},
 206     {"file://c|/d|/foo/bar", "c:\\d|\\foo\\bar", S_OK},
 207     {"file://host/foo/bar", "\\\\host\\foo\\bar", S_OK},
 208     {"file:/foo/bar", "\\foo\\bar", S_OK},
 209     {"file:/foo/bar/", "\\foo\\bar\\", S_OK},
 210     {"file:foo/bar", "foo\\bar", S_OK},
 211     {"file:c:/foo/bar", "c:\\foo\\bar", S_OK},
 212     {"file:c|/foo/bar", "c:\\foo\\bar", S_OK},
 213     {"file:cx|/foo/bar", "cx|\\foo\\bar", S_OK},
 214     {"file:////c:/foo/bar", "c:\\foo\\bar", S_OK},
 215
 216     {"c:\\foo\\bar", NULL, E_INVALIDARG},
 217     {"foo/bar", NULL, E_INVALIDARG},
 218     {"http://foo/bar", NULL, E_INVALIDARG},
 219
 220 };
 221
 222 struct {
 223     char *url;
 224     char *expect;
 225 } TEST_URL_UNESCAPE[] = {
 226     {"file://foo/bar", "file://foo/bar"},
 227     {"file://fo%20o%5Ca/bar", "file://fo o\\a/bar"}
 228 };
 229
 230
 231 struct {
 232     char *path;
 233     BOOL expect;
 234 } TEST_PATH_IS_URL[] = {
 235     {"http://foo/bar", TRUE},
 236     {"c:\\foo\\bar", FALSE},
 237     {"foo://foo/bar", TRUE},
 238     {"foo\\bar", FALSE}
 239 };
 240
 241 static LPWSTR GetWideString(const char* szString)
 242 {
 243   LPWSTR wszString = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
 244                                          (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
 245
 246   MultiByteToWideChar(0, 0, szString, -1, wszString, INTERNET_MAX_URL_LENGTH);
 247
 248   return wszString;
 249 }
 250
 251 static void FreeWideString(LPWSTR wszString)
 252 {
 253    HeapFree(GetProcessHeap(), 0, wszString);
 254 }
 255
 256 static void hash_url(const char* szUrl)
 257 {
 258   LPCSTR szTestUrl = szUrl;
 259   LPWSTR wszTestUrl = GetWideString(szTestUrl);
 260
 261   DWORD cbSize = sizeof(DWORD);
 262   DWORD dwHash1, dwHash2;
 263   ok(UrlHashA(szTestUrl, (LPBYTE)&dwHash1, cbSize) == S_OK, "UrlHashA didn't return S_OK\n");
 264   ok(UrlHashW(wszTestUrl, (LPBYTE)&dwHash2, cbSize) == S_OK, "UrlHashW didn't return S_OK\n");
 265
 266   FreeWideString(wszTestUrl);
 267
 268   ok(dwHash1 == dwHash2, "Hashes didn't compare\n");
 269 }
 270
 271 static void test_UrlHash(void)
 272 {
 273   hash_url(TEST_URL_1);
 274   hash_url(TEST_URL_2);
 275   hash_url(TEST_URL_3);
 276 }
 277
 278 static void test_url_part(const char* szUrl, DWORD dwPart, DWORD dwFlags, const char* szExpected)
 279 {
 280   CHAR szPart[INTERNET_MAX_URL_LENGTH];
 281   WCHAR wszPart[INTERNET_MAX_URL_LENGTH];
 282   LPWSTR wszUrl = GetWideString(szUrl);
 283   LPWSTR wszConvertedPart;
 284
 285   DWORD dwSize;
 286
 287   dwSize = INTERNET_MAX_URL_LENGTH;
 288   ok( UrlGetPartA(szUrl, szPart, &dwSize, dwPart, dwFlags) == S_OK, "UrlGetPartA for \"%s\" part 0x%08lx didn't return S_OK but \"%s\"\n", szUrl, dwPart, szPart);
 289   dwSize = INTERNET_MAX_URL_LENGTH;
 290   ok( UrlGetPartW(wszUrl, wszPart, &dwSize, dwPart, dwFlags) == S_OK, "UrlGetPartW didn't return S_OK\n" );
 291
 292   wszConvertedPart = GetWideString(szPart);
 293
 294   ok(strcmpW(wszPart,wszConvertedPart)==0, "Strings didn't match between ascii and unicode UrlGetPart!\n");
 295
 296   FreeWideString(wszUrl);
 297   FreeWideString(wszConvertedPart);
 298
 299   /* Note that v6.0 and later don't return '?' with the query */
 300   ok(strcmp(szPart,szExpected)==0 ||
 301      (*szExpected=='?' && !strcmp(szPart,szExpected+1)),
 302          "Expected %s, but got %s\n", szExpected, szPart);
 303 }
 304
 305 static void test_UrlGetPart(void)
 306 {
 307   test_url_part(TEST_URL_3, URL_PART_HOSTNAME, 0, "localhost");
 308   test_url_part(TEST_URL_3, URL_PART_PORT, 0, "21");
 309   test_url_part(TEST_URL_3, URL_PART_USERNAME, 0, "foo");
 310   test_url_part(TEST_URL_3, URL_PART_PASSWORD, 0, "bar");
 311   test_url_part(TEST_URL_3, URL_PART_SCHEME, 0, "http");
 312   test_url_part(TEST_URL_3, URL_PART_QUERY, 0, "?query=x&return=y");
 313 }
 314
 315 static void test_url_escape(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 316 {
 317     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 318     DWORD dwEscaped;
 319     WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
 320     WCHAR *urlW, *expected_urlW;
 321     dwEscaped=INTERNET_MAX_URL_LENGTH;
 322
 323     ok(UrlEscapeA(szUrl, szReturnUrl, &dwEscaped, dwFlags) == dwExpectReturn, "UrlEscapeA didn't return 0x%08lx from \"%s\"\n", dwExpectReturn, szUrl);
 324     ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected \"%s\", but got \"%s\" from \"%s\"\n", szExpectUrl, szReturnUrl, szUrl);
 325
 326     dwEscaped = INTERNET_MAX_URL_LENGTH;
 327     urlW = GetWideString(szUrl);
 328     expected_urlW = GetWideString(szExpectUrl);
 329     ok(UrlEscapeW(urlW, ret_urlW, &dwEscaped, dwFlags) == dwExpectReturn, "UrlEscapeW didn't return 0x%08lx from \"%s\"\n", dwExpectReturn, szUrl);
 330     WideCharToMultiByte(CP_ACP,0,ret_urlW,-1,szReturnUrl,INTERNET_MAX_URL_LENGTH,0,0);
 331     ok(strcmpW(ret_urlW, expected_urlW)==0, "Expected \"%s\", but got \"%s\" from \"%s\" flags %08lx\n", szExpectUrl, szReturnUrl, szUrl, dwFlags);
 332     FreeWideString(urlW);
 333     FreeWideString(expected_urlW);
 334
 335 }
 336
 337 static void test_url_canonicalize(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 338 {
 339     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 340     WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
 341     LPWSTR wszUrl = GetWideString(szUrl);
 342     LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
 343     LPWSTR wszConvertedUrl;
 344
 345     DWORD dwSize;
 346
 347     dwSize = INTERNET_MAX_URL_LENGTH;
 348     ok(UrlCanonicalizeA(szUrl, szReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeA didn't return 0x%08lx\n", dwExpectReturn);
 349     ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected %s, but got %s\n", szExpectUrl, szReturnUrl);
 350
 351     dwSize = INTERNET_MAX_URL_LENGTH;
 352     ok(UrlCanonicalizeW(wszUrl, wszReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeW didn't return 0x%08lx\n", dwExpectReturn);
 353     wszConvertedUrl = GetWideString(szReturnUrl);
 354     ok(strcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCanonicalize!\n");
 355     FreeWideString(wszConvertedUrl);
 356
 357
 358     FreeWideString(wszUrl);
 359     FreeWideString(wszExpectUrl);
 360 }
 361
 362
 363 static void test_UrlEscape(void)
 364 {
 365     unsigned int i;
 366     for(i=0; i<sizeof(TEST_ESCAPE)/sizeof(TEST_ESCAPE[0]); i++) {
 367         test_url_escape(TEST_ESCAPE[i].url, TEST_ESCAPE[i].flags,
 368                               TEST_ESCAPE[i].expectret, TEST_ESCAPE[i].expecturl);
 369     }
 370 }
 371
 372 static void test_UrlCanonicalize(void)
 373 {
 374     unsigned int i;
 375     for(i=0; i<sizeof(TEST_CANONICALIZE)/sizeof(TEST_CANONICALIZE[0]); i++) {
 376         test_url_canonicalize(TEST_CANONICALIZE[i].url, TEST_CANONICALIZE[i].flags,
 377                               TEST_CANONICALIZE[i].expectret, TEST_CANONICALIZE[i].expecturl);
 378     }
 379 }
 380
 381 static void test_url_combine(const char *szUrl1, const char *szUrl2, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 382 {
 383     HRESULT hr;
 384     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 385     WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
 386     LPWSTR wszUrl1 = GetWideString(szUrl1);
 387     LPWSTR wszUrl2 = GetWideString(szUrl2);
 388     LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
 389     LPWSTR wszConvertedUrl;
 390
 391     DWORD dwSize;
 392     DWORD dwExpectLen = lstrlen(szExpectUrl);
 393
 394     hr = UrlCombineA(szUrl1, szUrl2, NULL, NULL, dwFlags);
 395     ok(hr == E_INVALIDARG, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_INVALIDARG);
 396
 397     dwSize = 0;
 398     hr = UrlCombineA(szUrl1, szUrl2, NULL, &dwSize, dwFlags);
 399     ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 400     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 401
 402     dwSize--;
 403     hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
 404     ok(hr == E_POINTER, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 405     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 406
 407     hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
 408     ok(hr == dwExpectReturn, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, dwExpectReturn);
 409     ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen);
 410     if(SUCCEEDED(hr)) {
 411         ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected %s, but got %s\n", szExpectUrl, szReturnUrl);
 412     }
 413
 414     dwSize = 0;
 415     hr = UrlCombineW(wszUrl1, wszUrl2, NULL, &dwSize, dwFlags);
 416     ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 417     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 418
 419     dwSize--;
 420     hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
 421     ok(hr == E_POINTER, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 422     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 423
 424     hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
 425     ok(hr == dwExpectReturn, "UrlCombineW returned 0x%08lx, expected 0x%08lx\n", hr, dwExpectReturn);
 426     ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen);
 427     if(SUCCEEDED(hr)) {
 428         wszConvertedUrl = GetWideString(szReturnUrl);
 429         ok(strcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCombine!\n");
 430         FreeWideString(wszConvertedUrl);
 431     }
 432
 433     FreeWideString(wszUrl1);
 434     FreeWideString(wszUrl2);
 435     FreeWideString(wszExpectUrl);
 436 }
 437
 438 static void test_UrlCombine(void)
 439 {
 440     unsigned int i;
 441     for(i=0; i<sizeof(TEST_COMBINE)/sizeof(TEST_COMBINE[0]); i++) {
 442         test_url_combine(TEST_COMBINE[i].url1, TEST_COMBINE[i].url2, TEST_COMBINE[i].flags,
 443                          TEST_COMBINE[i].expectret, TEST_COMBINE[i].expecturl);
 444     }
 445 }
 446
 447 static void test_UrlCreateFromPath(void)
 448 {
 449     int i;
 450     char ret_url[INTERNET_MAX_URL_LENGTH];
 451     DWORD len, ret;
 452     WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
 453     WCHAR *pathW, *urlW;
 454
 455     for(i = 0; i < sizeof(TEST_URLFROMPATH) / sizeof(TEST_URLFROMPATH[0]); i++) {
 456         len = INTERNET_MAX_URL_LENGTH;
 457         ret = UrlCreateFromPathA(TEST_URLFROMPATH[i].path, ret_url, &len, 0);
 458         ok(ret == TEST_URLFROMPATH[i].ret, "ret %08lx from path %s\n", ret, TEST_URLFROMPATH[i].path);
 459         ok(!lstrcmpi(ret_url, TEST_URLFROMPATH[i].url), "url %s from path %s\n", ret_url, TEST_URLFROMPATH[i].path);
 460         ok(len == strlen(ret_url), "ret len %ld from path %s\n", len, TEST_URLFROMPATH[i].path);
 461
 462         len = INTERNET_MAX_URL_LENGTH;
 463         pathW = GetWideString(TEST_URLFROMPATH[i].path);
 464         urlW = GetWideString(TEST_URLFROMPATH[i].url);
 465         ret = UrlCreateFromPathW(pathW, ret_urlW, &len, 0);
 466         WideCharToMultiByte(CP_ACP, 0, ret_urlW, -1, ret_url, sizeof(ret_url),0,0);
 467         ok(ret == TEST_URLFROMPATH[i].ret, "ret %08lx from path L\"%s\"\n", ret, TEST_URLFROMPATH[i].path);
 468         ok(!lstrcmpiW(ret_urlW, urlW), "got %s expected %s from path L\"%s\"\n", ret_url, TEST_URLFROMPATH[i].url, TEST_URLFROMPATH[i].path);
 469         ok(len == strlenW(ret_urlW), "ret len %ld from path L\"%s\"\n", len, TEST_URLFROMPATH[i].path);
 470         FreeWideString(urlW);
 471         FreeWideString(pathW);
 472     }
 473 }
 474
 475 static void test_UrlUnescape(void)
 476 {
 477     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 478     WCHAR ret_urlW[INTERNET_MAX_URL_LENGTH];
 479     WCHAR *urlW, *expected_urlW;
 480     DWORD dwEscaped;
 481     unsigned int i;
 482
 483     for(i=0; i<sizeof(TEST_URL_UNESCAPE)/sizeof(TEST_URL_UNESCAPE[0]); i++) {
 484         dwEscaped=INTERNET_MAX_URL_LENGTH;
 485         ok(UrlUnescapeA(TEST_URL_UNESCAPE[i].url, szReturnUrl, &dwEscaped, 0) == S_OK, "UrlEscapeA didn't return 0x%08lx from \"%s\"\n", S_OK, TEST_URL_UNESCAPE[i].url);
 486         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);
 487
 488         dwEscaped = INTERNET_MAX_URL_LENGTH;
 489         urlW = GetWideString(TEST_URL_UNESCAPE[i].url);
 490         expected_urlW = GetWideString(TEST_URL_UNESCAPE[i].expect);
 491         ok(UrlUnescapeW(urlW, ret_urlW, &dwEscaped, 0) == S_OK, "UrlEscapeW didn't return 0x%08lx from \"%s\"\n", S_OK, TEST_URL_UNESCAPE[i].url);
 492         WideCharToMultiByte(CP_ACP,0,ret_urlW,-1,szReturnUrl,INTERNET_MAX_URL_LENGTH,0,0);
 493         ok(strcmpW(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);
 494         FreeWideString(urlW);
 495         FreeWideString(expected_urlW);
 496     }
 497
 498 }
 499
 500 static void test_PathSearchAndQualify(void)
 501 {
 502     WCHAR path1[] = {'c',':','\\','f','o','o',0};
 503     WCHAR expect1[] = {'c',':','\\','f','o','o',0};
 504     WCHAR path2[] = {'c',':','f','o','o',0};
 505     WCHAR c_drive[] = {'c',':',0};
 506     WCHAR foo[] = {'f','o','o',0};
 507     WCHAR path3[] = {'\\','f','o','o',0};
 508     WCHAR winini[] = {'w','i','n','.','i','n','i',0};
 509     WCHAR out[MAX_PATH];
 510     WCHAR cur_dir[MAX_PATH];
 511     WCHAR dot[] = {'.',0};
 512
 513     /* c:\foo */
 514     ok(PathSearchAndQualifyW(path1, out, MAX_PATH) != 0,
 515        "PathSearchAndQualify rets 0\n");
 516     ok(!lstrcmpiW(out, expect1), "strings don't match\n");
 517
 518     /* c:foo */
 519     ok(PathSearchAndQualifyW(path2, out, MAX_PATH) != 0,
 520        "PathSearchAndQualify rets 0\n");
 521     GetFullPathNameW(c_drive, MAX_PATH, cur_dir, NULL);
 522     PathAddBackslashW(cur_dir);
 523     strcatW(cur_dir, foo);
 524     ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
 525
 526     /* foo */
 527     ok(PathSearchAndQualifyW(foo, out, MAX_PATH) != 0,
 528        "PathSearchAndQualify rets 0\n");
 529     GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
 530     PathAddBackslashW(cur_dir);
 531     strcatW(cur_dir, foo);
 532     ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
 533
 534     /* \foo */
 535     ok(PathSearchAndQualifyW(path3, out, MAX_PATH) != 0,
 536        "PathSearchAndQualify rets 0\n");
 537     GetFullPathNameW(dot, MAX_PATH, cur_dir, NULL);
 538     strcpyW(cur_dir + 2, path3);
 539     ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
 540
 541     /* win.ini */
 542     ok(PathSearchAndQualifyW(winini, out, MAX_PATH) != 0,
 543        "PathSearchAndQualify rets 0\n");
 544     if(!SearchPathW(NULL, winini, NULL, MAX_PATH, cur_dir, NULL))
 545         GetFullPathNameW(winini, MAX_PATH, cur_dir, NULL);
 546     ok(!lstrcmpiW(out, cur_dir), "strings don't match\n");
 547
 548 }
 549
 550 static void test_PathCreateFromUrl(void)
 551 {
 552     int i;
 553     char ret_path[INTERNET_MAX_URL_LENGTH];
 554     DWORD len, ret;
 555     WCHAR ret_pathW[INTERNET_MAX_URL_LENGTH];
 556     WCHAR *pathW, *urlW;
 557
 558     for(i = 0; i < sizeof(TEST_PATHFROMURL) / sizeof(TEST_PATHFROMURL[0]); i++) {
 559         len = INTERNET_MAX_URL_LENGTH;
 560         ret = PathCreateFromUrlA(TEST_PATHFROMURL[i].url, ret_path, &len, 0);
 561         ok(ret == TEST_PATHFROMURL[i].ret, "ret %08lx from url %s\n", ret, TEST_PATHFROMURL[i].url);
 562         if(TEST_PATHFROMURL[i].path) {
 563            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);
 564            ok(len == strlen(ret_path), "ret len %ld from url %s\n", len, TEST_PATHFROMURL[i].url);
 565         }
 566         len = INTERNET_MAX_URL_LENGTH;
 567         pathW = GetWideString(TEST_PATHFROMURL[i].path);
 568         urlW = GetWideString(TEST_PATHFROMURL[i].url);
 569         ret = PathCreateFromUrlW(urlW, ret_pathW, &len, 0);
 570         WideCharToMultiByte(CP_ACP, 0, ret_pathW, -1, ret_path, sizeof(ret_path),0,0);
 571         ok(ret == TEST_PATHFROMURL[i].ret, "ret %08lx from url L\"%s\"\n", ret, TEST_PATHFROMURL[i].url);
 572         if(TEST_PATHFROMURL[i].path) {
 573             ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L\"%s\"\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url);
 574             ok(len == strlenW(ret_pathW), "ret len %ld from url L\"%s\"\n", len, TEST_PATHFROMURL[i].url);
 575         }
 576         FreeWideString(urlW);
 577         FreeWideString(pathW);
 578     }
 579 }
 580
 581
 582 static void test_PathIsUrl(void)
 583 {
 584     int i;
 585     BOOL ret;
 586
 587     for(i = 0; i < sizeof(TEST_PATH_IS_URL)/sizeof(TEST_PATH_IS_URL[0]); i++) {
 588         ret = PathIsURLA(TEST_PATH_IS_URL[i].path);
 589         ok(ret == TEST_PATH_IS_URL[i].expect,
 590            "returned %d from path %s, expected %d\n", ret, TEST_PATH_IS_URL[i].path,
 591            TEST_PATH_IS_URL[i].expect);
 592     }
 593 }
 594
 595 START_TEST(path)
 596 {
 597   test_UrlHash();
 598   test_UrlGetPart();
 599   test_UrlCanonicalize();
 600   test_UrlEscape();
 601   test_UrlCombine();
 602   test_UrlCreateFromPath();
 603   test_UrlUnescape();
 604
 605   test_PathSearchAndQualify();
 606   test_PathCreateFromUrl();
 607   test_PathIsUrl();
 608 }