git.oblomov.eu Git - wine/blob - dlls/urlmon/tests/url.c

   1 /*
   2  * UrlMon URL tests
   3  *
   4  * Copyright 2004 Kevin Koltzau
   5  * Copyright 2004 Jacek Caban
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "urlmon.h"
  29 #include "wininet.h"
  30
  31 #include "wine/test.h"
  32
  33 #define DEFINE_EXPECT(func) \
  34     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  35
  36 #define SET_EXPECT(func) \
  37     expect_ ## func = TRUE
  38
  39 #define CHECK_EXPECT(func) \
  40     do { \
  41         ok(expect_ ##func, "unexpected call " #func "\n"); \
  42         expect_ ## func = FALSE; \
  43         called_ ## func = TRUE; \
  44     }while(0)
  45
  46 #define CHECK_EXPECT2(func) \
  47     do { \
  48         ok(expect_ ##func, "unexpected call " #func "\n"); \
  49         called_ ## func = TRUE; \
  50     }while(0)
  51
  52 #define CHECK_CALLED(func) \
  53     do { \
  54         ok(called_ ## func, "expected " #func "\n"); \
  55         expect_ ## func = called_ ## func = FALSE; \
  56     }while(0)
  57
  58 DEFINE_EXPECT(GetBindInfo);
  59 DEFINE_EXPECT(OnStartBinding);
  60 DEFINE_EXPECT(OnProgress_FINDINGRESOURCE);
  61 DEFINE_EXPECT(OnProgress_CONNECTING);
  62 DEFINE_EXPECT(OnProgress_SENDINGREQUEST);
  63 DEFINE_EXPECT(OnProgress_MIMETYPEAVAILABLE);
  64 DEFINE_EXPECT(OnProgress_BEGINDOWNLOADDATA);
  65 DEFINE_EXPECT(OnProgress_DOWNLOADINGDATA);
  66 DEFINE_EXPECT(OnProgress_ENDDOWNLOADDATA);
  67 DEFINE_EXPECT(OnStopBinding);
  68 DEFINE_EXPECT(OnDataAvailable);
  69 DEFINE_EXPECT(Start);
  70 DEFINE_EXPECT(Read);
  71 DEFINE_EXPECT(LockRequest);
  72 DEFINE_EXPECT(Terminate);
  73 DEFINE_EXPECT(UnlockRequest);
  74
  75 static const WCHAR TEST_URL_1[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/','\0'};
  76 static const WCHAR TEST_PART_URL_1[] = {'/','t','e','s','t','/','\0'};
  77
  78 static const WCHAR WINE_ABOUT_URL[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
  79                                        'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0};
  80 static const WCHAR ABOUT_BLANK[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
  81 static WCHAR INDEX_HTML[MAX_PATH];
  82
  83 static const WCHAR wszIndexHtml[] = {'i','n','d','e','x','.','h','t','m','l',0};
  84
  85 static BOOL stopped_binding = FALSE, emulate_protocol = FALSE;
  86 static DWORD read = 0;
  87
  88 static const LPCWSTR urls[] = {
  89     WINE_ABOUT_URL,
  90     ABOUT_BLANK,
  91     INDEX_HTML
  92 };
  93
  94 static enum {
  95     HTTP_TEST,
  96     ABOUT_TEST,
  97     FILE_TEST
  98 } test_protocol;
  99
 100 static void test_CreateURLMoniker(LPCWSTR url1, LPCWSTR url2)
 101 {
 102     HRESULT hr;
 103     IMoniker *mon1 = NULL;
 104     IMoniker *mon2 = NULL;
 105
 106     hr = CreateURLMoniker(NULL, url1, &mon1);
 107     ok(SUCCEEDED(hr), "failed to create moniker: 0x%08lx\n", hr);
 108     if(SUCCEEDED(hr)) {
 109         hr = CreateURLMoniker(mon1, url2, &mon2);
 110         ok(SUCCEEDED(hr), "failed to create moniker: 0x%08lx\n", hr);
 111     }
 112     if(mon1) IMoniker_Release(mon1);
 113     if(mon2) IMoniker_Release(mon2);
 114 }
 115
 116 static void test_create(void)
 117 {
 118     test_CreateURLMoniker(TEST_URL_1, TEST_PART_URL_1);
 119 }
 120
 121 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 122 {
 123     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
 124         *ppv = iface;
 125         return S_OK;
 126     }
 127
 128     *ppv = NULL;
 129     return E_NOINTERFACE;
 130 }
 131
 132 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
 133 {
 134     return 2;
 135 }
 136
 137 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
 138 {
 139     return 1;
 140 }
 141
 142 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 143         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 144         DWORD grfPI, DWORD dwReserved)
 145 {
 146     BINDINFO bindinfo, bi = {sizeof(bi), 0};
 147     DWORD bindf, bscf = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION;
 148     WCHAR null_char = 0;
 149     HRESULT hres;
 150
 151     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 152
 153     CHECK_EXPECT(Start);
 154
 155     read = 0;
 156
 157     ok(szUrl && !lstrcmpW(szUrl, urls[test_protocol]), "wrong url\n");
 158     ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
 159     ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
 160     ok(grfPI == 0, "grfPI=%ld, expected 0\n", grfPI);
 161     ok(dwReserved == 0, "dwReserved=%ld, expected 0\n", dwReserved);
 162
 163     memset(&bindinfo, 0, sizeof(bindinfo));
 164     bindinfo.cbSize = sizeof(bindinfo);
 165     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
 166     ok(hres == S_OK, "GetBindInfo failed: %08lx\n", hres);
 167
 168     if(test_protocol == FILE_TEST) {
 169         ok(bindf == (BINDF_ASYNCHRONOUS|BINDF_ASYNCSTORAGE|BINDF_PULLDATA
 170                      |BINDF_FROMURLMON),
 171            "bindf=%08lx\n", bindf);
 172     }else {
 173         ok(bindf == (BINDF_ASYNCHRONOUS|BINDF_ASYNCSTORAGE|BINDF_PULLDATA|
 174                      BINDF_FROMURLMON|BINDF_NEEDFILE),
 175            "bindf=%08lx\n", bindf);
 176     }
 177
 178     ok(!memcmp(&bindinfo, &bi, sizeof(bindinfo)), "wrong bindinfo\n");
 179
 180     if(test_protocol == FILE_TEST) {
 181         SET_EXPECT(OnProgress_SENDINGREQUEST);
 182         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 183                 BINDSTATUS_SENDINGREQUEST, &null_char);
 184         ok(hres == S_OK,
 185            "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08lx\n", hres);
 186         CHECK_CALLED(OnProgress_SENDINGREQUEST);
 187
 188         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 189                 BINDSTATUS_CACHEFILENAMEAVAILABLE, &null_char);
 190         ok(hres == S_OK,
 191            "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08lx\n", hres);
 192
 193         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 194         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 195                 BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextHtml);
 196         ok(hres == S_OK,
 197            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08lx\n", hres);
 198         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 199     }else {
 200         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 201                 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 202         ok(hres == S_OK,
 203            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08lx\n", hres);
 204     }
 205
 206     if(test_protocol == ABOUT_TEST)
 207         bscf |= BSCF_DATAFULLYAVAILABLE;
 208
 209     SET_EXPECT(Read);
 210     if(test_protocol != FILE_TEST)
 211         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 212     SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 213     SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 214     SET_EXPECT(LockRequest);
 215     SET_EXPECT(OnDataAvailable);
 216     SET_EXPECT(OnStopBinding);
 217
 218     hres = IInternetProtocolSink_ReportData(pOIProtSink, bscf, 13, 13);
 219     ok(hres == S_OK, "ReportData failed: %08lx\n", hres);
 220
 221     CHECK_CALLED(Read);
 222     if(test_protocol != FILE_TEST)
 223         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 224     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 225     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 226     CHECK_CALLED(LockRequest);
 227     CHECK_CALLED(OnDataAvailable);
 228     CHECK_CALLED(OnStopBinding);
 229
 230     SET_EXPECT(Terminate);
 231     hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 232     ok(hres == S_OK, "ReportResult failed: %08lx\n", hres);
 233     CHECK_CALLED(Terminate);
 234
 235     return S_OK;
 236 }
 237
 238 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
 239         PROTOCOLDATA *pProtocolData)
 240 {
 241     ok(0, "unexpected call\n");
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 246         DWORD dwOptions)
 247 {
 248     ok(0, "unexpected call\n");
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 253 {
 254     CHECK_EXPECT(Terminate);
 255     ok(dwOptions == 0, "dwOptions=%ld, expected 0\n", dwOptions);
 256     return S_OK;
 257 }
 258
 259 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
 260 {
 261     ok(0, "unexpected call\n");
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
 266 {
 267     ok(0, "unexpected call\n");
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
 272         ULONG cb, ULONG *pcbRead)
 273 {
 274     static const char data[] = "<HTML></HTML>";
 275
 276     CHECK_EXPECT2(Read);
 277
 278     if(read) {
 279         *pcbRead = 0;
 280         return S_FALSE;
 281     }
 282
 283     ok(pv != NULL, "pv == NULL\n");
 284     ok(cb != 0, "cb == 0\n");
 285     ok(pcbRead != NULL, "pcbRead == NULL\n");
 286     if(pcbRead) {
 287         ok(*pcbRead == 0, "*pcbRead=%ld, expected 0\n", *pcbRead);
 288         *pcbRead = 13;
 289         read = 13;
 290     }
 291     if(pv)
 292         memcpy(pv, data, sizeof(data));
 293
 294     return S_OK;
 295 }
 296
 297 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
 298         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 299 {
 300     ok(0, "unexpected call\n");
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 305 {
 306     CHECK_EXPECT(LockRequest);
 307     return S_OK;
 308 }
 309
 310 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
 311 {
 312     CHECK_EXPECT(UnlockRequest);
 313     return S_OK;
 314 }
 315
 316 static const IInternetProtocolVtbl ProtocolVtbl = {
 317     Protocol_QueryInterface,
 318     Protocol_AddRef,
 319     Protocol_Release,
 320     Protocol_Start,
 321     Protocol_Continue,
 322     Protocol_Abort,
 323     Protocol_Terminate,
 324     Protocol_Suspend,
 325     Protocol_Resume,
 326     Protocol_Read,
 327     Protocol_Seek,
 328     Protocol_LockRequest,
 329     Protocol_UnlockRequest
 330 };
 331
 332 static IInternetProtocol Protocol = { &ProtocolVtbl };
 333
 334 static HRESULT WINAPI statusclb_QueryInterface(IBindStatusCallback *iface, REFIID riid, void **ppv)
 335 {
 336     if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 337         if(emulate_protocol) {
 338             *ppv = &Protocol;
 339             return S_OK;
 340         }else {
 341             return E_NOINTERFACE;
 342         }
 343     }
 344
 345     return E_NOINTERFACE;
 346 }
 347
 348 static ULONG WINAPI statusclb_AddRef(IBindStatusCallback *iface)
 349 {
 350     return 2;
 351 }
 352
 353 static ULONG WINAPI statusclb_Release(IBindStatusCallback *iface)
 354 {
 355     return 1;
 356 }
 357
 358 static HRESULT WINAPI statusclb_OnStartBinding(IBindStatusCallback *iface, DWORD dwReserved,
 359         IBinding *pib)
 360 {
 361     HRESULT hres;
 362     IMoniker *mon;
 363
 364     CHECK_EXPECT(OnStartBinding);
 365
 366     ok(pib != NULL, "pib should not be NULL\n");
 367
 368     hres = IBinding_QueryInterface(pib, &IID_IMoniker, (void**)&mon);
 369     ok(hres == E_NOINTERFACE, "IBinding should not have IMoniker interface\n");
 370     if(SUCCEEDED(hres))
 371         IMoniker_Release(mon);
 372
 373     return S_OK;
 374 }
 375
 376 static HRESULT WINAPI statusclb_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
 377 {
 378     ok(0, "unexpected call\n");
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI statusclb_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 383 {
 384     ok(0, "unexpected call\n");
 385     return E_NOTIMPL;
 386 }
 387
 388 static HRESULT WINAPI statusclb_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 389         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 390 {
 391     switch(ulStatusCode) {
 392     case BINDSTATUS_FINDINGRESOURCE:
 393         CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
 394         break;
 395     case BINDSTATUS_CONNECTING:
 396         CHECK_EXPECT(OnProgress_CONNECTING);
 397         break;
 398     case BINDSTATUS_SENDINGREQUEST:
 399         CHECK_EXPECT(OnProgress_SENDINGREQUEST);
 400         break;
 401     case BINDSTATUS_MIMETYPEAVAILABLE:
 402         CHECK_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 403         break;
 404     case BINDSTATUS_BEGINDOWNLOADDATA:
 405         CHECK_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 406         ok(szStatusText != NULL, "szStatusText == NULL\n");
 407         if(szStatusText)
 408             ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText\n");
 409         break;
 410     case BINDSTATUS_DOWNLOADINGDATA:
 411         CHECK_EXPECT2(OnProgress_DOWNLOADINGDATA);
 412         break;
 413     case BINDSTATUS_ENDDOWNLOADDATA:
 414         CHECK_EXPECT(OnProgress_ENDDOWNLOADDATA);
 415         ok(szStatusText != NULL, "szStatusText == NULL\n");
 416         if(szStatusText)
 417             ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText\n");
 418         break;
 419     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 420         ok(szStatusText != NULL, "szStatusText == NULL\n");
 421         if(szStatusText && test_protocol == FILE_TEST)
 422             ok(!lstrcmpW(INDEX_HTML+7, szStatusText), "wrong szStatusText\n");
 423         break;
 424     default:
 425         todo_wine { ok(0, "unexpexted code %ld\n", ulStatusCode); }
 426     };
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI statusclb_OnStopBinding(IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError)
 431 {
 432     CHECK_EXPECT(OnStopBinding);
 433
 434     /* ignore DNS failure */
 435     if (hresult != HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
 436     {
 437         ok(SUCCEEDED(hresult), "Download failed: %08lx\n", hresult);
 438         ok(szError == NULL, "szError should be NULL\n");
 439     }
 440     stopped_binding = TRUE;
 441
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI statusclb_GetBindInfo(IBindStatusCallback *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
 446 {
 447     DWORD cbSize;
 448
 449     CHECK_EXPECT(GetBindInfo);
 450
 451     *grfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
 452     cbSize = pbindinfo->cbSize;
 453     memset(pbindinfo, 0, cbSize);
 454     pbindinfo->cbSize = cbSize;
 455
 456     return S_OK;
 457 }
 458
 459 static HRESULT WINAPI statusclb_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
 460         DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
 461 {
 462     HRESULT hres;
 463     DWORD readed;
 464     BYTE buf[512];
 465
 466     CHECK_EXPECT2(OnDataAvailable);
 467
 468 #if 0 /* Uncomment after removing BindToStorage hack. */
 469     ok(pformatetc != NULL, "pformatetx == NULL\n");
 470     if(pformatetc) {
 471         ok(pformatetc->cfFormat == 0xc02d, "clipformat=%x\n", pformatetc->cfFormat);
 472         ok(pformatetc->ptd == NULL, "ptd = %p\n", pformatetc->ptd);
 473         ok(pformatetc->dwAspect == 1, "dwAspect=%ld\n", pformatetc->dwAspect);
 474         ok(pformatetc->lindex == -1, "lindex=%ld\n", pformatetc->lindex);
 475         ok(pformatetc->tymed == TYMED_ISTREAM, "tymed=%ld\n", pformatetc->tymed);
 476     }
 477
 478     ok(pstgmed != NULL, "stgmeg == NULL\n");
 479     if(pstgmed) {
 480         ok(pstgmed->tymed == TYMED_ISTREAM, "tymed=%ld\n", pstgmed->tymed);
 481         ok(U(*pstgmed).pstm != NULL, "pstm == NULL\n");
 482         ok(pstgmed->pUnkForRelease != NULL, "pUnkForRelease == NULL\n");
 483     }
 484 #endif
 485
 486     if(U(*pstgmed).pstm) {
 487         do hres = IStream_Read(U(*pstgmed).pstm, buf, 512, &readed);
 488         while(hres == S_OK);
 489         ok(hres == S_FALSE || hres == E_PENDING, "IStream_Read returned %08lx\n", hres);
 490     }
 491
 492     return S_OK;
 493 }
 494
 495 static HRESULT WINAPI statusclb_OnObjectAvailable(IBindStatusCallback *iface, REFIID riid, IUnknown *punk)
 496 {
 497     ok(0, "unexpected call\n");
 498     return E_NOTIMPL;
 499 }
 500
 501 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 502     statusclb_QueryInterface,
 503     statusclb_AddRef,
 504     statusclb_Release,
 505     statusclb_OnStartBinding,
 506     statusclb_GetPriority,
 507     statusclb_OnLowResource,
 508     statusclb_OnProgress,
 509     statusclb_OnStopBinding,
 510     statusclb_GetBindInfo,
 511     statusclb_OnDataAvailable,
 512     statusclb_OnObjectAvailable
 513 };
 514
 515 static IBindStatusCallback bsc = { &BindStatusCallbackVtbl };
 516
 517 static void test_CreateAsyncBindCtx(void)
 518 {
 519     IBindCtx *bctx = (IBindCtx*)0x0ff00ff0;
 520     HRESULT hres;
 521     ULONG ref;
 522     BIND_OPTS bindopts;
 523
 524     hres = CreateAsyncBindCtx(0, NULL, NULL, &bctx);
 525     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08lx\n", hres);
 526     ok(bctx == (IBindCtx*)0x0ff00ff0, "bctx should not be changed\n");
 527
 528     hres = CreateAsyncBindCtx(0, NULL, NULL, NULL);
 529     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08lx\n", hres);
 530
 531     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
 532     ok(SUCCEEDED(hres), "CreateAsyncBindCtx failed: %08lx\n", hres);
 533
 534     bindopts.cbStruct = sizeof(bindopts);
 535     hres = IBindCtx_GetBindOptions(bctx, &bindopts);
 536     ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08lx\n", hres);
 537     ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
 538                 "bindopts.grfFlags = %08lx, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
 539     ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
 540                 "bindopts.grfMode = %08lx, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
 541                 bindopts.grfMode);
 542     ok(bindopts.dwTickCountDeadline == 0,
 543                 "bindopts.dwTickCountDeadline = %08lx, expected: 0\n", bindopts.dwTickCountDeadline);
 544
 545     ref = IBindCtx_Release(bctx);
 546     ok(ref == 0, "bctx should be destroyed here\n");
 547 }
 548
 549 static void test_CreateAsyncBindCtxEx(void)
 550 {
 551     IBindCtx *bctx = NULL, *bctx_arg = NULL;
 552     BIND_OPTS bindopts;
 553     HRESULT hres;
 554
 555     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, NULL, 0);
 556     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed: %08lx, expected E_INVALIDARG\n", hres);
 557
 558     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
 559     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08lx\n", hres);
 560
 561     if(SUCCEEDED(hres)) {
 562         bindopts.cbStruct = sizeof(bindopts);
 563         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
 564         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08lx\n", hres);
 565         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
 566                 "bindopts.grfFlags = %08lx, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
 567         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
 568                 "bindopts.grfMode = %08lx, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
 569                 bindopts.grfMode);
 570         ok(bindopts.dwTickCountDeadline == 0,
 571                 "bindopts.dwTickCountDeadline = %08lx, expected: 0\n", bindopts.dwTickCountDeadline);
 572
 573         IBindCtx_Release(bctx);
 574     }
 575
 576     CreateBindCtx(0, &bctx_arg);
 577     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
 578     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08lx\n", hres);
 579
 580     if(SUCCEEDED(hres)) {
 581         bindopts.cbStruct = sizeof(bindopts);
 582         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
 583         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08lx\n", hres);
 584         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
 585                 "bindopts.grfFlags = %08lx, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
 586         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
 587                 "bindopts.grfMode = %08lx, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
 588                 bindopts.grfMode);
 589         ok(bindopts.dwTickCountDeadline == 0,
 590                 "bindopts.dwTickCountDeadline = %08lx, expected: 0\n", bindopts.dwTickCountDeadline);
 591
 592         IBindCtx_Release(bctx);
 593     }
 594
 595     IBindCtx_Release(bctx_arg);
 596
 597     hres = CreateAsyncBindCtxEx(NULL, 0, &bsc, NULL, &bctx, 0);
 598     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08lx\n", hres);
 599
 600     if(SUCCEEDED(hres))
 601         IBindCtx_Release(bctx);
 602 }
 603
 604 static void test_BindToStorage(void)
 605 {
 606     IMoniker *mon;
 607     HRESULT hres;
 608     LPOLESTR display_name;
 609     IBindCtx *bctx;
 610     MSG msg;
 611     IBindStatusCallback *previousclb;
 612     IUnknown *unk = (IUnknown*)0x00ff00ff;
 613     IBinding *bind;
 614
 615     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
 616     ok(SUCCEEDED(hres), "CreateAsyncBindCtx failed: %08lx\n\n", hres);
 617     if(FAILED(hres))
 618         return;
 619
 620     hres = RegisterBindStatusCallback(bctx, &bsc, &previousclb, 0);
 621     ok(SUCCEEDED(hres), "RegisterBindStatusCallback failed: %08lx\n", hres);
 622     ok(previousclb == &bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
 623     if(previousclb)
 624         IBindStatusCallback_Release(previousclb);
 625
 626     hres = CreateURLMoniker(NULL, urls[test_protocol], &mon);
 627     ok(SUCCEEDED(hres), "failed to create moniker: %08lx\n", hres);
 628     if(FAILED(hres)) {
 629         IBindCtx_Release(bctx);
 630         return;
 631     }
 632
 633     if(test_protocol == FILE_TEST && INDEX_HTML[7] == '/')
 634         memmove(INDEX_HTML+7, INDEX_HTML+8, lstrlenW(INDEX_HTML+7)*sizeof(WCHAR));
 635
 636     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
 637     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
 638     if(SUCCEEDED(hres))
 639         IBinding_Release(bind);
 640
 641     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
 642     ok(hres == S_OK, "GetDisplayName failed %08lx\n", hres);
 643     ok(!lstrcmpW(display_name, urls[test_protocol]), "GetDisplayName got wrong name\n");
 644
 645     SET_EXPECT(GetBindInfo);
 646     SET_EXPECT(OnStartBinding);
 647     if(emulate_protocol) {
 648         SET_EXPECT(Start);
 649         SET_EXPECT(UnlockRequest);
 650     }else {
 651         if(test_protocol == HTTP_TEST) {
 652             SET_EXPECT(OnProgress_FINDINGRESOURCE);
 653             SET_EXPECT(OnProgress_CONNECTING);
 654         }
 655         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
 656             SET_EXPECT(OnProgress_SENDINGREQUEST);
 657         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 658         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 659         SET_EXPECT(OnDataAvailable);
 660         if(test_protocol == HTTP_TEST)
 661             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
 662         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 663         SET_EXPECT(OnStopBinding);
 664     }
 665
 666     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
 667     if (test_protocol == HTTP_TEST && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
 668     {
 669         trace( "Network unreachable, skipping tests\n" );
 670         return;
 671     }
 672     ok(SUCCEEDED(hres), "IMoniker_BindToStorage failed: %08lx\n", hres);
 673     if (!SUCCEEDED(hres)) return;
 674
 675     if(test_protocol == HTTP_TEST) {
 676         todo_wine {
 677             ok(unk == NULL, "istr should be NULL\n");
 678         }
 679     }else {
 680         ok(unk != NULL, "unk == NULL\n");
 681     }
 682     if(unk)
 683         IUnknown_Release(unk);
 684
 685     while(!stopped_binding && GetMessage(&msg,NULL,0,0)) {
 686         TranslateMessage(&msg);
 687         DispatchMessage(&msg);
 688     }
 689
 690     CHECK_CALLED(GetBindInfo);
 691     CHECK_CALLED(OnStartBinding);
 692     if(emulate_protocol) {
 693         CHECK_CALLED(Start);
 694         CHECK_CALLED(UnlockRequest);
 695     }else {
 696         if(test_protocol == HTTP_TEST) {
 697             CHECK_CALLED(OnProgress_FINDINGRESOURCE);
 698             CHECK_CALLED(OnProgress_CONNECTING);
 699             CHECK_CALLED(OnProgress_SENDINGREQUEST);
 700             todo_wine { CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE); }
 701         }else {
 702             CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 703         }
 704         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 705         CHECK_CALLED(OnDataAvailable);
 706         if(test_protocol == HTTP_TEST)
 707             CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
 708         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 709         CHECK_CALLED(OnStopBinding);
 710     }
 711
 712     ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
 713     ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
 714 }
 715
 716 static void set_file_url(void)
 717 {
 718     int len;
 719
 720     static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
 721
 722     memcpy(INDEX_HTML, wszFile, sizeof(wszFile));
 723     len = sizeof(wszFile)/sizeof(WCHAR);
 724     INDEX_HTML[len++] = '/';
 725     len += GetCurrentDirectoryW(sizeof(INDEX_HTML)/sizeof(WCHAR)-len, INDEX_HTML+len);
 726     INDEX_HTML[len++] = '\\';
 727     memcpy(INDEX_HTML+len, wszIndexHtml, sizeof(wszIndexHtml));
 728 }
 729
 730 static void create_file(void)
 731 {
 732     HANDLE file;
 733     DWORD size;
 734
 735     static const char html_doc[] = "<HTML></HTML>";
 736
 737     file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 738             FILE_ATTRIBUTE_NORMAL, NULL);
 739     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
 740     if(file == INVALID_HANDLE_VALUE)
 741         return;
 742
 743     WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
 744     CloseHandle(file);
 745
 746     set_file_url();
 747 }
 748
 749 static void test_BindToStorage_fail(void)
 750 {
 751     IMoniker *mon = NULL;
 752     IBindCtx *bctx = NULL;
 753     IUnknown *unk;
 754     HRESULT hres;
 755
 756     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
 757     ok(hres == S_OK, "CreateURLMoniker failed: %08lx\n", hres);
 758     if(FAILED(hres))
 759         return;
 760
 761     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
 762     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08lx\n", hres);
 763
 764     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
 765     ok(hres == MK_E_SYNTAX, "hres=%08lx, expected INET_E_SYNTAX\n", hres);
 766
 767     IBindCtx_Release(bctx);
 768
 769     IMoniker_Release(mon);
 770 }
 771
 772 START_TEST(url)
 773 {
 774     test_create();
 775     test_CreateAsyncBindCtx();
 776     test_CreateAsyncBindCtxEx();
 777
 778     trace("http test...\n");
 779     emulate_protocol = FALSE;
 780     test_protocol = HTTP_TEST;
 781     test_BindToStorage();
 782
 783     trace("about test...\n");
 784     test_protocol = ABOUT_TEST;
 785     CoInitialize(NULL);
 786     test_BindToStorage();
 787     CoUninitialize();
 788
 789     trace("emulated about test...\n");
 790     emulate_protocol = TRUE;
 791     test_protocol = ABOUT_TEST;
 792     test_BindToStorage();
 793
 794     trace("file test...\n");
 795     create_file();
 796     emulate_protocol = FALSE;
 797     test_protocol = FILE_TEST;
 798     test_BindToStorage();
 799     DeleteFileW(wszIndexHtml);
 800
 801     trace("emulated file test...\n");
 802     set_file_url();
 803     emulate_protocol = TRUE;
 804     test_protocol = FILE_TEST;
 805     test_BindToStorage();
 806
 807     test_BindToStorage_fail();
 808 }