git.oblomov.eu Git - wine/blob - 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
  81 typedef struct _TEST_URL_COMBINE {
  82     char *url1;
  83     char *url2;
  84     DWORD flags;
  85     HRESULT expectret;
  86     char *expecturl;
  87 } TEST_URL_COMBINE;
  88
  89 const TEST_URL_COMBINE TEST_COMBINE[] = {
  90     {"http://www.winehq.org/tests", "tests1", 0, S_OK, "http://www.winehq.org/tests1"},
  91     /*FIXME {"http://www.winehq.org/tests", "../tests2", 0, S_OK, "http://www.winehq.org/tests2"},*/
  92     {"http://www.winehq.org/tests/", "../tests3", 0, S_OK, "http://www.winehq.org/tests3"},
  93     {"http://www.winehq.org/tests/../tests", "tests4", 0, S_OK, "http://www.winehq.org/tests4"},
  94     {"http://www.winehq.org/tests/../tests/", "tests5", 0, S_OK, "http://www.winehq.org/tests/tests5"},
  95     {"http://www.winehq.org/tests/../tests/", "/tests6/..", 0, S_OK, "http://www.winehq.org/"},
  96     {"http://www.winehq.org/tests/../tests/..", "tests7/..", 0, S_OK, "http://www.winehq.org/"},
  97     {"http://www.winehq.org/tests/?query=x&return=y", "tests8", 0, S_OK, "http://www.winehq.org/tests/tests8"},
  98     {"http://www.winehq.org/tests/#example", "tests9", 0, S_OK, "http://www.winehq.org/tests/tests9"},
  99     {"http://www.winehq.org/tests/../tests/", "/tests10/..", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests10/.."},
 100     {"http://www.winehq.org/tests/../", "tests11", URL_DONT_SIMPLIFY, S_OK, "http://www.winehq.org/tests/../tests11"},
 101 };
 102
 103 static LPWSTR GetWideString(const char* szString)
 104 {
 105   LPWSTR wszString = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
 106                                          (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
 107
 108   MultiByteToWideChar(0, 0, szString, -1, wszString, INTERNET_MAX_URL_LENGTH);
 109
 110   return wszString;
 111 }
 112
 113 static void FreeWideString(LPWSTR wszString)
 114 {
 115    HeapFree(GetProcessHeap(), 0, wszString);
 116 }
 117
 118 static void hash_url(const char* szUrl)
 119 {
 120   LPCSTR szTestUrl = szUrl;
 121   LPWSTR wszTestUrl = GetWideString(szTestUrl);
 122
 123   DWORD cbSize = sizeof(DWORD);
 124   DWORD dwHash1, dwHash2;
 125   ok(UrlHashA(szTestUrl, (LPBYTE)&dwHash1, cbSize) == S_OK, "UrlHashA didn't return S_OK\n");
 126   ok(UrlHashW(wszTestUrl, (LPBYTE)&dwHash2, cbSize) == S_OK, "UrlHashW didn't return S_OK\n");
 127
 128   FreeWideString(wszTestUrl);
 129
 130   ok(dwHash1 == dwHash2, "Hashes didn't compare\n");
 131 }
 132
 133 static void test_UrlHash(void)
 134 {
 135   hash_url(TEST_URL_1);
 136   hash_url(TEST_URL_2);
 137   hash_url(TEST_URL_3);
 138 }
 139
 140 static void test_url_part(const char* szUrl, DWORD dwPart, DWORD dwFlags, const char* szExpected)
 141 {
 142   CHAR szPart[INTERNET_MAX_URL_LENGTH];
 143   WCHAR wszPart[INTERNET_MAX_URL_LENGTH];
 144   LPWSTR wszUrl = GetWideString(szUrl);
 145   LPWSTR wszConvertedPart;
 146
 147   DWORD dwSize;
 148
 149   dwSize = INTERNET_MAX_URL_LENGTH;
 150   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);
 151   dwSize = INTERNET_MAX_URL_LENGTH;
 152   ok( UrlGetPartW(wszUrl, wszPart, &dwSize, dwPart, dwFlags) == S_OK, "UrlGetPartW didn't return S_OK\n" );
 153
 154   wszConvertedPart = GetWideString(szPart);
 155
 156   ok(strcmpW(wszPart,wszConvertedPart)==0, "Strings didn't match between ascii and unicode UrlGetPart!\n");
 157
 158   FreeWideString(wszUrl);
 159   FreeWideString(wszConvertedPart);
 160
 161   /* Note that v6.0 and later don't return '?' with the query */
 162   ok(strcmp(szPart,szExpected)==0 ||
 163      (*szExpected=='?' && !strcmp(szPart,szExpected+1)),
 164          "Expected %s, but got %s\n", szExpected, szPart);
 165 }
 166
 167 static void test_UrlGetPart(void)
 168 {
 169   test_url_part(TEST_URL_3, URL_PART_HOSTNAME, 0, "localhost");
 170   test_url_part(TEST_URL_3, URL_PART_PORT, 0, "21");
 171   test_url_part(TEST_URL_3, URL_PART_USERNAME, 0, "foo");
 172   test_url_part(TEST_URL_3, URL_PART_PASSWORD, 0, "bar");
 173   test_url_part(TEST_URL_3, URL_PART_SCHEME, 0, "http");
 174   test_url_part(TEST_URL_3, URL_PART_QUERY, 0, "?query=x&return=y");
 175 }
 176
 177 static void test_url_escape(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 178 {
 179     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 180     DWORD dwEscaped;
 181
 182     dwEscaped=INTERNET_MAX_URL_LENGTH;
 183     ok(UrlEscapeA(szUrl, szReturnUrl, &dwEscaped, dwFlags) == dwExpectReturn, "UrlEscapeA didn't return 0x%08lx\n", dwExpectReturn);
 184     ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected \"%s\", but got \"%s\"\n", szExpectUrl, szReturnUrl);
 185 }
 186 static void test_url_canonicalize(const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 187 {
 188     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 189     WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
 190     LPWSTR wszUrl = GetWideString(szUrl);
 191     LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
 192     LPWSTR wszConvertedUrl;
 193
 194     DWORD dwSize;
 195
 196     dwSize = INTERNET_MAX_URL_LENGTH;
 197     ok(UrlCanonicalizeA(szUrl, szReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeA didn't return 0x%08lx\n", dwExpectReturn);
 198     ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected %s, but got %s\n", szExpectUrl, szReturnUrl);
 199
 200     dwSize = INTERNET_MAX_URL_LENGTH;
 201     ok(UrlCanonicalizeW(wszUrl, wszReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeW didn't return 0x%08lx\n", dwExpectReturn);
 202     wszConvertedUrl = GetWideString(szReturnUrl);
 203     ok(strcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCanonicalize!\n");
 204     FreeWideString(wszConvertedUrl);
 205
 206
 207     FreeWideString(wszUrl);
 208     FreeWideString(wszExpectUrl);
 209 }
 210
 211
 212 static void test_UrlEscape(void)
 213 {
 214     unsigned int i;
 215     for(i=0; i<sizeof(TEST_ESCAPE)/sizeof(TEST_ESCAPE[0]); i++) {
 216         test_url_escape(TEST_ESCAPE[i].url, TEST_ESCAPE[i].flags,
 217                               TEST_ESCAPE[i].expectret, TEST_ESCAPE[i].expecturl);
 218     }
 219 }
 220
 221 static void test_UrlCanonicalize(void)
 222 {
 223     unsigned int i;
 224     for(i=0; i<sizeof(TEST_CANONICALIZE)/sizeof(TEST_CANONICALIZE[0]); i++) {
 225         test_url_canonicalize(TEST_CANONICALIZE[i].url, TEST_CANONICALIZE[i].flags,
 226                               TEST_CANONICALIZE[i].expectret, TEST_CANONICALIZE[i].expecturl);
 227     }
 228 }
 229
 230 static void test_url_combine(const char *szUrl1, const char *szUrl2, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl)
 231 {
 232     HRESULT hr;
 233     CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
 234     WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
 235     LPWSTR wszUrl1 = GetWideString(szUrl1);
 236     LPWSTR wszUrl2 = GetWideString(szUrl2);
 237     LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
 238     LPWSTR wszConvertedUrl;
 239
 240     DWORD dwSize;
 241     DWORD dwExpectLen = lstrlen(szExpectUrl);
 242
 243     hr = UrlCombineA(szUrl1, szUrl2, NULL, NULL, dwFlags);
 244     ok(hr == E_INVALIDARG, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_INVALIDARG);
 245
 246     dwSize = 0;
 247     hr = UrlCombineA(szUrl1, szUrl2, NULL, &dwSize, dwFlags);
 248     ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 249     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 250
 251     dwSize--;
 252     hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
 253     ok(hr == E_POINTER, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 254     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 255
 256     hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags);
 257     ok(hr == dwExpectReturn, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, dwExpectReturn);
 258     ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen);
 259     if(SUCCEEDED(hr)) {
 260         ok(strcmp(szReturnUrl,szExpectUrl)==0, "Expected %s, but got %s\n", szExpectUrl, szReturnUrl);
 261     }
 262
 263     dwSize = 0;
 264     hr = UrlCombineW(wszUrl1, wszUrl2, NULL, &dwSize, dwFlags);
 265     ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 266     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 267
 268     dwSize--;
 269     hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
 270     ok(hr == E_POINTER, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER);
 271     ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
 272
 273     hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags);
 274     ok(hr == dwExpectReturn, "UrlCombineW returned 0x%08lx, expected 0x%08lx\n", hr, dwExpectReturn);
 275     ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen);
 276     if(SUCCEEDED(hr)) {
 277         wszConvertedUrl = GetWideString(szReturnUrl);
 278         ok(strcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCombine!\n");
 279         FreeWideString(wszConvertedUrl);
 280     }
 281
 282     FreeWideString(wszUrl1);
 283     FreeWideString(wszUrl2);
 284     FreeWideString(wszExpectUrl);
 285 }
 286
 287 static void test_UrlCombine(void)
 288 {
 289     unsigned int i;
 290     for(i=0; i<sizeof(TEST_COMBINE)/sizeof(TEST_COMBINE[0]); i++) {
 291         test_url_combine(TEST_COMBINE[i].url1, TEST_COMBINE[i].url2, TEST_COMBINE[i].flags,
 292                          TEST_COMBINE[i].expectret, TEST_COMBINE[i].expecturl);
 293     }
 294 }
 295
 296 START_TEST(path)
 297 {
 298   test_UrlHash();
 299   test_UrlGetPart();
 300   test_UrlCanonicalize();
 301   test_UrlEscape();
 302   test_UrlCombine();
 303 }