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-2007 Jacek Caban for CodeWeavers
   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 #include <stdio.h>
  24
  25 #define COBJMACROS
  26 #define CONST_VTABLE
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "urlmon.h"
  31 #include "wininet.h"
  32 #include "mshtml.h"
  33
  34 #include "wine/test.h"
  35
  36 #define DEFINE_EXPECT(func) \
  37     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  38
  39 #define SET_EXPECT(func) \
  40     expect_ ## func = TRUE
  41
  42 #define CHECK_EXPECT(func) \
  43     do { \
  44         ok(expect_ ##func, "unexpected call " #func "\n"); \
  45         expect_ ## func = FALSE; \
  46         called_ ## func = TRUE; \
  47     }while(0)
  48
  49 #define CHECK_EXPECT2(func) \
  50     do { \
  51         ok(expect_ ##func, "unexpected call " #func "\n"); \
  52         called_ ## func = TRUE; \
  53     }while(0)
  54
  55 #define CHECK_CALLED(func) \
  56     do { \
  57         ok(called_ ## func, "expected " #func "\n"); \
  58         expect_ ## func = called_ ## func = FALSE; \
  59     }while(0)
  60
  61 #define CHECK_NOT_CALLED(func) \
  62     do { \
  63         ok(!called_ ## func, "unexpected " #func "\n"); \
  64         expect_ ## func = called_ ## func = FALSE; \
  65     }while(0)
  66
  67 #define CLEAR_CALLED(func) \
  68     expect_ ## func = called_ ## func = FALSE
  69
  70 DEFINE_EXPECT(QueryInterface_IServiceProvider);
  71 DEFINE_EXPECT(QueryInterface_IHttpNegotiate);
  72 DEFINE_EXPECT(QueryInterface_IBindStatusCallback);
  73 DEFINE_EXPECT(QueryInterface_IBindStatusCallbackHolder);
  74 DEFINE_EXPECT(QueryInterface_IInternetBindInfo);
  75 DEFINE_EXPECT(QueryInterface_IAuthenticate);
  76 DEFINE_EXPECT(QueryInterface_IInternetProtocol);
  77 DEFINE_EXPECT(QueryService_IAuthenticate);
  78 DEFINE_EXPECT(QueryService_IInternetProtocol);
  79 DEFINE_EXPECT(QueryService_IInternetBindInfo);
  80 DEFINE_EXPECT(BeginningTransaction);
  81 DEFINE_EXPECT(OnResponse);
  82 DEFINE_EXPECT(QueryInterface_IHttpNegotiate2);
  83 DEFINE_EXPECT(GetRootSecurityId);
  84 DEFINE_EXPECT(GetBindInfo);
  85 DEFINE_EXPECT(OnStartBinding);
  86 DEFINE_EXPECT(OnProgress_FINDINGRESOURCE);
  87 DEFINE_EXPECT(OnProgress_CONNECTING);
  88 DEFINE_EXPECT(OnProgress_SENDINGREQUEST);
  89 DEFINE_EXPECT(OnProgress_MIMETYPEAVAILABLE);
  90 DEFINE_EXPECT(OnProgress_BEGINDOWNLOADDATA);
  91 DEFINE_EXPECT(OnProgress_DOWNLOADINGDATA);
  92 DEFINE_EXPECT(OnProgress_ENDDOWNLOADDATA);
  93 DEFINE_EXPECT(OnProgress_CLASSIDAVAILABLE);
  94 DEFINE_EXPECT(OnProgress_BEGINSYNCOPERATION);
  95 DEFINE_EXPECT(OnProgress_ENDSYNCOPERATION);
  96 DEFINE_EXPECT(OnStopBinding);
  97 DEFINE_EXPECT(OnDataAvailable);
  98 DEFINE_EXPECT(OnObjectAvailable);
  99 DEFINE_EXPECT(Start);
 100 DEFINE_EXPECT(Read);
 101 DEFINE_EXPECT(LockRequest);
 102 DEFINE_EXPECT(Terminate);
 103 DEFINE_EXPECT(UnlockRequest);
 104 DEFINE_EXPECT(Continue);
 105
 106 static const WCHAR TEST_URL_1[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/','\0'};
 107 static const WCHAR TEST_PART_URL_1[] = {'/','t','e','s','t','/','\0'};
 108
 109 static const WCHAR WINE_ABOUT_URL[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
 110                                        'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0};
 111 static const WCHAR SHORT_RESPONSE_URL[] =
 112         {'h','t','t','p',':','/','/','c','r','o','s','s','o','v','e','r','.',
 113          'c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
 114          'p','o','s','t','t','e','s','t','.','p','h','p',0};
 115 static const WCHAR ABOUT_BLANK[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 116 static WCHAR INDEX_HTML[MAX_PATH];
 117 static const WCHAR ITS_URL[] =
 118     {'i','t','s',':','t','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0};
 119 static const WCHAR MK_URL[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':',
 120     't','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0};
 121
 122 static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 123
 124 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
 125
 126 static const WCHAR wszWineHQSite[] =
 127     {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
 128 static const WCHAR wszWineHQIP[] =
 129     {'2','0','9','.','3','2','.','1','4','1','.','3',0};
 130 static const WCHAR wszIndexHtml[] = {'i','n','d','e','x','.','h','t','m','l',0};
 131
 132 static BOOL stopped_binding = FALSE, emulate_protocol = FALSE,
 133     data_available = FALSE, http_is_first = TRUE;
 134 static DWORD read = 0, bindf = 0, prot_state = 0, thread_id;
 135 static CHAR mime_type[512];
 136 static IInternetProtocolSink *protocol_sink = NULL;
 137 static HANDLE complete_event, complete_event2;
 138
 139 extern IID IID_IBindStatusCallbackHolder;
 140
 141 static LPCWSTR urls[] = {
 142     WINE_ABOUT_URL,
 143     ABOUT_BLANK,
 144     INDEX_HTML,
 145     ITS_URL,
 146     MK_URL
 147 };
 148
 149 static enum {
 150     HTTP_TEST,
 151     ABOUT_TEST,
 152     FILE_TEST,
 153     ITS_TEST,
 154     MK_TEST
 155 } test_protocol;
 156
 157 static enum {
 158     BEFORE_DOWNLOAD,
 159     DOWNLOADING,
 160     END_DOWNLOAD
 161 } download_state;
 162
 163 static const char *debugstr_guid(REFIID riid)
 164 {
 165     static char buf[50];
 166
 167     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 168             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 169             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 170             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 171
 172     return buf;
 173 }
 174
 175 static void test_CreateURLMoniker(LPCWSTR url1, LPCWSTR url2)
 176 {
 177     HRESULT hr;
 178     IMoniker *mon1 = NULL;
 179     IMoniker *mon2 = NULL;
 180
 181     hr = CreateURLMoniker(NULL, url1, &mon1);
 182     ok(SUCCEEDED(hr), "failed to create moniker: 0x%08x\n", hr);
 183     if(SUCCEEDED(hr)) {
 184         hr = CreateURLMoniker(mon1, url2, &mon2);
 185         ok(SUCCEEDED(hr), "failed to create moniker: 0x%08x\n", hr);
 186     }
 187     if(mon1) IMoniker_Release(mon1);
 188     if(mon2) IMoniker_Release(mon2);
 189 }
 190
 191 static void test_create(void)
 192 {
 193     test_CreateURLMoniker(TEST_URL_1, TEST_PART_URL_1);
 194 }
 195
 196 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 197 {
 198     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
 199         *ppv = iface;
 200         return S_OK;
 201     }
 202
 203     *ppv = NULL;
 204     return E_NOINTERFACE;
 205 }
 206
 207 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
 208 {
 209     return 2;
 210 }
 211
 212 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
 213 {
 214     return 1;
 215 }
 216
 217 static DWORD WINAPI thread_proc(PVOID arg)
 218 {
 219     PROTOCOLDATA protocoldata;
 220     HRESULT hres;
 221
 222     SET_EXPECT(OnProgress_FINDINGRESOURCE);
 223     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 224             BINDSTATUS_FINDINGRESOURCE, wszWineHQSite);
 225     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 226     WaitForSingleObject(complete_event, INFINITE);
 227     CHECK_CALLED(OnProgress_FINDINGRESOURCE);
 228
 229     SET_EXPECT(OnProgress_CONNECTING);
 230     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 231             BINDSTATUS_CONNECTING, wszWineHQIP);
 232     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 233     WaitForSingleObject(complete_event, INFINITE);
 234     CHECK_CALLED(OnProgress_CONNECTING);
 235
 236     SET_EXPECT(OnProgress_SENDINGREQUEST);
 237     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 238             BINDSTATUS_SENDINGREQUEST, NULL);
 239     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 240     WaitForSingleObject(complete_event, INFINITE);
 241     CHECK_CALLED(OnProgress_SENDINGREQUEST);
 242
 243     SET_EXPECT(Continue);
 244     prot_state = 1;
 245     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 246     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 247     WaitForSingleObject(complete_event, INFINITE);
 248     CHECK_CALLED(Continue);
 249     CHECK_CALLED(Read);
 250     CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 251     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 252     CHECK_CALLED(LockRequest);
 253     CHECK_CALLED(OnDataAvailable);
 254
 255     SET_EXPECT(Continue);
 256     prot_state = 2;
 257     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 258     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 259     WaitForSingleObject(complete_event, INFINITE);
 260     CHECK_CALLED(Continue);
 261     CHECK_CALLED(Read);
 262     CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
 263     CHECK_CALLED(OnDataAvailable);
 264
 265     SET_EXPECT(Continue);
 266     prot_state = 2;
 267     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 268     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 269     WaitForSingleObject(complete_event, INFINITE);
 270     CHECK_CALLED(Continue);
 271     CHECK_CALLED(Read);
 272     CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
 273     CHECK_CALLED(OnDataAvailable);
 274
 275     SET_EXPECT(Continue);
 276     prot_state = 3;
 277     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 278     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 279     WaitForSingleObject(complete_event, INFINITE);
 280     CHECK_CALLED(Continue);
 281     CHECK_CALLED(Read);
 282     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 283     CHECK_CALLED(OnDataAvailable);
 284     CHECK_CALLED(OnStopBinding);
 285
 286     SetEvent(complete_event2);
 287
 288     return 0;
 289 }
 290
 291 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 292         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 293         DWORD grfPI, DWORD dwReserved)
 294 {
 295     BINDINFO bindinfo, bi = {sizeof(bi), 0};
 296     DWORD bindf, bscf = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION;
 297     WCHAR null_char = 0;
 298     HRESULT hres;
 299
 300     CHECK_EXPECT(Start);
 301
 302     read = 0;
 303
 304     ok(szUrl && !lstrcmpW(szUrl, urls[test_protocol]), "wrong url\n");
 305     ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
 306     ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
 307     ok(grfPI == 0, "grfPI=%d, expected 0\n", grfPI);
 308     ok(dwReserved == 0, "dwReserved=%d, expected 0\n", dwReserved);
 309
 310     memset(&bindinfo, 0, sizeof(bindinfo));
 311     bindinfo.cbSize = sizeof(bindinfo);
 312     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
 313     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
 314
 315     if(test_protocol == FILE_TEST || test_protocol == MK_TEST || test_protocol == HTTP_TEST) {
 316         ok(bindf == (BINDF_ASYNCHRONOUS|BINDF_ASYNCSTORAGE|BINDF_PULLDATA
 317                      |BINDF_FROMURLMON),
 318            "bindf=%08x\n", bindf);
 319     }else {
 320         ok(bindf == (BINDF_ASYNCHRONOUS|BINDF_ASYNCSTORAGE|BINDF_PULLDATA|
 321                      BINDF_FROMURLMON|BINDF_NEEDFILE),
 322            "bindf=%08x\n", bindf);
 323     }
 324
 325     ok(!memcmp(&bindinfo, &bi, sizeof(bindinfo)), "wrong bindinfo\n");
 326
 327     switch(test_protocol) {
 328     case MK_TEST:
 329         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 330                 BINDSTATUS_DIRECTBIND, NULL);
 331         ok(hres == S_OK,
 332            "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
 333
 334     case FILE_TEST:
 335     case ITS_TEST:
 336         SET_EXPECT(OnProgress_SENDINGREQUEST);
 337         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 338                 BINDSTATUS_SENDINGREQUEST, &null_char);
 339         ok(hres == S_OK,
 340            "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
 341         CHECK_CALLED(OnProgress_SENDINGREQUEST);
 342     default:
 343         break;
 344     }
 345
 346     if(test_protocol == HTTP_TEST) {
 347         IServiceProvider *service_provider;
 348         IHttpNegotiate *http_negotiate;
 349         IHttpNegotiate2 *http_negotiate2;
 350         LPWSTR ua = (LPWSTR)0xdeadbeef, accept_mimes[256];
 351         LPWSTR additional_headers = (LPWSTR)0xdeadbeef;
 352         BYTE sec_id[100];
 353         DWORD fetched = 256, size = 100;
 354
 355         static const WCHAR wszMimes[] = {'*','/','*',0};
 356
 357         SET_EXPECT(QueryInterface_IInternetBindInfo);
 358         SET_EXPECT(QueryService_IInternetBindInfo);
 359         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_USER_AGENT,
 360                                                &ua, 1, &fetched);
 361         todo_wine {
 362         CHECK_CALLED(QueryInterface_IInternetBindInfo);
 363         CHECK_CALLED(QueryService_IInternetBindInfo);
 364         }
 365         ok(hres == E_NOINTERFACE,
 366            "GetBindString(BINDSTRING_USER_AGETNT) failed: %08x\n", hres);
 367         ok(fetched == 256, "fetched = %d, expected 254\n", fetched);
 368         ok(ua == (LPWSTR)0xdeadbeef, "ua =  %p\n", ua);
 369
 370         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 371                                                accept_mimes, 256, &fetched);
 372         ok(hres == S_OK,
 373            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 374         ok(fetched == 1, "fetched = %d, expected 1\n", fetched);
 375         ok(!lstrcmpW(wszMimes, accept_mimes[0]), "unexpected mimes\n");
 376
 377         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 378                                                NULL, 256, &fetched);
 379         ok(hres == E_INVALIDARG,
 380            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 381
 382         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 383                                                accept_mimes, 256, NULL);
 384         ok(hres == E_INVALIDARG,
 385            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 386
 387         hres = IInternetBindInfo_QueryInterface(pOIBindInfo, &IID_IServiceProvider,
 388                                                 (void**)&service_provider);
 389         ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
 390
 391         SET_EXPECT(QueryInterface_IHttpNegotiate);
 392         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
 393                 &IID_IHttpNegotiate, (void**)&http_negotiate);
 394         CHECK_CALLED(QueryInterface_IHttpNegotiate);
 395         ok(hres == S_OK, "QueryService failed: %08x\n", hres);
 396
 397         SET_EXPECT(BeginningTransaction);
 398         hres = IHttpNegotiate_BeginningTransaction(http_negotiate, urls[test_protocol],
 399                                                    NULL, 0, &additional_headers);
 400         CHECK_CALLED(BeginningTransaction);
 401         IHttpNegotiate_Release(http_negotiate);
 402         ok(hres == S_OK, "BeginningTransction failed: %08x\n", hres);
 403         ok(additional_headers == NULL, "additional_headers=%p\n", additional_headers);
 404
 405         SET_EXPECT(QueryInterface_IHttpNegotiate2);
 406         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
 407                 &IID_IHttpNegotiate2, (void**)&http_negotiate2);
 408         CHECK_CALLED(QueryInterface_IHttpNegotiate2);
 409         ok(hres == S_OK, "QueryService failed: %08x\n", hres);
 410
 411         size = 512;
 412         SET_EXPECT(GetRootSecurityId);
 413         hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, sec_id, &size, 0);
 414         CHECK_CALLED(GetRootSecurityId);
 415         IHttpNegotiate2_Release(http_negotiate2);
 416         ok(hres == E_FAIL, "GetRootSecurityId failed: %08x, expected E_FAIL\n", hres);
 417         ok(size == 13, "size=%d\n", size);
 418
 419         IServiceProvider_Release(service_provider);
 420
 421         IInternetProtocolSink_AddRef(pOIProtSink);
 422         protocol_sink = pOIProtSink;
 423         CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
 424
 425         return S_OK;
 426     }
 427
 428     if(test_protocol == FILE_TEST) {
 429         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 430                 BINDSTATUS_CACHEFILENAMEAVAILABLE, &null_char);
 431         ok(hres == S_OK,
 432            "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
 433
 434         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 435         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 436                 BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextHtml);
 437         ok(hres == S_OK,
 438            "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
 439         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 440     }else {
 441         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 442                 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 443         ok(hres == S_OK,
 444            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
 445     }
 446
 447     if(test_protocol == ABOUT_TEST)
 448         bscf |= BSCF_DATAFULLYAVAILABLE;
 449     if(test_protocol == ITS_TEST)
 450         bscf = BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
 451
 452     SET_EXPECT(Read);
 453     if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 454         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 455     SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 456     SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 457     SET_EXPECT(LockRequest);
 458     SET_EXPECT(OnDataAvailable);
 459     SET_EXPECT(OnStopBinding);
 460
 461     hres = IInternetProtocolSink_ReportData(pOIProtSink, bscf, 13, 13);
 462     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 463
 464     CHECK_CALLED(Read);
 465     if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 466         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 467     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 468     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 469     CHECK_CALLED(LockRequest);
 470     CHECK_CALLED(OnDataAvailable);
 471     CHECK_CALLED(OnStopBinding);
 472
 473     if(test_protocol == ITS_TEST) {
 474         SET_EXPECT(Read);
 475         hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
 476         ok(hres == S_OK, "ReportProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
 477         CHECK_CALLED(Read);
 478     }
 479
 480     SET_EXPECT(Terminate);
 481     hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 482     ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 483     CHECK_CALLED(Terminate);
 484
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
 489         PROTOCOLDATA *pProtocolData)
 490 {
 491     DWORD bscf = 0;
 492     HRESULT hres;
 493
 494     CHECK_EXPECT(Continue);
 495
 496     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 497
 498     ok(pProtocolData != NULL, "pProtocolData == NULL\n");
 499     if(!pProtocolData)
 500         return S_OK;
 501
 502     switch(prot_state) {
 503     case 1: {
 504         IServiceProvider *service_provider;
 505         IHttpNegotiate *http_negotiate;
 506         static WCHAR header[] = {'?',0};
 507
 508         hres = IInternetProtocolSink_QueryInterface(protocol_sink, &IID_IServiceProvider,
 509                                                     (void**)&service_provider);
 510         ok(hres == S_OK, "Could not get IServiceProvicder\n");
 511
 512         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
 513                                              &IID_IHttpNegotiate, (void**)&http_negotiate);
 514         ok(hres == S_OK, "Could not get IHttpNegotiate\n");
 515
 516         SET_EXPECT(OnResponse);
 517         hres = IHttpNegotiate_OnResponse(http_negotiate, 200, header, NULL, NULL);
 518         CHECK_CALLED(OnResponse);
 519         IHttpNegotiate_Release(http_negotiate);
 520         ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
 521
 522         hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 523                 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 524         ok(hres == S_OK,
 525            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
 526
 527         bscf |= BSCF_FIRSTDATANOTIFICATION;
 528         break;
 529     }
 530     case 2:
 531     case 3:
 532         bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
 533         break;
 534     }
 535
 536     hres = IInternetProtocolSink_ReportData(protocol_sink, bscf, 100, 400);
 537     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 538
 539     SET_EXPECT(Read);
 540     switch(prot_state) {
 541     case 1:
 542         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 543         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 544         SET_EXPECT(LockRequest);
 545         break;
 546     case 2:
 547         SET_EXPECT(OnProgress_DOWNLOADINGDATA);
 548         break;
 549     case 3:
 550         SET_EXPECT(OnProgress_DOWNLOADINGDATA);
 551         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 552     }
 553     SET_EXPECT(OnDataAvailable);
 554     if(prot_state == 3)
 555         SET_EXPECT(OnStopBinding);
 556
 557     return S_OK;
 558 }
 559
 560 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 561         DWORD dwOptions)
 562 {
 563     ok(0, "unexpected call\n");
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 568 {
 569     CHECK_EXPECT(Terminate);
 570
 571     ok(dwOptions == 0, "dwOptions=%d, expected 0\n", dwOptions);
 572
 573     if(protocol_sink) {
 574         IInternetProtocolSink_Release(protocol_sink);
 575         protocol_sink = NULL;
 576     }
 577
 578     return S_OK;
 579 }
 580
 581 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
 582 {
 583     ok(0, "unexpected call\n");
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
 588 {
 589     ok(0, "unexpected call\n");
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
 594         ULONG cb, ULONG *pcbRead)
 595 {
 596     static const char data[] = "<HTML></HTML>";
 597
 598     CHECK_EXPECT2(Read);
 599
 600     if(test_protocol == HTTP_TEST) {
 601         HRESULT hres;
 602
 603         static BOOL pending = TRUE;
 604
 605         pending = !pending;
 606
 607         switch(prot_state) {
 608         case 1:
 609         case 2:
 610             if(pending) {
 611                 *pcbRead = 10;
 612                 memset(pv, '?', 10);
 613                 return E_PENDING;
 614             }else {
 615                 memset(pv, '?', cb);
 616                 *pcbRead = cb;
 617                 read++;
 618                 return S_OK;
 619             }
 620         case 3:
 621             prot_state++;
 622
 623             *pcbRead = 0;
 624
 625             hres = IInternetProtocolSink_ReportData(protocol_sink,
 626                     BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION, 2000, 2000);
 627             ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 628
 629             hres = IInternetProtocolSink_ReportResult(protocol_sink, S_OK, 0, NULL);
 630             ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 631
 632             return S_FALSE;
 633         case 4:
 634             *pcbRead = 0;
 635             return S_FALSE;
 636         }
 637     }
 638
 639     if(read) {
 640         *pcbRead = 0;
 641         return S_FALSE;
 642     }
 643
 644     ok(pv != NULL, "pv == NULL\n");
 645     ok(cb != 0, "cb == 0\n");
 646     ok(pcbRead != NULL, "pcbRead == NULL\n");
 647     if(pcbRead) {
 648         ok(*pcbRead == 0, "*pcbRead=%d, expected 0\n", *pcbRead);
 649         read += *pcbRead = sizeof(data)-1;
 650     }
 651     if(pv)
 652         memcpy(pv, data, sizeof(data));
 653
 654     return S_OK;
 655 }
 656
 657 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
 658         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 659 {
 660     ok(0, "unexpected call\n");
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 665 {
 666     CHECK_EXPECT(LockRequest);
 667     return S_OK;
 668 }
 669
 670 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
 671 {
 672     CHECK_EXPECT(UnlockRequest);
 673     return S_OK;
 674 }
 675
 676 static const IInternetProtocolVtbl ProtocolVtbl = {
 677     Protocol_QueryInterface,
 678     Protocol_AddRef,
 679     Protocol_Release,
 680     Protocol_Start,
 681     Protocol_Continue,
 682     Protocol_Abort,
 683     Protocol_Terminate,
 684     Protocol_Suspend,
 685     Protocol_Resume,
 686     Protocol_Read,
 687     Protocol_Seek,
 688     Protocol_LockRequest,
 689     Protocol_UnlockRequest
 690 };
 691
 692 static IInternetProtocol Protocol = { &ProtocolVtbl };
 693
 694 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
 695 {
 696     if(IsEqualGUID(&IID_IUnknown, riid)
 697             || IsEqualGUID(&IID_IHttpNegotiate, riid)
 698             || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
 699         *ppv = iface;
 700         return S_OK;
 701     }
 702
 703     ok(0, "unexpected call\n");
 704     return E_NOINTERFACE;
 705 }
 706
 707 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
 708 {
 709     return 2;
 710 }
 711
 712 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
 713 {
 714     return 1;
 715 }
 716
 717 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface, LPCWSTR szURL,
 718         LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
 719 {
 720     CHECK_EXPECT(BeginningTransaction);
 721
 722     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 723
 724     ok(!lstrcmpW(szURL, urls[test_protocol]), "szURL != urls[test_protocol]\n");
 725     ok(!dwReserved, "dwReserved=%d, expected 0\n", dwReserved);
 726     ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
 727     if(pszAdditionalHeaders)
 728         ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
 729
 730     return S_OK;
 731 }
 732
 733 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
 734         LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
 735 {
 736     CHECK_EXPECT(OnResponse);
 737
 738     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 739
 740     ok(dwResponseCode == 200, "dwResponseCode=%d, expected 200\n", dwResponseCode);
 741     ok(szResponseHeaders != NULL, "szResponseHeaders == NULL\n");
 742     ok(szRequestHeaders == NULL, "szRequestHeaders != NULL\n");
 743     /* Note: in protocol.c tests, OnResponse pszAdditionalRequestHeaders _is_ NULL */
 744     ok(pszAdditionalRequestHeaders != NULL, "pszAdditionalHeaders == NULL\n");
 745     if(pszAdditionalRequestHeaders)
 746         ok(*pszAdditionalRequestHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
 747
 748     return S_OK;
 749 }
 750
 751 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
 752         BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 753 {
 754     static const BYTE sec_id[] = {'h','t','t','p',':','t','e','s','t',1,0,0,0};
 755
 756     CHECK_EXPECT(GetRootSecurityId);
 757
 758     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 759
 760     ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
 761     ok(pbSecurityId != NULL, "pbSecurityId == NULL\n");
 762     ok(pcbSecurityId != NULL, "pcbSecurityId == NULL\n");
 763
 764     if(pbSecurityId == (void*)0xdeadbeef)
 765         return E_NOTIMPL;
 766
 767     if(pcbSecurityId) {
 768         ok(*pcbSecurityId == 512, "*pcbSecurityId=%d, expected 512\n", *pcbSecurityId);
 769         *pcbSecurityId = sizeof(sec_id);
 770     }
 771
 772     if(pbSecurityId)
 773         memcpy(pbSecurityId, sec_id, sizeof(sec_id));
 774
 775     return E_FAIL;
 776 }
 777
 778 static IHttpNegotiate2Vtbl HttpNegotiateVtbl = {
 779     HttpNegotiate_QueryInterface,
 780     HttpNegotiate_AddRef,
 781     HttpNegotiate_Release,
 782     HttpNegotiate_BeginningTransaction,
 783     HttpNegotiate_OnResponse,
 784     HttpNegotiate_GetRootSecurityId
 785 };
 786
 787 static IHttpNegotiate2 HttpNegotiate = { &HttpNegotiateVtbl };
 788
 789 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 790 {
 791     ok(0, "unexpected call\n");
 792     return E_NOINTERFACE;
 793 }
 794
 795 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 796 {
 797     return 2;
 798 }
 799
 800 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 801 {
 802     return 1;
 803 }
 804
 805 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
 806         REFGUID guidService, REFIID riid, void **ppv)
 807 {
 808     if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
 809         CHECK_EXPECT(QueryService_IAuthenticate);
 810         return E_NOTIMPL;
 811     }
 812
 813     if(IsEqualGUID(&IID_IInternetProtocol, guidService)) {
 814         CHECK_EXPECT2(QueryService_IInternetProtocol);
 815         return E_NOTIMPL;
 816     }
 817
 818     if(IsEqualGUID(&IID_IInternetBindInfo, guidService)) {
 819         CHECK_EXPECT(QueryService_IInternetBindInfo);
 820         return E_NOTIMPL;
 821     }
 822
 823     ok(0, "unexpected service %s\n", debugstr_guid(guidService));
 824     return E_NOINTERFACE;
 825 }
 826
 827 static IServiceProviderVtbl ServiceProviderVtbl = {
 828     ServiceProvider_QueryInterface,
 829     ServiceProvider_AddRef,
 830     ServiceProvider_Release,
 831     ServiceProvider_QueryService
 832 };
 833
 834 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
 835
 836 static HRESULT WINAPI statusclb_QueryInterface(IBindStatusCallback *iface, REFIID riid, void **ppv)
 837 {
 838     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 839
 840     if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 841         CHECK_EXPECT2(QueryInterface_IInternetProtocol);
 842         if(emulate_protocol) {
 843             *ppv = &Protocol;
 844             return S_OK;
 845         }else {
 846             return E_NOINTERFACE;
 847         }
 848     }
 849     else if (IsEqualGUID(&IID_IServiceProvider, riid))
 850     {
 851         CHECK_EXPECT2(QueryInterface_IServiceProvider);
 852         *ppv = &ServiceProvider;
 853         return S_OK;
 854     }
 855     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
 856     {
 857         CHECK_EXPECT(QueryInterface_IHttpNegotiate);
 858         *ppv = &HttpNegotiate;
 859         return S_OK;
 860     }
 861     else if (IsEqualGUID(&IID_IHttpNegotiate2, riid))
 862     {
 863         CHECK_EXPECT(QueryInterface_IHttpNegotiate2);
 864         *ppv = &HttpNegotiate;
 865         return S_OK;
 866     }
 867     else if (IsEqualGUID(&IID_IAuthenticate, riid))
 868     {
 869         CHECK_EXPECT(QueryInterface_IAuthenticate);
 870         return E_NOINTERFACE;
 871     }
 872     else if(IsEqualGUID(&IID_IBindStatusCallback, riid))
 873     {
 874         CHECK_EXPECT2(QueryInterface_IBindStatusCallback);
 875         *ppv = iface;
 876         return S_OK;
 877     }
 878     else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid))
 879     {
 880         CHECK_EXPECT2(QueryInterface_IBindStatusCallbackHolder);
 881         return E_NOINTERFACE;
 882     }
 883     else if(IsEqualGUID(&IID_IInternetBindInfo, riid))
 884     {
 885         /* TODO */
 886         CHECK_EXPECT2(QueryInterface_IInternetBindInfo);
 887     }
 888     else
 889     {
 890         ok(0, "unexpected interface %s\n", debugstr_guid(riid));
 891     }
 892
 893     return E_NOINTERFACE;
 894 }
 895
 896 static ULONG WINAPI statusclb_AddRef(IBindStatusCallback *iface)
 897 {
 898     return 2;
 899 }
 900
 901 static ULONG WINAPI statusclb_Release(IBindStatusCallback *iface)
 902 {
 903     return 1;
 904 }
 905
 906 static HRESULT WINAPI statusclb_OnStartBinding(IBindStatusCallback *iface, DWORD dwReserved,
 907         IBinding *pib)
 908 {
 909     HRESULT hres;
 910     IMoniker *mon;
 911
 912     CHECK_EXPECT(OnStartBinding);
 913
 914     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 915
 916     ok(pib != NULL, "pib should not be NULL\n");
 917     ok(dwReserved == 0xff, "dwReserved=%x\n", dwReserved);
 918
 919     if(pib == (void*)0xdeadbeef)
 920         return S_OK;
 921
 922     hres = IBinding_QueryInterface(pib, &IID_IMoniker, (void**)&mon);
 923     ok(hres == E_NOINTERFACE, "IBinding should not have IMoniker interface\n");
 924     if(SUCCEEDED(hres))
 925         IMoniker_Release(mon);
 926
 927     return S_OK;
 928 }
 929
 930 static HRESULT WINAPI statusclb_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
 931 {
 932     ok(0, "unexpected call\n");
 933     return E_NOTIMPL;
 934 }
 935
 936 static HRESULT WINAPI statusclb_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 937 {
 938     ok(0, "unexpected call\n");
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI statusclb_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 943         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 944 {
 945     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 946
 947     switch(ulStatusCode) {
 948     case BINDSTATUS_FINDINGRESOURCE:
 949         CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
 950         if((bindf & BINDF_ASYNCHRONOUS) && emulate_protocol)
 951             SetEvent(complete_event);
 952         break;
 953     case BINDSTATUS_CONNECTING:
 954         CHECK_EXPECT(OnProgress_CONNECTING);
 955         if((bindf & BINDF_ASYNCHRONOUS) && emulate_protocol)
 956             SetEvent(complete_event);
 957         break;
 958     case BINDSTATUS_SENDINGREQUEST:
 959         CHECK_EXPECT(OnProgress_SENDINGREQUEST);
 960         if((bindf & BINDF_ASYNCHRONOUS) && emulate_protocol)
 961             SetEvent(complete_event);
 962         break;
 963     case BINDSTATUS_MIMETYPEAVAILABLE:
 964         CHECK_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 965         ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
 966            download_state);
 967         WideCharToMultiByte(CP_ACP, 0, szStatusText, -1, mime_type, sizeof(mime_type)-1, NULL, NULL);
 968         break;
 969     case BINDSTATUS_BEGINDOWNLOADDATA:
 970         CHECK_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 971         ok(szStatusText != NULL, "szStatusText == NULL\n");
 972         if(szStatusText)
 973             ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText\n");
 974         ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
 975            download_state);
 976         download_state = DOWNLOADING;
 977         break;
 978     case BINDSTATUS_DOWNLOADINGDATA:
 979         CHECK_EXPECT2(OnProgress_DOWNLOADINGDATA);
 980         ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
 981            download_state);
 982         break;
 983     case BINDSTATUS_ENDDOWNLOADDATA:
 984         CHECK_EXPECT(OnProgress_ENDDOWNLOADDATA);
 985         ok(szStatusText != NULL, "szStatusText == NULL\n");
 986         if(szStatusText)
 987             ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText\n");
 988         ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
 989            download_state);
 990         download_state = END_DOWNLOAD;
 991         break;
 992     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 993         ok(szStatusText != NULL, "szStatusText == NULL\n");
 994         if(szStatusText && test_protocol == FILE_TEST)
 995             ok(!lstrcmpW(INDEX_HTML+7, szStatusText), "wrong szStatusText\n");
 996         break;
 997     case BINDSTATUS_CLASSIDAVAILABLE:
 998     {
 999         CLSID clsid;
1000         HRESULT hr;
1001         CHECK_EXPECT(OnProgress_CLASSIDAVAILABLE);
1002         hr = CLSIDFromString((LPOLESTR)szStatusText, &clsid);
1003         ok(hr == S_OK, "CLSIDFromString failed with error 0x%08x\n", hr);
1004         ok(IsEqualCLSID(&clsid, &CLSID_HTMLDocument),
1005             "Expected clsid to be CLSID_HTMLDocument instead of {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
1006             clsid.Data1, clsid.Data2, clsid.Data3,
1007             clsid.Data4[0], clsid.Data4[1], clsid.Data4[2], clsid.Data4[3],
1008             clsid.Data4[4], clsid.Data4[5], clsid.Data4[6], clsid.Data4[7]);
1009         break;
1010     }
1011     case BINDSTATUS_BEGINSYNCOPERATION:
1012         CHECK_EXPECT(OnProgress_BEGINSYNCOPERATION);
1013         ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1014         break;
1015     case BINDSTATUS_ENDSYNCOPERATION:
1016         CHECK_EXPECT(OnProgress_ENDSYNCOPERATION);
1017         ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1018         break;
1019     default:
1020         ok(0, "unexpexted code %d\n", ulStatusCode);
1021     };
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI statusclb_OnStopBinding(IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError)
1026 {
1027     CHECK_EXPECT(OnStopBinding);
1028
1029     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1030
1031     stopped_binding = TRUE;
1032
1033     /* ignore DNS failure */
1034     if (hresult == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
1035         return S_OK;
1036
1037     ok(hresult == S_OK, "binding failed: %08x\n", hresult);
1038     ok(szError == NULL, "szError should be NULL\n");
1039
1040     if(test_protocol == HTTP_TEST && emulate_protocol) {
1041         SetEvent(complete_event);
1042         WaitForSingleObject(complete_event2, INFINITE);
1043     }
1044
1045     return S_OK;
1046 }
1047
1048 static HRESULT WINAPI statusclb_GetBindInfo(IBindStatusCallback *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
1049 {
1050     DWORD cbSize;
1051
1052     CHECK_EXPECT(GetBindInfo);
1053
1054     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1055
1056     *grfBINDF = bindf;
1057     cbSize = pbindinfo->cbSize;
1058     memset(pbindinfo, 0, cbSize);
1059     pbindinfo->cbSize = cbSize;
1060
1061     return S_OK;
1062 }
1063
1064 static HRESULT WINAPI statusclb_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
1065         DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
1066 {
1067     HRESULT hres;
1068     DWORD readed;
1069     BYTE buf[512];
1070     CHAR clipfmt[512];
1071
1072     CHECK_EXPECT2(OnDataAvailable);
1073
1074     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1075
1076     ok(download_state == DOWNLOADING || download_state == END_DOWNLOAD,
1077        "Download state was %d, expected DOWNLOADING or END_DOWNLOAD\n",
1078        download_state);
1079     data_available = TRUE;
1080
1081     ok(pformatetc != NULL, "pformatetx == NULL\n");
1082     if(pformatetc) {
1083         if (mime_type[0]) todo_wine {
1084             clipfmt[0] = 0;
1085             ok(GetClipboardFormatName(pformatetc->cfFormat, clipfmt, sizeof(clipfmt)-1),
1086                "GetClipboardFormatName failed, error %d\n", GetLastError());
1087             ok(!lstrcmp(clipfmt, mime_type), "clipformat != mime_type, \"%s\" != \"%s\"\n",
1088                clipfmt, mime_type);
1089         } else {
1090             ok(pformatetc->cfFormat == 0, "clipformat=%x\n", pformatetc->cfFormat);
1091         }
1092         ok(pformatetc->ptd == NULL, "ptd = %p\n", pformatetc->ptd);
1093         ok(pformatetc->dwAspect == 1, "dwAspect=%u\n", pformatetc->dwAspect);
1094         ok(pformatetc->lindex == -1, "lindex=%d\n", pformatetc->lindex);
1095         ok(pformatetc->tymed == TYMED_ISTREAM, "tymed=%u\n", pformatetc->tymed);
1096     }
1097
1098     ok(pstgmed != NULL, "stgmeg == NULL\n");
1099     if(pstgmed) {
1100         ok(pstgmed->tymed == TYMED_ISTREAM, "tymed=%u\n", pstgmed->tymed);
1101         ok(U(*pstgmed).pstm != NULL, "pstm == NULL\n");
1102         ok(pstgmed->pUnkForRelease != NULL, "pUnkForRelease == NULL\n");
1103     }
1104
1105     if(grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
1106         hres = IStream_Write(U(*pstgmed).pstm, buf, 10, NULL);
1107         ok(hres == STG_E_ACCESSDENIED,
1108            "Write failed: %08x, expected STG_E_ACCESSDENIED\n", hres);
1109
1110         hres = IStream_Commit(U(*pstgmed).pstm, 0);
1111         ok(hres == E_NOTIMPL, "Commit failed: %08x, expected E_NOTIMPL\n", hres);
1112
1113         hres = IStream_Revert(U(*pstgmed).pstm);
1114         ok(hres == E_NOTIMPL, "Revert failed: %08x, expected E_NOTIMPL\n", hres);
1115     }
1116
1117     ok(U(*pstgmed).pstm != NULL, "U(*pstgmed).pstm == NULL\n");
1118
1119     if(U(*pstgmed).pstm) {
1120         do hres = IStream_Read(U(*pstgmed).pstm, buf, 512, &readed);
1121         while(hres == S_OK);
1122         ok(hres == S_FALSE || hres == E_PENDING, "IStream_Read returned %08x\n", hres);
1123     }
1124
1125     if(test_protocol == HTTP_TEST && emulate_protocol && prot_state < 4)
1126         SetEvent(complete_event);
1127
1128     return S_OK;
1129 }
1130
1131 static HRESULT WINAPI statusclb_OnObjectAvailable(IBindStatusCallback *iface, REFIID riid, IUnknown *punk)
1132 {
1133     CHECK_EXPECT(OnObjectAvailable);
1134     return S_OK;
1135 }
1136
1137 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
1138     statusclb_QueryInterface,
1139     statusclb_AddRef,
1140     statusclb_Release,
1141     statusclb_OnStartBinding,
1142     statusclb_GetPriority,
1143     statusclb_OnLowResource,
1144     statusclb_OnProgress,
1145     statusclb_OnStopBinding,
1146     statusclb_GetBindInfo,
1147     statusclb_OnDataAvailable,
1148     statusclb_OnObjectAvailable
1149 };
1150
1151 static IBindStatusCallback bsc = { &BindStatusCallbackVtbl };
1152
1153 static void test_CreateAsyncBindCtx(void)
1154 {
1155     IBindCtx *bctx = (IBindCtx*)0x0ff00ff0;
1156     IUnknown *unk;
1157     HRESULT hres;
1158     ULONG ref;
1159     BIND_OPTS bindopts;
1160
1161     hres = CreateAsyncBindCtx(0, NULL, NULL, &bctx);
1162     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
1163     ok(bctx == (IBindCtx*)0x0ff00ff0, "bctx should not be changed\n");
1164
1165     hres = CreateAsyncBindCtx(0, NULL, NULL, NULL);
1166     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
1167
1168     SET_EXPECT(QueryInterface_IServiceProvider);
1169     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
1170     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n", hres);
1171     CHECK_CALLED(QueryInterface_IServiceProvider);
1172
1173     bindopts.cbStruct = sizeof(bindopts);
1174     hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1175     ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1176     ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1177                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1178     ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1179                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1180                 bindopts.grfMode);
1181     ok(bindopts.dwTickCountDeadline == 0,
1182                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1183
1184     hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
1185     ok(hres == E_NOINTERFACE, "QueryInterface(IID_IAsyncBindCtx) failed: %08x, expected E_NOINTERFACE\n", hres);
1186     if(SUCCEEDED(hres))
1187         IUnknown_Release(unk);
1188
1189     ref = IBindCtx_Release(bctx);
1190     ok(ref == 0, "bctx should be destroyed here\n");
1191 }
1192
1193 static void test_CreateAsyncBindCtxEx(void)
1194 {
1195     IBindCtx *bctx = NULL, *bctx_arg = NULL;
1196     IUnknown *unk;
1197     BIND_OPTS bindopts;
1198     HRESULT hres;
1199
1200     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, NULL, 0);
1201     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed: %08x, expected E_INVALIDARG\n", hres);
1202
1203     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
1204     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1205
1206     if(SUCCEEDED(hres)) {
1207         bindopts.cbStruct = sizeof(bindopts);
1208         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1209         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1210         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1211                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1212         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1213                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1214                 bindopts.grfMode);
1215         ok(bindopts.dwTickCountDeadline == 0,
1216                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1217
1218         IBindCtx_Release(bctx);
1219     }
1220
1221     CreateBindCtx(0, &bctx_arg);
1222     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
1223     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1224
1225     if(SUCCEEDED(hres)) {
1226         bindopts.cbStruct = sizeof(bindopts);
1227         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1228         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1229         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1230                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1231         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1232                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1233                 bindopts.grfMode);
1234         ok(bindopts.dwTickCountDeadline == 0,
1235                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1236
1237         IBindCtx_Release(bctx);
1238     }
1239
1240     IBindCtx_Release(bctx_arg);
1241
1242     SET_EXPECT(QueryInterface_IServiceProvider);
1243     hres = CreateAsyncBindCtxEx(NULL, 0, &bsc, NULL, &bctx, 0);
1244     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1245     CHECK_CALLED(QueryInterface_IServiceProvider);
1246
1247     hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
1248     ok(hres == S_OK, "QueryInterface(IID_IAsyncBindCtx) failed: %08x\n", hres);
1249     if(SUCCEEDED(hres))
1250         IUnknown_Release(unk);
1251
1252     if(SUCCEEDED(hres))
1253         IBindCtx_Release(bctx);
1254 }
1255
1256 static void test_bscholder(IBindStatusCallback *holder)
1257 {
1258     IServiceProvider *serv_prov;
1259     IHttpNegotiate *http_negotiate, *http_negotiate_serv;
1260     IHttpNegotiate2 *http_negotiate2, *http_negotiate2_serv;
1261     IAuthenticate *authenticate, *authenticate_serv;
1262     IInternetProtocol *protocol;
1263     BINDINFO bindinfo = {sizeof(bindinfo)};
1264     LPWSTR wstr;
1265     DWORD dw;
1266     HRESULT hres;
1267
1268     static const WCHAR emptyW[] = {0};
1269
1270     hres = IBindStatusCallback_QueryInterface(holder, &IID_IServiceProvider, (void**)&serv_prov);
1271     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
1272
1273     dw = 0xdeadbeef;
1274     SET_EXPECT(GetBindInfo);
1275     hres = IBindStatusCallback_GetBindInfo(holder, &dw, &bindinfo);
1276     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
1277     CHECK_CALLED(GetBindInfo);
1278
1279     SET_EXPECT(OnStartBinding);
1280     hres = IBindStatusCallback_OnStartBinding(holder, 0, (void*)0xdeadbeef);
1281     ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
1282     CHECK_CALLED(OnStartBinding);
1283
1284     hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate, (void**)&http_negotiate);
1285     ok(hres == S_OK, "Could not get IHttpNegotiate interface: %08x\n", hres);
1286
1287     wstr = (void*)0xdeadbeef;
1288     hres = IHttpNegotiate_BeginningTransaction(http_negotiate, urls[test_protocol], (void*)0xdeadbeef, 0xff, &wstr);
1289     ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
1290     ok(wstr == NULL, "wstr = %p\n", wstr);
1291
1292     SET_EXPECT(QueryInterface_IHttpNegotiate);
1293     hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
1294                                          (void**)&http_negotiate_serv);
1295     ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
1296     CHECK_CALLED(QueryInterface_IHttpNegotiate);
1297
1298     ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
1299
1300     wstr = (void*)0xdeadbeef;
1301     SET_EXPECT(BeginningTransaction);
1302     hres = IHttpNegotiate_BeginningTransaction(http_negotiate_serv, urls[test_protocol], emptyW, 0, &wstr);
1303     CHECK_CALLED(BeginningTransaction);
1304     ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
1305     ok(wstr == NULL, "wstr = %p\n", wstr);
1306
1307     IHttpNegotiate_Release(http_negotiate_serv);
1308
1309     hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
1310                                          (void**)&http_negotiate_serv);
1311     ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
1312     ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
1313     IHttpNegotiate_Release(http_negotiate_serv);
1314
1315     hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate2, (void**)&http_negotiate2);
1316     ok(hres == S_OK, "Could not get IHttpNegotiate2 interface: %08x\n", hres);
1317
1318     hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, (void*)0xdeadbeef, (void*)0xdeadbeef, 0);
1319     ok(hres == E_FAIL, "GetRootSecurityId failed: %08x\n", hres);
1320
1321     IHttpNegotiate_Release(http_negotiate2);
1322
1323     SET_EXPECT(QueryInterface_IHttpNegotiate2);
1324     hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate2, &IID_IHttpNegotiate2,
1325                                          (void**)&http_negotiate2_serv);
1326     ok(hres == S_OK, "Could not get IHttpNegotiate2 service: %08x\n", hres);
1327     CHECK_CALLED(QueryInterface_IHttpNegotiate2);
1328     ok(http_negotiate2 == http_negotiate2_serv, "http_negotiate != http_negotiate_serv\n");
1329
1330     SET_EXPECT(GetRootSecurityId);
1331     hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, (void*)0xdeadbeef, (void*)0xdeadbeef, 0);
1332     ok(hres == E_NOTIMPL, "GetRootSecurityId failed: %08x\n", hres);
1333     CHECK_CALLED(GetRootSecurityId);
1334
1335     IHttpNegotiate_Release(http_negotiate2_serv);
1336
1337     SET_EXPECT(OnProgress_FINDINGRESOURCE);
1338     hres = IBindStatusCallback_OnProgress(holder, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
1339     ok(hres == S_OK, "OnProgress failed: %08x\n", hres);
1340     CHECK_CALLED(OnProgress_FINDINGRESOURCE);
1341
1342     SET_EXPECT(OnResponse);
1343     wstr = (void*)0xdeadbeef;
1344     hres = IHttpNegotiate_OnResponse(http_negotiate, 200, emptyW, NULL, NULL);
1345     ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
1346     CHECK_CALLED(OnResponse);
1347
1348     IHttpNegotiate_Release(http_negotiate);
1349
1350     hres = IBindStatusCallback_QueryInterface(holder, &IID_IAuthenticate, (void**)&authenticate);
1351     ok(hres == S_OK, "Could not get IAuthenticate interface: %08x\n", hres);
1352
1353     SET_EXPECT(QueryInterface_IAuthenticate);
1354     SET_EXPECT(QueryService_IAuthenticate);
1355     hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
1356                                          (void**)&authenticate_serv);
1357     ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
1358     CHECK_CALLED(QueryInterface_IAuthenticate);
1359     CHECK_CALLED(QueryService_IAuthenticate);
1360     ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
1361     IAuthenticate_Release(authenticate_serv);
1362
1363     hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
1364                                          (void**)&authenticate_serv);
1365     ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
1366     ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
1367
1368     IAuthenticate_Release(authenticate);
1369     IAuthenticate_Release(authenticate_serv);
1370
1371     SET_EXPECT(OnStopBinding);
1372     hres = IBindStatusCallback_OnStopBinding(holder, S_OK, NULL);
1373     ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
1374     CHECK_CALLED(OnStopBinding);
1375
1376     SET_EXPECT(QueryInterface_IInternetProtocol);
1377     SET_EXPECT(QueryService_IInternetProtocol);
1378     hres = IServiceProvider_QueryService(serv_prov, &IID_IInternetProtocol, &IID_IInternetProtocol,
1379                                          (void**)&protocol);
1380     ok(hres == E_NOINTERFACE, "QueryService(IInternetProtocol) failed: %08x\n", hres);
1381     CHECK_CALLED(QueryInterface_IInternetProtocol);
1382     CHECK_CALLED(QueryService_IInternetProtocol);
1383
1384     IServiceProvider_Release(serv_prov);
1385 }
1386
1387 static void test_RegisterBindStatusCallback(void)
1388 {
1389     IBindStatusCallback *prevbsc, *clb;
1390     IBindCtx *bindctx;
1391     IUnknown *unk;
1392     HRESULT hres;
1393
1394     hres = CreateBindCtx(0, &bindctx);
1395     ok(hres == S_OK, "BindCtx failed: %08x\n", hres);
1396
1397     SET_EXPECT(QueryInterface_IServiceProvider);
1398
1399     hres = IBindCtx_RegisterObjectParam(bindctx, BSCBHolder, (IUnknown*)&bsc);
1400     ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
1401
1402     SET_EXPECT(QueryInterface_IBindStatusCallback);
1403     SET_EXPECT(QueryInterface_IBindStatusCallbackHolder);
1404     prevbsc = (void*)0xdeadbeef;
1405     hres = RegisterBindStatusCallback(bindctx, &bsc, &prevbsc, 0);
1406     ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
1407     ok(prevbsc == &bsc, "prevbsc=%p\n", prevbsc);
1408     CHECK_CALLED(QueryInterface_IBindStatusCallback);
1409     CHECK_CALLED(QueryInterface_IBindStatusCallbackHolder);
1410
1411     CHECK_CALLED(QueryInterface_IServiceProvider);
1412
1413     hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
1414     ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
1415
1416     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
1417     IUnknown_Release(unk);
1418     ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
1419     ok(clb != &bsc, "bsc == clb\n");
1420
1421     test_bscholder(clb);
1422
1423     IBindStatusCallback_Release(clb);
1424
1425     hres = RevokeBindStatusCallback(bindctx, &bsc);
1426     ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
1427
1428     unk = (void*)0xdeadbeef;
1429     hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
1430     ok(hres == E_FAIL, "GetObjectParam failed: %08x\n", hres);
1431     ok(unk == NULL, "unk != NULL\n");
1432
1433     if(unk)
1434         IUnknown_Release(unk);
1435
1436     hres = RevokeBindStatusCallback(bindctx, (void*)0xdeadbeef);
1437     ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
1438
1439     hres = RevokeBindStatusCallback(NULL, (void*)0xdeadbeef);
1440     ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
1441
1442     hres = RevokeBindStatusCallback(bindctx, NULL);
1443     ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
1444
1445     IBindCtx_Release(bindctx);
1446 }
1447
1448 static void test_BindToStorage(int protocol, BOOL emul)
1449 {
1450     IMoniker *mon;
1451     HRESULT hres;
1452     LPOLESTR display_name;
1453     IBindCtx *bctx;
1454     MSG msg;
1455     IBindStatusCallback *previousclb;
1456     IUnknown *unk = (IUnknown*)0x00ff00ff;
1457     IBinding *bind;
1458
1459     test_protocol = protocol;
1460     emulate_protocol = emul;
1461     download_state = BEFORE_DOWNLOAD;
1462     stopped_binding = FALSE;
1463     data_available = FALSE;
1464     mime_type[0] = 0;
1465
1466     SET_EXPECT(QueryInterface_IServiceProvider);
1467     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
1468     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
1469     CHECK_CALLED(QueryInterface_IServiceProvider);
1470     if(FAILED(hres))
1471         return;
1472
1473     SET_EXPECT(QueryInterface_IServiceProvider);
1474     hres = RegisterBindStatusCallback(bctx, &bsc, &previousclb, 0);
1475     ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
1476     ok(previousclb == &bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
1477     CHECK_CALLED(QueryInterface_IServiceProvider);
1478     if(previousclb)
1479         IBindStatusCallback_Release(previousclb);
1480
1481     hres = CreateURLMoniker(NULL, urls[test_protocol], &mon);
1482     ok(SUCCEEDED(hres), "failed to create moniker: %08x\n", hres);
1483     if(FAILED(hres)) {
1484         IBindCtx_Release(bctx);
1485         return;
1486     }
1487
1488     if(test_protocol == FILE_TEST && INDEX_HTML[7] == '/')
1489         memmove(INDEX_HTML+7, INDEX_HTML+8, lstrlenW(INDEX_HTML+7)*sizeof(WCHAR));
1490
1491     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
1492     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
1493     if(SUCCEEDED(hres))
1494         IBinding_Release(bind);
1495
1496     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
1497     ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
1498     ok(!lstrcmpW(display_name, urls[test_protocol]), "GetDisplayName got wrong name\n");
1499
1500     SET_EXPECT(GetBindInfo);
1501     SET_EXPECT(QueryInterface_IInternetProtocol);
1502     if(!emulate_protocol)
1503         SET_EXPECT(QueryService_IInternetProtocol);
1504     SET_EXPECT(OnStartBinding);
1505     if(emulate_protocol) {
1506         SET_EXPECT(Start);
1507         if(test_protocol == HTTP_TEST)
1508             SET_EXPECT(Terminate);
1509         SET_EXPECT(UnlockRequest);
1510     }else {
1511         if(test_protocol == HTTP_TEST) {
1512             SET_EXPECT(QueryInterface_IHttpNegotiate);
1513             SET_EXPECT(BeginningTransaction);
1514             SET_EXPECT(QueryInterface_IHttpNegotiate2);
1515             SET_EXPECT(GetRootSecurityId);
1516             SET_EXPECT(OnProgress_FINDINGRESOURCE);
1517             SET_EXPECT(OnProgress_CONNECTING);
1518         }
1519         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
1520             SET_EXPECT(OnProgress_SENDINGREQUEST);
1521         if(test_protocol == HTTP_TEST)
1522             SET_EXPECT(OnResponse);
1523         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1524         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1525         if(test_protocol == HTTP_TEST)
1526             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
1527         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
1528         SET_EXPECT(OnDataAvailable);
1529         SET_EXPECT(OnStopBinding);
1530     }
1531
1532     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
1533     if (test_protocol == HTTP_TEST && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
1534     {
1535         trace( "Network unreachable, skipping tests\n" );
1536         return;
1537     }
1538     if (!SUCCEEDED(hres)) return;
1539
1540     if((bindf & BINDF_ASYNCHRONOUS) && !data_available) {
1541         ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
1542         ok(unk == NULL, "istr should be NULL\n");
1543     }else {
1544         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
1545         ok(unk != NULL, "unk == NULL\n");
1546     }
1547     if(unk)
1548         IUnknown_Release(unk);
1549
1550     while((bindf & BINDF_ASYNCHRONOUS) &&
1551           !stopped_binding && GetMessage(&msg,NULL,0,0)) {
1552         TranslateMessage(&msg);
1553         DispatchMessage(&msg);
1554     }
1555
1556     CHECK_CALLED(GetBindInfo);
1557     CHECK_CALLED(QueryInterface_IInternetProtocol);
1558     if(!emulate_protocol)
1559         CHECK_CALLED(QueryService_IInternetProtocol);
1560     CHECK_CALLED(OnStartBinding);
1561     if(emulate_protocol) {
1562         CHECK_CALLED(Start);
1563         if(test_protocol == HTTP_TEST)
1564             CHECK_CALLED(Terminate);
1565         CHECK_CALLED(UnlockRequest);
1566     }else {
1567         if(test_protocol == HTTP_TEST) {
1568             CHECK_CALLED(QueryInterface_IHttpNegotiate);
1569             CHECK_CALLED(BeginningTransaction);
1570             /* QueryInterface_IHttpNegotiate2 and GetRootSecurityId
1571              * called on WinXP but not on Win98 */
1572             CLEAR_CALLED(QueryInterface_IHttpNegotiate2);
1573             CLEAR_CALLED(GetRootSecurityId);
1574             if(http_is_first) {
1575                 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
1576                 CHECK_CALLED(OnProgress_CONNECTING);
1577             }else todo_wine {
1578                 CHECK_NOT_CALLED(OnProgress_FINDINGRESOURCE);
1579                 CHECK_NOT_CALLED(OnProgress_CONNECTING);
1580             }
1581         }
1582         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
1583             CHECK_CALLED(OnProgress_SENDINGREQUEST);
1584         if(test_protocol == HTTP_TEST)
1585             CHECK_CALLED(OnResponse);
1586         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
1587         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
1588         if(test_protocol == HTTP_TEST)
1589             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
1590         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
1591         CHECK_CALLED(OnDataAvailable);
1592         CHECK_CALLED(OnStopBinding);
1593     }
1594
1595     ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
1596     ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
1597
1598     if(test_protocol == HTTP_TEST)
1599         http_is_first = FALSE;
1600 }
1601
1602 static void test_BindToObject(int protocol, BOOL emul)
1603 {
1604     IMoniker *mon;
1605     HRESULT hres;
1606     LPOLESTR display_name;
1607     IBindCtx *bctx;
1608     MSG msg;
1609     IBindStatusCallback *previousclb;
1610     IUnknown *unk = (IUnknown*)0x00ff00ff;
1611     IBinding *bind;
1612
1613     test_protocol = protocol;
1614     emulate_protocol = emul;
1615     download_state = BEFORE_DOWNLOAD;
1616     stopped_binding = FALSE;
1617     data_available = FALSE;
1618     mime_type[0] = 0;
1619
1620     SET_EXPECT(QueryInterface_IServiceProvider);
1621     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
1622     ok(SUCCEEDED(hres), "CreateAsyncBindCtx failed: %08x\n\n", hres);
1623     if(FAILED(hres))
1624         return;
1625     CHECK_CALLED(QueryInterface_IServiceProvider);
1626
1627     SET_EXPECT(QueryInterface_IServiceProvider);
1628     hres = RegisterBindStatusCallback(bctx, &bsc, &previousclb, 0);
1629     ok(SUCCEEDED(hres), "RegisterBindStatusCallback failed: %08x\n", hres);
1630     ok(previousclb == &bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
1631     CHECK_CALLED(QueryInterface_IServiceProvider);
1632     if(previousclb)
1633         IBindStatusCallback_Release(previousclb);
1634
1635     hres = CreateURLMoniker(NULL, urls[test_protocol], &mon);
1636     ok(SUCCEEDED(hres), "failed to create moniker: %08x\n", hres);
1637     if(FAILED(hres)) {
1638         IBindCtx_Release(bctx);
1639         return;
1640     }
1641
1642     if(test_protocol == FILE_TEST && INDEX_HTML[7] == '/')
1643         memmove(INDEX_HTML+7, INDEX_HTML+8, lstrlenW(INDEX_HTML+7)*sizeof(WCHAR));
1644
1645     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
1646     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
1647     if(SUCCEEDED(hres))
1648         IBinding_Release(bind);
1649
1650     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
1651     ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
1652     ok(!lstrcmpW(display_name, urls[test_protocol]), "GetDisplayName got wrong name\n");
1653
1654     SET_EXPECT(QueryInterface_IServiceProvider);
1655     SET_EXPECT(GetBindInfo);
1656     SET_EXPECT(OnStartBinding);
1657     if(emulate_protocol) {
1658         SET_EXPECT(Start);
1659         SET_EXPECT(UnlockRequest);
1660     }else {
1661         if(test_protocol == HTTP_TEST) {
1662             SET_EXPECT(QueryInterface_IHttpNegotiate);
1663             SET_EXPECT(BeginningTransaction);
1664             SET_EXPECT(QueryInterface_IHttpNegotiate2);
1665             SET_EXPECT(GetRootSecurityId);
1666             SET_EXPECT(OnProgress_FINDINGRESOURCE);
1667             SET_EXPECT(OnProgress_CONNECTING);
1668         }
1669         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
1670             SET_EXPECT(OnProgress_SENDINGREQUEST);
1671         if(test_protocol == HTTP_TEST)
1672             SET_EXPECT(OnResponse);
1673         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1674         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1675         if(test_protocol == HTTP_TEST)
1676             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
1677         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
1678         SET_EXPECT(OnProgress_CLASSIDAVAILABLE);
1679         SET_EXPECT(OnProgress_BEGINSYNCOPERATION);
1680         SET_EXPECT(OnProgress_ENDSYNCOPERATION);
1681         SET_EXPECT(OnObjectAvailable);
1682         SET_EXPECT(OnStopBinding);
1683     }
1684
1685     hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
1686     if (test_protocol == HTTP_TEST && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
1687     {
1688         trace( "Network unreachable, skipping tests\n" );
1689         return;
1690     }
1691     todo_wine ok(SUCCEEDED(hres), "IMoniker_BindToObject failed with error 0x%08x\n", hres);
1692     /* no point testing the calls if binding didn't even work */
1693     if (!SUCCEEDED(hres)) return;
1694
1695     if((bindf & BINDF_ASYNCHRONOUS) && !data_available) {
1696         ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
1697         ok(unk == NULL, "istr should be NULL\n");
1698     }else {
1699         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
1700         ok(unk != NULL, "unk == NULL\n");
1701     }
1702     if(unk)
1703         IUnknown_Release(unk);
1704
1705     while((bindf & BINDF_ASYNCHRONOUS) &&
1706           !stopped_binding && GetMessage(&msg,NULL,0,0)) {
1707         TranslateMessage(&msg);
1708         DispatchMessage(&msg);
1709     }
1710
1711     todo_wine CHECK_NOT_CALLED(QueryInterface_IServiceProvider);
1712     CHECK_CALLED(GetBindInfo);
1713     CHECK_CALLED(OnStartBinding);
1714     if(emulate_protocol) {
1715         CHECK_CALLED(Start);
1716         CHECK_CALLED(UnlockRequest);
1717     }else {
1718         if(test_protocol == HTTP_TEST) {
1719             CHECK_CALLED(QueryInterface_IHttpNegotiate);
1720             CHECK_CALLED(BeginningTransaction);
1721             /* QueryInterface_IHttpNegotiate2 and GetRootSecurityId
1722              * called on WinXP but not on Win98 */
1723             CLEAR_CALLED(QueryInterface_IHttpNegotiate2);
1724             CLEAR_CALLED(GetRootSecurityId);
1725             if(http_is_first) {
1726                 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
1727                 CHECK_CALLED(OnProgress_CONNECTING);
1728             }else todo_wine {
1729                 CHECK_NOT_CALLED(OnProgress_FINDINGRESOURCE);
1730                 CHECK_NOT_CALLED(OnProgress_CONNECTING);
1731             }
1732         }
1733         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
1734             CHECK_CALLED(OnProgress_SENDINGREQUEST);
1735         if(test_protocol == HTTP_TEST)
1736             CHECK_CALLED(OnResponse);
1737         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
1738         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
1739         if(test_protocol == HTTP_TEST)
1740             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
1741         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
1742         CHECK_CALLED(OnProgress_CLASSIDAVAILABLE);
1743         CHECK_CALLED(OnProgress_BEGINSYNCOPERATION);
1744         CHECK_CALLED(OnProgress_ENDSYNCOPERATION);
1745         CHECK_CALLED(OnObjectAvailable);
1746         CHECK_CALLED(OnStopBinding);
1747     }
1748
1749     ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
1750     ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
1751
1752     if(test_protocol == HTTP_TEST)
1753         http_is_first = FALSE;
1754 }
1755
1756 static void set_file_url(void)
1757 {
1758     int len;
1759
1760     static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
1761
1762     memcpy(INDEX_HTML, wszFile, sizeof(wszFile));
1763     len = sizeof(wszFile)/sizeof(WCHAR);
1764     INDEX_HTML[len++] = '/';
1765     len += GetCurrentDirectoryW(sizeof(INDEX_HTML)/sizeof(WCHAR)-len, INDEX_HTML+len);
1766     INDEX_HTML[len++] = '\\';
1767     memcpy(INDEX_HTML+len, wszIndexHtml, sizeof(wszIndexHtml));
1768 }
1769
1770 static void create_file(void)
1771 {
1772     HANDLE file;
1773     DWORD size;
1774
1775     static const char html_doc[] = "<HTML></HTML>";
1776
1777     file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1778             FILE_ATTRIBUTE_NORMAL, NULL);
1779     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
1780     if(file == INVALID_HANDLE_VALUE)
1781         return;
1782
1783     WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
1784     CloseHandle(file);
1785
1786     set_file_url();
1787 }
1788
1789 static void test_BindToStorage_fail(void)
1790 {
1791     IMoniker *mon = NULL;
1792     IBindCtx *bctx = NULL;
1793     IUnknown *unk;
1794     HRESULT hres;
1795
1796     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
1797     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
1798     if(FAILED(hres))
1799         return;
1800
1801     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
1802     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1803
1804     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
1805     ok(hres == MK_E_SYNTAX, "hres=%08x, expected INET_E_SYNTAX\n", hres);
1806
1807     IBindCtx_Release(bctx);
1808
1809     IMoniker_Release(mon);
1810 }
1811
1812 START_TEST(url)
1813 {
1814     complete_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1815     complete_event2 = CreateEvent(NULL, FALSE, FALSE, NULL);
1816     thread_id = GetCurrentThreadId();
1817
1818     test_create();
1819     test_CreateAsyncBindCtx();
1820     test_CreateAsyncBindCtxEx();
1821     test_RegisterBindStatusCallback();
1822
1823     trace("synchronous http test (COM not initialised)...\n");
1824     test_BindToStorage(HTTP_TEST, FALSE);
1825     test_BindToStorage_fail();
1826
1827     CoInitialize(NULL);
1828
1829     trace("synchronous http test...\n");
1830     test_BindToStorage(HTTP_TEST, FALSE);
1831     test_BindToObject(HTTP_TEST, FALSE);
1832
1833     trace("synchronous file test...\n");
1834     create_file();
1835     test_BindToStorage(FILE_TEST, FALSE);
1836     test_BindToObject(FILE_TEST, FALSE);
1837     DeleteFileW(wszIndexHtml);
1838
1839     bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
1840
1841     trace("http test...\n");
1842     test_BindToStorage(HTTP_TEST, FALSE);
1843     test_BindToObject(HTTP_TEST, FALSE);
1844
1845     trace("http test (short response)...\n");
1846     http_is_first = TRUE;
1847     urls[HTTP_TEST] = SHORT_RESPONSE_URL;
1848     test_BindToStorage(HTTP_TEST, FALSE);
1849     test_BindToObject(HTTP_TEST, FALSE);
1850
1851     trace("emulated http test...\n");
1852     test_BindToStorage(HTTP_TEST, TRUE);
1853
1854     trace("about test...\n");
1855     test_BindToStorage(ABOUT_TEST, FALSE);
1856     test_BindToObject(ABOUT_TEST, FALSE);
1857
1858     trace("emulated about test...\n");
1859     test_BindToStorage(ABOUT_TEST, TRUE);
1860
1861     trace("file test...\n");
1862     create_file();
1863     test_BindToStorage(FILE_TEST, FALSE);
1864     test_BindToObject(FILE_TEST, FALSE);
1865     DeleteFileW(wszIndexHtml);
1866
1867     trace("emulated file test...\n");
1868     set_file_url();
1869     test_BindToStorage(FILE_TEST, TRUE);
1870
1871     trace("emulated its test...\n");
1872     test_BindToStorage(ITS_TEST, TRUE);
1873
1874     trace("emulated mk test...\n");
1875     test_BindToStorage(MK_TEST, TRUE);
1876
1877     test_BindToStorage_fail();
1878
1879     CloseHandle(complete_event);
1880     CloseHandle(complete_event2);
1881     CoUninitialize();
1882 }