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