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 NONAMELESSUNION
  27 #define CONST_VTABLE
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "initguid.h"
  32 #include "urlmon.h"
  33 #include "wininet.h"
  34 #include "mshtml.h"
  35
  36 #include "wine/test.h"
  37
  38 static HRESULT (WINAPI *pCreateAsyncBindCtxEx)(IBindCtx *, DWORD,
  39                 IBindStatusCallback *, IEnumFORMATETC *, IBindCtx **, DWORD);
  40
  41
  42 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  43 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  44 DEFINE_GUID(IID_IBindStatusCallbackHolder,0x79eac9cc,0xbaf9,0x11ce,0x8c,0x82,0x00,0xaa,0x00,0x4b,0xa9,0x0b);
  45
  46 #define DEFINE_EXPECT(func) \
  47     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  48
  49 #define SET_EXPECT(func) \
  50     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  51
  52 #define CHECK_EXPECT2(func) \
  53     do { \
  54         ok(expect_ ##func, "unexpected call " #func "\n"); \
  55         called_ ## func = TRUE; \
  56     }while(0)
  57
  58 #define CHECK_EXPECT(func) \
  59     do { \
  60         CHECK_EXPECT2(func); \
  61         expect_ ## func = FALSE; \
  62     }while(0)
  63
  64 #define CHECK_CALLED(func) \
  65     do { \
  66         ok(called_ ## func, "expected " #func "\n"); \
  67         expect_ ## func = called_ ## func = FALSE; \
  68     }while(0)
  69
  70 #define CHECK_NOT_CALLED(func) \
  71     do { \
  72         ok(!called_ ## func, "unexpected " #func "\n"); \
  73         expect_ ## func = called_ ## func = FALSE; \
  74     }while(0)
  75
  76 #define CHECK_CALLED_BROKEN(func) \
  77     do { \
  78         ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
  79         expect_ ## func = called_ ## func = FALSE; \
  80     }while(0)
  81
  82 #define CLEAR_CALLED(func) \
  83     expect_ ## func = called_ ## func = FALSE
  84
  85 DEFINE_EXPECT(QueryInterface_IServiceProvider);
  86 DEFINE_EXPECT(QueryInterface_IHttpNegotiate);
  87 DEFINE_EXPECT(QueryInterface_IBindStatusCallback);
  88 DEFINE_EXPECT(QueryInterface_IBindStatusCallbackEx);
  89 DEFINE_EXPECT(QueryInterface_IBindStatusCallbackHolder);
  90 DEFINE_EXPECT(QueryInterface_IInternetBindInfo);
  91 DEFINE_EXPECT(QueryInterface_IAuthenticate);
  92 DEFINE_EXPECT(QueryInterface_IInternetProtocol);
  93 DEFINE_EXPECT(QueryInterface_IWindowForBindingUI);
  94 DEFINE_EXPECT(QueryService_IAuthenticate);
  95 DEFINE_EXPECT(QueryService_IInternetProtocol);
  96 DEFINE_EXPECT(QueryService_IInternetBindInfo);
  97 DEFINE_EXPECT(QueryService_IWindowForBindingUI);
  98 DEFINE_EXPECT(BeginningTransaction);
  99 DEFINE_EXPECT(OnResponse);
 100 DEFINE_EXPECT(QueryInterface_IHttpNegotiate2);
 101 DEFINE_EXPECT(GetRootSecurityId);
 102 DEFINE_EXPECT(GetBindInfo);
 103 DEFINE_EXPECT(GetBindInfoEx);
 104 DEFINE_EXPECT(OnStartBinding);
 105 DEFINE_EXPECT(OnProgress_FINDINGRESOURCE);
 106 DEFINE_EXPECT(OnProgress_CONNECTING);
 107 DEFINE_EXPECT(OnProgress_REDIRECTING);
 108 DEFINE_EXPECT(OnProgress_SENDINGREQUEST);
 109 DEFINE_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 110 DEFINE_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 111 DEFINE_EXPECT(OnProgress_DOWNLOADINGDATA);
 112 DEFINE_EXPECT(OnProgress_ENDDOWNLOADDATA);
 113 DEFINE_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
 114 DEFINE_EXPECT(OnStopBinding);
 115 DEFINE_EXPECT(OnDataAvailable);
 116 DEFINE_EXPECT(OnObjectAvailable);
 117 DEFINE_EXPECT(Obj_OnStartBinding);
 118 DEFINE_EXPECT(Obj_OnStopBinding);
 119 DEFINE_EXPECT(Obj_GetBindInfo);
 120 DEFINE_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
 121 DEFINE_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
 122 DEFINE_EXPECT(Obj_OnProgress_SENDINGREQUEST);
 123 DEFINE_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
 124 DEFINE_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
 125 DEFINE_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
 126 DEFINE_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
 127 DEFINE_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
 128 DEFINE_EXPECT(Obj_OnProgress_CONNECTING);
 129 DEFINE_EXPECT(Obj_OnProgress_REDIRECTING);
 130 DEFINE_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
 131 DEFINE_EXPECT(Start);
 132 DEFINE_EXPECT(Read);
 133 DEFINE_EXPECT(LockRequest);
 134 DEFINE_EXPECT(Terminate);
 135 DEFINE_EXPECT(UnlockRequest);
 136 DEFINE_EXPECT(Continue);
 137 DEFINE_EXPECT(CreateInstance);
 138 DEFINE_EXPECT(Load);
 139 DEFINE_EXPECT(PutProperty_MIMETYPEPROP);
 140 DEFINE_EXPECT(PutProperty_CLASSIDPROP);
 141 DEFINE_EXPECT(SetPriority);
 142
 143 static const WCHAR TEST_URL_1[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/','\0'};
 144 static const WCHAR TEST_PART_URL_1[] = {'/','t','e','s','t','/','\0'};
 145
 146 static const WCHAR WINE_ABOUT_URL[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
 147                                        'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0};
 148 static const WCHAR SHORT_RESPONSE_URL[] =
 149         {'h','t','t','p',':','/','/','c','r','o','s','s','o','v','e','r','.',
 150          'c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
 151          'p','o','s','t','t','e','s','t','.','p','h','p',0};
 152 static const WCHAR ABOUT_BLANK[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 153 static WCHAR INDEX_HTML[MAX_PATH];
 154 static const WCHAR ITS_URL[] =
 155     {'i','t','s',':','t','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0};
 156 static const WCHAR MK_URL[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':',
 157     't','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0};
 158 static const WCHAR https_urlW[] =
 159     {'h','t','t','p','s',':','/','/','w','w','w','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',
 160      '/','t','e','s','t','.','h','t','m','l',0};
 161 static const WCHAR ftp_urlW[] = {'f','t','p',':','/','/','f','t','p','.','w','i','n','e','h','q','.','o','r','g',
 162     '/','p','u','b','/','o','t','h','e','r','/',
 163     'w','i','n','e','l','o','g','o','.','x','c','f','.','t','a','r','.','b','z','2',0};
 164
 165
 166 static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 167
 168 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
 169
 170 static const WCHAR wszWineHQSite[] =
 171     {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
 172 static const WCHAR wszWineHQIP[] =
 173     {'2','0','9','.','3','2','.','1','4','1','.','3',0};
 174 static const CHAR wszIndexHtmlA[] = "index.html";
 175 static const WCHAR wszIndexHtml[] = {'i','n','d','e','x','.','h','t','m','l',0};
 176 static const WCHAR cache_fileW[] = {'c',':','\\','c','a','c','h','e','.','h','t','m',0};
 177 static const CHAR dwl_htmlA[] = "dwl.html";
 178 static const WCHAR dwl_htmlW[] = {'d','w','l','.','h','t','m','l',0};
 179 static const WCHAR test_txtW[] = {'t','e','s','t','.','t','x','t',0};
 180 static const WCHAR emptyW[] = {0};
 181
 182 static BOOL stopped_binding = FALSE, stopped_obj_binding = FALSE, emulate_protocol = FALSE,
 183     data_available = FALSE, http_is_first = TRUE, bind_to_object = FALSE, filedwl_api;
 184 static DWORD read = 0, bindf = 0, prot_state = 0, thread_id, tymed;
 185 static CHAR mime_type[512];
 186 static IInternetProtocolSink *protocol_sink = NULL;
 187 static IBinding *current_binding;
 188 static HANDLE complete_event, complete_event2;
 189 static HRESULT binding_hres;
 190 static BOOL have_IHttpNegotiate2, use_bscex;
 191 static BOOL test_redirect, use_cache_file, callback_read;
 192 static WCHAR cache_file_name[MAX_PATH];
 193
 194 static LPCWSTR urls[] = {
 195     WINE_ABOUT_URL,
 196     ABOUT_BLANK,
 197     INDEX_HTML,
 198     ITS_URL,
 199     MK_URL,
 200     https_urlW,
 201     ftp_urlW
 202 };
 203
 204 static WCHAR file_url[INTERNET_MAX_URL_LENGTH];
 205
 206 static enum {
 207     HTTP_TEST,
 208     ABOUT_TEST,
 209     FILE_TEST,
 210     ITS_TEST,
 211     MK_TEST,
 212     HTTPS_TEST,
 213     FTP_TEST
 214 } test_protocol;
 215
 216 static enum {
 217     BEFORE_DOWNLOAD,
 218     DOWNLOADING,
 219     END_DOWNLOAD
 220 } download_state;
 221
 222 static const char *debugstr_guid(REFIID riid)
 223 {
 224     static char buf[50];
 225
 226     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 227             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 228             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 229             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 230
 231     return buf;
 232 }
 233
 234 static BOOL is_urlmon_protocol(int prot)
 235 {
 236     return prot == FILE_TEST || prot == HTTP_TEST || prot == HTTPS_TEST || prot == FTP_TEST || prot == MK_TEST;
 237 }
 238
 239 static void test_CreateURLMoniker(LPCWSTR url1, LPCWSTR url2)
 240 {
 241     HRESULT hr;
 242     IMoniker *mon1 = NULL;
 243     IMoniker *mon2 = NULL;
 244
 245     hr = CreateURLMoniker(NULL, url1, &mon1);
 246     ok(SUCCEEDED(hr), "failed to create moniker: 0x%08x\n", hr);
 247     if(SUCCEEDED(hr)) {
 248         hr = CreateURLMoniker(mon1, url2, &mon2);
 249         ok(SUCCEEDED(hr), "failed to create moniker: 0x%08x\n", hr);
 250     }
 251     if(mon1) IMoniker_Release(mon1);
 252     if(mon2) IMoniker_Release(mon2);
 253 }
 254
 255 static void test_create(void)
 256 {
 257     test_CreateURLMoniker(TEST_URL_1, TEST_PART_URL_1);
 258 }
 259
 260 static HRESULT WINAPI Priority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv)
 261 {
 262     ok(0, "unexpected call\n");
 263     return E_NOINTERFACE;
 264 }
 265
 266 static ULONG WINAPI Priority_AddRef(IInternetPriority *iface)
 267 {
 268     return 2;
 269 }
 270
 271 static ULONG WINAPI Priority_Release(IInternetPriority *iface)
 272 {
 273     return 1;
 274 }
 275
 276 static HRESULT WINAPI Priority_SetPriority(IInternetPriority *iface, LONG nPriority)
 277 {
 278     CHECK_EXPECT(SetPriority);
 279     ok(!nPriority, "nPriority = %d\n", nPriority);
 280     return S_OK;
 281 }
 282
 283 static HRESULT WINAPI Priority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
 284 {
 285     ok(0, "unexpected call\n");
 286     return S_OK;
 287 }
 288
 289 static const IInternetPriorityVtbl InternetPriorityVtbl = {
 290     Priority_QueryInterface,
 291     Priority_AddRef,
 292     Priority_Release,
 293     Priority_SetPriority,
 294     Priority_GetPriority
 295 };
 296
 297 static IInternetPriority InternetPriority = { &InternetPriorityVtbl };
 298
 299 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 300 {
 301     *ppv = NULL;
 302
 303     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
 304         *ppv = iface;
 305         return S_OK;
 306     }
 307
 308     if(IsEqualGUID(&IID_IInternetPriority, riid)) {
 309         if(!is_urlmon_protocol(test_protocol))
 310             return E_NOINTERFACE;
 311
 312         *ppv = &InternetPriority;
 313         return S_OK;
 314     }
 315
 316     if(IsEqualGUID(&IID_IInternetProtocolEx, riid))
 317         return E_NOINTERFACE; /* TODO */
 318
 319     ok(0, "unexpected call %s\n", debugstr_guid(riid));
 320     return E_NOINTERFACE;
 321 }
 322
 323 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
 324 {
 325     return 2;
 326 }
 327
 328 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
 329 {
 330     return 1;
 331 }
 332
 333 static void test_switch_fail(void)
 334 {
 335     IInternetProtocolSink *binding_sink;
 336     PROTOCOLDATA protocoldata;
 337     HRESULT hres;
 338
 339     static BOOL tested_switch_fail;
 340
 341     if(tested_switch_fail)
 342         return;
 343
 344     tested_switch_fail = TRUE;
 345
 346     hres = IBinding_QueryInterface(current_binding, &IID_IInternetProtocolSink, (void**)&binding_sink);
 347     ok(hres == S_OK, "Could not get IInternetProtocolSink iface: %08x\n", hres);
 348     if(SUCCEEDED(hres)) {
 349         hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
 350         ok(hres == E_FAIL, "Switch failed: %08x, expected E_FAIL\n", hres);
 351         IInternetProtocolSink_Release(binding_sink);
 352     }
 353 }
 354
 355 static DWORD WINAPI thread_proc(PVOID arg)
 356 {
 357     PROTOCOLDATA protocoldata;
 358     HRESULT hres;
 359
 360     if(bind_to_object)
 361         SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
 362     else
 363         SET_EXPECT(OnProgress_FINDINGRESOURCE);
 364     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 365             BINDSTATUS_FINDINGRESOURCE, wszWineHQSite);
 366     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 367     WaitForSingleObject(complete_event, INFINITE);
 368     if(bind_to_object)
 369         CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
 370     else
 371         CHECK_CALLED(OnProgress_FINDINGRESOURCE);
 372
 373     if(bind_to_object)
 374         SET_EXPECT(Obj_OnProgress_CONNECTING);
 375     else
 376         SET_EXPECT(OnProgress_CONNECTING);
 377     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 378             BINDSTATUS_CONNECTING, wszWineHQIP);
 379     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 380     WaitForSingleObject(complete_event, INFINITE);
 381     if(bind_to_object)
 382         CHECK_CALLED(Obj_OnProgress_CONNECTING);
 383     else
 384         CHECK_CALLED(OnProgress_CONNECTING);
 385
 386     if(bind_to_object)
 387         SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
 388     else
 389         SET_EXPECT(OnProgress_SENDINGREQUEST);
 390     hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 391             BINDSTATUS_SENDINGREQUEST, NULL);
 392     ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
 393     WaitForSingleObject(complete_event, INFINITE);
 394     if(bind_to_object)
 395         CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
 396     else
 397         CHECK_CALLED(OnProgress_SENDINGREQUEST);
 398
 399     if(test_redirect) {
 400         if(bind_to_object)
 401             SET_EXPECT(Obj_OnProgress_REDIRECTING);
 402         else
 403             SET_EXPECT(OnProgress_REDIRECTING);
 404         hres = IInternetProtocolSink_ReportProgress(protocol_sink, BINDSTATUS_REDIRECTING, WINE_ABOUT_URL);
 405         ok(hres == S_OK, "ReportProgress(BINDSTATUS_REFIRECTING) failed: %08x\n", hres);
 406         WaitForSingleObject(complete_event, INFINITE);
 407         if(bind_to_object)
 408             CHECK_CALLED(Obj_OnProgress_REDIRECTING);
 409         else
 410             CHECK_CALLED(OnProgress_REDIRECTING);
 411     }
 412
 413     test_switch_fail();
 414
 415     SET_EXPECT(Continue);
 416     prot_state = 1;
 417     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 418     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 419     WaitForSingleObject(complete_event, INFINITE);
 420
 421     CHECK_CALLED(Continue);
 422     CHECK_CALLED(Read);
 423     if(bind_to_object) {
 424         CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
 425         CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
 426         CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
 427         CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
 428         CHECK_CALLED(CreateInstance);
 429         CHECK_CALLED(PutProperty_MIMETYPEPROP);
 430         CHECK_CALLED_BROKEN(PutProperty_CLASSIDPROP);
 431         CHECK_CALLED(Load);
 432         CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
 433         CHECK_CALLED(OnObjectAvailable);
 434         CHECK_CALLED(Obj_OnStopBinding);
 435     }else {
 436         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 437         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 438         CHECK_CALLED(LockRequest);
 439         CHECK_CALLED(OnDataAvailable);
 440     }
 441
 442     SET_EXPECT(Continue);
 443     prot_state = 2;
 444     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 445     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 446     WaitForSingleObject(complete_event, INFINITE);
 447     CHECK_CALLED(Continue);
 448     CHECK_CALLED(Read);
 449     CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
 450     CHECK_CALLED(OnDataAvailable);
 451
 452     SET_EXPECT(Continue);
 453     prot_state = 2;
 454     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 455     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 456     WaitForSingleObject(complete_event, INFINITE);
 457     CHECK_CALLED(Continue);
 458     CHECK_CALLED(Read);
 459     CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
 460     CHECK_CALLED(OnDataAvailable);
 461
 462     SET_EXPECT(Continue);
 463     prot_state = 3;
 464     hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
 465     ok(hres == S_OK, "Switch failed: %08x\n", hres);
 466     WaitForSingleObject(complete_event, INFINITE);
 467     CHECK_CALLED(Continue);
 468     CHECK_CALLED(Read);
 469     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 470     CHECK_CALLED(OnDataAvailable);
 471     CHECK_CALLED(OnStopBinding);
 472
 473     SET_EXPECT(Read);
 474
 475     SetEvent(complete_event2);
 476     return 0;
 477 }
 478
 479 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 480         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 481         DWORD grfPI, HANDLE_PTR dwReserved)
 482 {
 483     BINDINFO bindinfo;
 484     DWORD bind_info, bscf = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION;
 485     HRESULT hres;
 486
 487     static const STGMEDIUM stgmed_zero = {0};
 488     static const SECURITY_ATTRIBUTES sa_zero = {0};
 489
 490     CHECK_EXPECT(Start);
 491
 492     read = 0;
 493
 494     if(!filedwl_api) /* FIXME */
 495         ok(szUrl && !lstrcmpW(szUrl, urls[test_protocol]), "wrong url %s\n", wine_dbgstr_w(szUrl));
 496     ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
 497     ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
 498     ok(grfPI == 0, "grfPI=%d, expected 0\n", grfPI);
 499     ok(dwReserved == 0, "dwReserved=%lx, expected 0\n", dwReserved);
 500
 501     if(!filedwl_api && binding_hres != S_OK) {
 502         SET_EXPECT(OnStopBinding);
 503         SET_EXPECT(Terminate);
 504         hres = IInternetProtocolSink_ReportResult(pOIProtSink, binding_hres, 0, NULL);
 505         ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 506         CHECK_CALLED(OnStopBinding);
 507         CHECK_CALLED(Terminate);
 508
 509         return S_OK;
 510     }
 511
 512     memset(&bindinfo, 0, sizeof(bindinfo));
 513     bindinfo.cbSize = sizeof(bindinfo);
 514     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bind_info, &bindinfo);
 515     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
 516
 517     ok(bind_info & BINDF_FROMURLMON, "BINDF_FROMURLMON is not set\n");
 518
 519     if(filedwl_api || !is_urlmon_protocol(test_protocol) || !(bindf&BINDF_ASYNCSTORAGE) || tymed != TYMED_ISTREAM)
 520         ok(bind_info & BINDF_NEEDFILE, "BINDF_NEEDFILE is not set\n");
 521     else
 522         ok(!(bind_info & BINDF_NEEDFILE), "BINDF_NEEDFILE is set\n");
 523
 524     bind_info &= ~(BINDF_NEEDFILE|BINDF_FROMURLMON);
 525     if(filedwl_api)
 526         ok(bind_info == BINDF_PULLDATA, "bind_info = %x, expected BINDF_PULLDATA\n", bind_info);
 527     else
 528         ok(bind_info == (bindf & ~(BINDF_NEEDFILE|BINDF_FROMURLMON)), "bind_info = %x, expected %x\n",
 529            bind_info, (bindf & ~(BINDF_NEEDFILE|BINDF_FROMURLMON)));
 530
 531     ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize = %d\n", bindinfo.cbSize);
 532     ok(!bindinfo.szExtraInfo, "bindinfo.szExtraInfo = %p\n", bindinfo.szExtraInfo);
 533     ok(!memcmp(&bindinfo.stgmedData, &stgmed_zero, sizeof(STGMEDIUM)), "wrong stgmedData\n");
 534     ok(!bindinfo.grfBindInfoF, "bindinfo.grfBindInfoF = %d\n", bindinfo.grfBindInfoF);
 535     ok(!bindinfo.dwBindVerb, "bindinfo.dwBindVerb = %d\n", bindinfo.dwBindVerb);
 536     ok(!bindinfo.szCustomVerb, "bindinfo.szCustomVerb = %p\n", bindinfo.szCustomVerb);
 537     ok(!bindinfo.cbstgmedData, "bindinfo.cbstgmedData = %d\n", bindinfo.cbstgmedData);
 538     ok(bindinfo.dwOptions == (bind_to_object ? 0x100000 : 0), "bindinfo.dwOptions = %x\n", bindinfo.dwOptions);
 539     ok(!bindinfo.dwOptionsFlags, "bindinfo.dwOptionsFlags = %d\n", bindinfo.dwOptionsFlags);
 540     ok(!bindinfo.dwCodePage, "bindinfo.dwCodePage = %d\n", bindinfo.dwCodePage);
 541     ok(!memcmp(&bindinfo.securityAttributes, &sa_zero, sizeof(sa_zero)), "wrong bindinfo.securityAttributes\n");
 542     ok(IsEqualGUID(&bindinfo.iid, &IID_NULL), "wrong bindinfo.iid\n");
 543     ok(!bindinfo.pUnk, "bindinfo.pUnk = %p\n", bindinfo.pUnk);
 544     ok(!bindinfo.dwReserved, "bindinfo.dwReserved = %d\n", bindinfo.dwReserved);
 545
 546     switch(test_protocol) {
 547     case MK_TEST:
 548         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 549                 BINDSTATUS_DIRECTBIND, NULL);
 550         ok(hres == S_OK,
 551            "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
 552
 553     case FILE_TEST:
 554     case ITS_TEST:
 555         if(bind_to_object)
 556             SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
 557         else
 558             SET_EXPECT(OnProgress_SENDINGREQUEST);
 559         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 560                 BINDSTATUS_SENDINGREQUEST, emptyW);
 561         ok(hres == S_OK,
 562            "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
 563         if(bind_to_object)
 564             CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
 565         else
 566             CHECK_CALLED(OnProgress_SENDINGREQUEST);
 567     default:
 568         break;
 569     }
 570
 571     if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
 572         IServiceProvider *service_provider;
 573         IHttpNegotiate *http_negotiate;
 574         IHttpNegotiate2 *http_negotiate2;
 575         LPWSTR ua = (LPWSTR)0xdeadbeef, accept_mimes[256];
 576         LPWSTR additional_headers = (LPWSTR)0xdeadbeef;
 577         BYTE sec_id[100];
 578         DWORD fetched = 256, size = 100;
 579         DWORD tid;
 580
 581         static const WCHAR wszMimes[] = {'*','/','*',0};
 582
 583         SET_EXPECT(QueryInterface_IInternetBindInfo);
 584         SET_EXPECT(QueryService_IInternetBindInfo);
 585         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_USER_AGENT,
 586                                                &ua, 1, &fetched);
 587         CLEAR_CALLED(QueryInterface_IInternetBindInfo); /* IE <8 */
 588         CLEAR_CALLED(QueryService_IInternetBindInfo); /* IE <8 */
 589
 590         ok(hres == E_NOINTERFACE,
 591            "GetBindString(BINDSTRING_USER_AGETNT) failed: %08x\n", hres);
 592         ok(fetched == 256, "fetched = %d, expected 254\n", fetched);
 593         ok(ua == (LPWSTR)0xdeadbeef, "ua =  %p\n", ua);
 594
 595         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 596                                                accept_mimes, 256, &fetched);
 597         ok(hres == S_OK,
 598            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 599         ok(fetched == 1, "fetched = %d, expected 1\n", fetched);
 600         ok(!lstrcmpW(wszMimes, accept_mimes[0]), "unexpected mimes\n");
 601
 602         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 603                                                NULL, 256, &fetched);
 604         ok(hres == E_INVALIDARG,
 605            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 606
 607         hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
 608                                                accept_mimes, 256, NULL);
 609         ok(hres == E_INVALIDARG,
 610            "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
 611
 612         hres = IInternetBindInfo_QueryInterface(pOIBindInfo, &IID_IServiceProvider,
 613                                                 (void**)&service_provider);
 614         ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
 615
 616         SET_EXPECT(QueryInterface_IHttpNegotiate);
 617         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
 618                 &IID_IHttpNegotiate, (void**)&http_negotiate);
 619         CLEAR_CALLED(QueryInterface_IHttpNegotiate); /* IE <8 */
 620         ok(hres == S_OK, "QueryService failed: %08x\n", hres);
 621
 622         SET_EXPECT(BeginningTransaction);
 623         SET_EXPECT(QueryInterface_IHttpNegotiate);
 624         hres = IHttpNegotiate_BeginningTransaction(http_negotiate, urls[test_protocol],
 625                                                    NULL, 0, &additional_headers);
 626         CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate);
 627         CHECK_CALLED(BeginningTransaction);
 628         IHttpNegotiate_Release(http_negotiate);
 629         ok(hres == S_OK, "BeginningTransction failed: %08x\n", hres);
 630         ok(additional_headers == NULL, "additional_headers=%p\n", additional_headers);
 631
 632         SET_EXPECT(QueryInterface_IHttpNegotiate2);
 633         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
 634                 &IID_IHttpNegotiate2, (void**)&http_negotiate2);
 635         CLEAR_CALLED(QueryInterface_IHttpNegotiate2); /* IE <8 */
 636         ok(hres == S_OK, "QueryService failed: %08x\n", hres);
 637
 638         size = 512;
 639         SET_EXPECT(QueryInterface_IHttpNegotiate2);
 640         SET_EXPECT(GetRootSecurityId);
 641         hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, sec_id, &size, 0);
 642         CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate2);
 643         CHECK_CALLED(GetRootSecurityId);
 644         IHttpNegotiate2_Release(http_negotiate2);
 645         ok(hres == E_FAIL, "GetRootSecurityId failed: %08x, expected E_FAIL\n", hres);
 646         ok(size == 13, "size=%d\n", size);
 647
 648         IServiceProvider_Release(service_provider);
 649
 650         IInternetProtocolSink_AddRef(pOIProtSink);
 651         protocol_sink = pOIProtSink;
 652         CreateThread(NULL, 0, thread_proc, NULL, 0, &tid);
 653
 654         return S_OK;
 655     }
 656
 657     if(test_protocol == FILE_TEST) {
 658         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 659                 BINDSTATUS_CACHEFILENAMEAVAILABLE, file_url+8);
 660         ok(hres == S_OK,
 661            "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
 662
 663         if(bind_to_object)
 664             SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
 665         else
 666             SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 667         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 668                 BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextHtml);
 669         ok(hres == S_OK,
 670            "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
 671         if(bind_to_object)
 672             CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
 673         else
 674             CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 675     }else {
 676         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 677                 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 678         ok(hres == S_OK,
 679            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
 680     }
 681
 682     if(test_protocol == ABOUT_TEST)
 683         bscf |= BSCF_DATAFULLYAVAILABLE;
 684     if(test_protocol == ITS_TEST)
 685         bscf = BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
 686
 687     SET_EXPECT(Read);
 688     if(bind_to_object) {
 689         if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 690             SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
 691         SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
 692         if(test_protocol == FILE_TEST)
 693             SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
 694         SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
 695         SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
 696         SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
 697         SET_EXPECT(CreateInstance);
 698         SET_EXPECT(PutProperty_MIMETYPEPROP);
 699         SET_EXPECT(PutProperty_CLASSIDPROP);
 700         SET_EXPECT(Load);
 701         SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
 702         SET_EXPECT(OnObjectAvailable);
 703         SET_EXPECT(Obj_OnStopBinding);
 704     }else {
 705         if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 706             SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 707         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 708         if(test_protocol == FILE_TEST)
 709             SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
 710         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 711         SET_EXPECT(LockRequest);
 712         if(!filedwl_api)
 713             SET_EXPECT(OnDataAvailable);
 714         SET_EXPECT(OnStopBinding);
 715     }
 716
 717     hres = IInternetProtocolSink_ReportData(pOIProtSink, bscf, 13, 13);
 718     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 719
 720     CHECK_CALLED(Read);
 721     if(bind_to_object) {
 722         if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 723             CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
 724         CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
 725         if(test_protocol == FILE_TEST)
 726             CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
 727         CHECK_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
 728         CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
 729         CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
 730         CHECK_CALLED(CreateInstance);
 731         CHECK_CALLED(PutProperty_MIMETYPEPROP);
 732         CHECK_CALLED_BROKEN(PutProperty_CLASSIDPROP);
 733         CHECK_CALLED(Load);
 734         CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
 735         CHECK_CALLED(OnObjectAvailable);
 736         CHECK_CALLED(Obj_OnStopBinding);
 737     }else {
 738         if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
 739             CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 740         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 741         if(test_protocol == FILE_TEST)
 742             CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
 743         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 744         CHECK_CALLED(LockRequest);
 745         if(!filedwl_api)
 746             CHECK_CALLED(OnDataAvailable);
 747         CHECK_CALLED(OnStopBinding);
 748     }
 749
 750     if(test_protocol == ITS_TEST) {
 751         SET_EXPECT(Read);
 752         hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
 753         ok(hres == S_OK, "ReportProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
 754         CHECK_CALLED(Read);
 755     }
 756
 757     SET_EXPECT(Terminate);
 758     hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 759     ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 760     CHECK_CALLED(Terminate);
 761
 762     return S_OK;
 763 }
 764
 765 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
 766         PROTOCOLDATA *pProtocolData)
 767 {
 768     DWORD bscf = 0;
 769     HRESULT hres;
 770
 771     CHECK_EXPECT(Continue);
 772
 773     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
 774
 775     ok(pProtocolData != NULL, "pProtocolData == NULL\n");
 776     if(!pProtocolData)
 777         return S_OK;
 778
 779     switch(prot_state) {
 780     case 1: {
 781         IServiceProvider *service_provider;
 782         IHttpNegotiate *http_negotiate;
 783         static WCHAR header[] = {'?',0};
 784
 785         hres = IInternetProtocolSink_QueryInterface(protocol_sink, &IID_IServiceProvider,
 786                                                     (void**)&service_provider);
 787         ok(hres == S_OK, "Could not get IServiceProvicder\n");
 788
 789         hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
 790                                              &IID_IHttpNegotiate, (void**)&http_negotiate);
 791         ok(hres == S_OK, "Could not get IHttpNegotiate\n");
 792
 793         SET_EXPECT(QueryInterface_IHttpNegotiate);
 794         SET_EXPECT(OnResponse);
 795         hres = IHttpNegotiate_OnResponse(http_negotiate, 200, header, NULL, NULL);
 796         CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate);
 797         CHECK_CALLED(OnResponse);
 798         IHttpNegotiate_Release(http_negotiate);
 799         ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
 800
 801         if(test_protocol == HTTPS_TEST || test_redirect) {
 802             hres = IInternetProtocolSink_ReportProgress(protocol_sink, BINDSTATUS_ACCEPTRANGES, NULL);
 803             ok(hres == S_OK, "ReportProgress(BINDSTATUS_ACCEPTRANGES) failed: %08x\n", hres);
 804         }
 805
 806         hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 807                 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 808         ok(hres == S_OK,
 809            "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
 810
 811         hres = IInternetProtocolSink_ReportProgress(protocol_sink,
 812             BINDSTATUS_CACHEFILENAMEAVAILABLE, use_cache_file ? cache_file_name : cache_fileW);
 813         ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
 814
 815         bscf |= BSCF_FIRSTDATANOTIFICATION;
 816         break;
 817     }
 818     case 2:
 819     case 3:
 820         bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
 821         break;
 822     }
 823
 824     hres = IInternetProtocolSink_ReportData(protocol_sink, bscf, 100, 400);
 825     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 826
 827     SET_EXPECT(Read);
 828     switch(prot_state) {
 829     case 1:
 830         if(bind_to_object) {
 831             SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
 832             SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
 833             SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
 834             SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
 835             SET_EXPECT(CreateInstance);
 836             SET_EXPECT(PutProperty_MIMETYPEPROP);
 837             SET_EXPECT(PutProperty_CLASSIDPROP);
 838             SET_EXPECT(Load);
 839             SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
 840             SET_EXPECT(OnObjectAvailable);
 841             SET_EXPECT(Obj_OnStopBinding);
 842         }else {
 843             SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 844             SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 845             SET_EXPECT(LockRequest);
 846         }
 847         break;
 848     case 2:
 849         SET_EXPECT(OnProgress_DOWNLOADINGDATA);
 850         break;
 851     case 3:
 852         SET_EXPECT(OnProgress_DOWNLOADINGDATA);
 853         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 854     }
 855     if(!bind_to_object || prot_state >= 2)
 856         SET_EXPECT(OnDataAvailable);
 857     if(prot_state == 3)
 858         SET_EXPECT(OnStopBinding);
 859
 860     return S_OK;
 861 }
 862
 863 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 864         DWORD dwOptions)
 865 {
 866     ok(0, "unexpected call\n");
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 871 {
 872     CHECK_EXPECT(Terminate);
 873
 874     ok(dwOptions == 0, "dwOptions=%d, expected 0\n", dwOptions);
 875
 876     if(protocol_sink) {
 877         IInternetProtocolSink_Release(protocol_sink);
 878         protocol_sink = NULL;
 879     }
 880
 881     return S_OK;
 882 }
 883
 884 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
 885 {
 886     ok(0, "unexpected call\n");
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
 891 {
 892     ok(0, "unexpected call\n");
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
 897         ULONG cb, ULONG *pcbRead)
 898 {
 899     static const char data[] = "<HTML></HTML>";
 900
 901     CHECK_EXPECT2(Read);
 902
 903     if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
 904         HRESULT hres;
 905
 906         static BOOL pending = TRUE;
 907
 908         pending = !pending;
 909
 910         switch(prot_state) {
 911         case 1:
 912         case 2:
 913             if(pending) {
 914                 *pcbRead = 10;
 915                 memset(pv, '?', 10);
 916                 return E_PENDING;
 917             }else {
 918                 memset(pv, '?', cb);
 919                 *pcbRead = cb;
 920                 read++;
 921                 return S_OK;
 922             }
 923         case 3:
 924             prot_state++;
 925
 926             *pcbRead = 0;
 927
 928             hres = IInternetProtocolSink_ReportData(protocol_sink,
 929                     BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION, 2000, 2000);
 930             ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 931
 932             hres = IInternetProtocolSink_ReportResult(protocol_sink, S_OK, 0, NULL);
 933             ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 934
 935             return S_FALSE;
 936         case 4:
 937             *pcbRead = 0;
 938             return S_FALSE;
 939         }
 940     }
 941
 942     if(read) {
 943         *pcbRead = 0;
 944         return S_FALSE;
 945     }
 946
 947     ok(pv != NULL, "pv == NULL\n");
 948     ok(cb != 0, "cb == 0\n");
 949     ok(pcbRead != NULL, "pcbRead == NULL\n");
 950     if(pcbRead) {
 951         ok(*pcbRead == 0, "*pcbRead=%d, expected 0\n", *pcbRead);
 952         read += *pcbRead = sizeof(data)-1;
 953     }
 954     if(pv)
 955         memcpy(pv, data, sizeof(data));
 956
 957     return S_OK;
 958 }
 959
 960 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
 961         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 962 {
 963     ok(0, "unexpected call\n");
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 968 {
 969     CHECK_EXPECT(LockRequest);
 970     return S_OK;
 971 }
 972
 973 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
 974 {
 975     CHECK_EXPECT(UnlockRequest);
 976     return S_OK;
 977 }
 978
 979 static const IInternetProtocolVtbl ProtocolVtbl = {
 980     Protocol_QueryInterface,
 981     Protocol_AddRef,
 982     Protocol_Release,
 983     Protocol_Start,
 984     Protocol_Continue,
 985     Protocol_Abort,
 986     Protocol_Terminate,
 987     Protocol_Suspend,
 988     Protocol_Resume,
 989     Protocol_Read,
 990     Protocol_Seek,
 991     Protocol_LockRequest,
 992     Protocol_UnlockRequest
 993 };
 994
 995 static IInternetProtocol Protocol = { &ProtocolVtbl };
 996
 997 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
 998 {
 999     if(IsEqualGUID(&IID_IUnknown, riid)
1000             || IsEqualGUID(&IID_IHttpNegotiate, riid)
1001             || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
1002         *ppv = iface;
1003         return S_OK;
1004     }
1005
1006     ok(0, "unexpected call\n");
1007     return E_NOINTERFACE;
1008 }
1009
1010 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
1011 {
1012     return 2;
1013 }
1014
1015 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
1016 {
1017     return 1;
1018 }
1019
1020 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface, LPCWSTR szURL,
1021         LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
1022 {
1023     CHECK_EXPECT(BeginningTransaction);
1024
1025     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1026
1027     ok(!lstrcmpW(szURL, urls[test_protocol]), "szURL != urls[test_protocol]\n");
1028     ok(!dwReserved, "dwReserved=%d, expected 0\n", dwReserved);
1029     ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
1030     if(pszAdditionalHeaders)
1031         ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
1032
1033     return S_OK;
1034 }
1035
1036 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
1037         LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
1038 {
1039     CHECK_EXPECT(OnResponse);
1040
1041     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1042
1043     ok(dwResponseCode == 200, "dwResponseCode=%d, expected 200\n", dwResponseCode);
1044     ok(szResponseHeaders != NULL, "szResponseHeaders == NULL\n");
1045     ok(szRequestHeaders == NULL, "szRequestHeaders != NULL\n");
1046     /* Note: in protocol.c tests, OnResponse pszAdditionalRequestHeaders _is_ NULL */
1047     ok(pszAdditionalRequestHeaders != NULL, "pszAdditionalHeaders == NULL\n");
1048     if(pszAdditionalRequestHeaders)
1049         ok(*pszAdditionalRequestHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
1050
1051     return S_OK;
1052 }
1053
1054 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
1055         BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
1056 {
1057     static const BYTE sec_id[] = {'h','t','t','p',':','t','e','s','t',1,0,0,0};
1058
1059     CHECK_EXPECT(GetRootSecurityId);
1060
1061     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1062
1063     ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
1064     ok(pbSecurityId != NULL, "pbSecurityId == NULL\n");
1065     ok(pcbSecurityId != NULL, "pcbSecurityId == NULL\n");
1066
1067     if(pbSecurityId == (void*)0xdeadbeef)
1068         return E_NOTIMPL;
1069
1070     if(pcbSecurityId) {
1071         ok(*pcbSecurityId == 512, "*pcbSecurityId=%d, expected 512\n", *pcbSecurityId);
1072         *pcbSecurityId = sizeof(sec_id);
1073     }
1074
1075     if(pbSecurityId)
1076         memcpy(pbSecurityId, sec_id, sizeof(sec_id));
1077
1078     return E_FAIL;
1079 }
1080
1081 static IHttpNegotiate2Vtbl HttpNegotiateVtbl = {
1082     HttpNegotiate_QueryInterface,
1083     HttpNegotiate_AddRef,
1084     HttpNegotiate_Release,
1085     HttpNegotiate_BeginningTransaction,
1086     HttpNegotiate_OnResponse,
1087     HttpNegotiate_GetRootSecurityId
1088 };
1089
1090 static IHttpNegotiate2 HttpNegotiate = { &HttpNegotiateVtbl };
1091
1092 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
1093 {
1094     ok(0, "unexpected call\n");
1095     return E_NOINTERFACE;
1096 }
1097
1098 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1099 {
1100     return 2;
1101 }
1102
1103 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1104 {
1105     return 1;
1106 }
1107
1108 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
1109         REFGUID guidService, REFIID riid, void **ppv)
1110 {
1111     if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
1112         CHECK_EXPECT(QueryService_IAuthenticate);
1113         return E_NOTIMPL;
1114     }
1115
1116     if(IsEqualGUID(&IID_IInternetProtocol, guidService)) {
1117         CHECK_EXPECT2(QueryService_IInternetProtocol);
1118         return E_NOTIMPL;
1119     }
1120
1121     if(IsEqualGUID(&IID_IInternetBindInfo, guidService)) {
1122         CHECK_EXPECT(QueryService_IInternetBindInfo);
1123         return E_NOTIMPL;
1124     }
1125
1126     if(IsEqualGUID(&IID_IWindowForBindingUI, guidService)) {
1127         CHECK_EXPECT(QueryService_IWindowForBindingUI);
1128         return E_NOTIMPL;
1129     }
1130
1131     ok(0, "unexpected service %s\n", debugstr_guid(guidService));
1132     return E_NOINTERFACE;
1133 }
1134
1135 static IServiceProviderVtbl ServiceProviderVtbl = {
1136     ServiceProvider_QueryInterface,
1137     ServiceProvider_AddRef,
1138     ServiceProvider_Release,
1139     ServiceProvider_QueryService
1140 };
1141
1142 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1143
1144 static IBindStatusCallbackEx objbsc;
1145
1146 static HRESULT WINAPI statusclb_QueryInterface(IBindStatusCallbackEx *iface, REFIID riid, void **ppv)
1147 {
1148     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1149
1150     if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
1151         CHECK_EXPECT2(QueryInterface_IInternetProtocol);
1152         if(emulate_protocol) {
1153             *ppv = &Protocol;
1154             return S_OK;
1155         }else {
1156             return E_NOINTERFACE;
1157         }
1158     }
1159     else if (IsEqualGUID(&IID_IServiceProvider, riid))
1160     {
1161         CHECK_EXPECT2(QueryInterface_IServiceProvider);
1162         *ppv = &ServiceProvider;
1163         return S_OK;
1164     }
1165     else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
1166     {
1167         CHECK_EXPECT2(QueryInterface_IHttpNegotiate);
1168         *ppv = &HttpNegotiate;
1169         return S_OK;
1170     }
1171     else if (IsEqualGUID(&IID_IHttpNegotiate2, riid))
1172     {
1173         CHECK_EXPECT(QueryInterface_IHttpNegotiate2);
1174         *ppv = &HttpNegotiate;
1175         return S_OK;
1176     }
1177     else if (IsEqualGUID(&IID_IAuthenticate, riid))
1178     {
1179         CHECK_EXPECT(QueryInterface_IAuthenticate);
1180         return E_NOINTERFACE;
1181     }
1182     else if(IsEqualGUID(&IID_IBindStatusCallback, riid))
1183     {
1184         CHECK_EXPECT2(QueryInterface_IBindStatusCallback);
1185         *ppv = iface;
1186         return S_OK;
1187     }
1188     else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid))
1189     {
1190         CHECK_EXPECT2(QueryInterface_IBindStatusCallbackHolder);
1191         return E_NOINTERFACE;
1192     }
1193     else if(IsEqualGUID(&IID_IBindStatusCallbackEx, riid))
1194     {
1195         CHECK_EXPECT(QueryInterface_IBindStatusCallbackEx);
1196         if(!use_bscex)
1197             return E_NOINTERFACE;
1198         *ppv = iface;
1199         return S_OK;
1200     }
1201     else if(IsEqualGUID(&IID_IInternetBindInfo, riid))
1202     {
1203         /* TODO */
1204         CHECK_EXPECT2(QueryInterface_IInternetBindInfo);
1205     }
1206     else if(IsEqualGUID(&IID_IWindowForBindingUI, riid))
1207     {
1208         CHECK_EXPECT2(QueryInterface_IWindowForBindingUI);
1209         return E_NOINTERFACE;
1210     }
1211     else
1212     {
1213         ok(0, "unexpected interface %s\n", debugstr_guid(riid));
1214     }
1215
1216     return E_NOINTERFACE;
1217 }
1218
1219 static ULONG WINAPI statusclb_AddRef(IBindStatusCallbackEx *iface)
1220 {
1221     return 2;
1222 }
1223
1224 static ULONG WINAPI statusclb_Release(IBindStatusCallbackEx *iface)
1225 {
1226     return 1;
1227 }
1228
1229 static HRESULT WINAPI statusclb_OnStartBinding(IBindStatusCallbackEx *iface, DWORD dwReserved,
1230         IBinding *pib)
1231 {
1232     IWinInetHttpInfo *http_info;
1233     HRESULT hres;
1234     IMoniker *mon;
1235
1236     if(iface == &objbsc)
1237         CHECK_EXPECT(Obj_OnStartBinding);
1238     else
1239         CHECK_EXPECT(OnStartBinding);
1240
1241     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1242
1243     ok(pib != NULL, "pib should not be NULL\n");
1244     ok(dwReserved == 0xff, "dwReserved=%x\n", dwReserved);
1245
1246     if(pib == (void*)0xdeadbeef)
1247         return S_OK;
1248
1249     current_binding = pib;
1250
1251     hres = IBinding_QueryInterface(pib, &IID_IMoniker, (void**)&mon);
1252     ok(hres == E_NOINTERFACE, "IBinding should not have IMoniker interface\n");
1253     if(SUCCEEDED(hres))
1254         IMoniker_Release(mon);
1255
1256     hres = IBinding_QueryInterface(pib, &IID_IWinInetHttpInfo, (void**)&http_info);
1257     ok(hres == E_NOINTERFACE, "Could not get IID_IWinInetHttpInfo: %08x\n", hres);
1258
1259     return S_OK;
1260 }
1261
1262 static HRESULT WINAPI statusclb_GetPriority(IBindStatusCallbackEx *iface, LONG *pnPriority)
1263 {
1264     ok(0, "unexpected call\n");
1265     return E_NOTIMPL;
1266 }
1267
1268 static HRESULT WINAPI statusclb_OnLowResource(IBindStatusCallbackEx *iface, DWORD reserved)
1269 {
1270     ok(0, "unexpected call\n");
1271     return E_NOTIMPL;
1272 }
1273
1274 static HRESULT WINAPI statusclb_OnProgress(IBindStatusCallbackEx *iface, ULONG ulProgress,
1275         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
1276 {
1277     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1278
1279     switch(ulStatusCode) {
1280     case BINDSTATUS_FINDINGRESOURCE:
1281         if(iface == &objbsc)
1282             CHECK_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
1283         else if(test_protocol == FTP_TEST)
1284             todo_wine CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
1285         else
1286             CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
1287         if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST))
1288             SetEvent(complete_event);
1289         break;
1290     case BINDSTATUS_CONNECTING:
1291         if(iface == &objbsc)
1292             CHECK_EXPECT(Obj_OnProgress_CONNECTING);
1293         else if(test_protocol == FTP_TEST)
1294             todo_wine CHECK_EXPECT(OnProgress_CONNECTING);
1295         else
1296             CHECK_EXPECT(OnProgress_CONNECTING);
1297         if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST))
1298             SetEvent(complete_event);
1299         break;
1300     case BINDSTATUS_REDIRECTING:
1301         if(iface == &objbsc)
1302             CHECK_EXPECT(Obj_OnProgress_REDIRECTING);
1303         else
1304             CHECK_EXPECT(OnProgress_REDIRECTING);
1305         ok(!lstrcmpW(szStatusText, WINE_ABOUT_URL), "unexpected status text %s\n",
1306            wine_dbgstr_w(szStatusText));
1307         if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
1308                 && (!bind_to_object || iface == &objbsc))
1309             SetEvent(complete_event);
1310         break;
1311     case BINDSTATUS_SENDINGREQUEST:
1312         if(iface == &objbsc)
1313             CHECK_EXPECT(Obj_OnProgress_SENDINGREQUEST);
1314         else if(test_protocol == FTP_TEST)
1315             CHECK_EXPECT2(OnProgress_SENDINGREQUEST);
1316         else
1317             CHECK_EXPECT(OnProgress_SENDINGREQUEST);
1318         if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST))
1319             SetEvent(complete_event);
1320         break;
1321     case BINDSTATUS_MIMETYPEAVAILABLE:
1322         if(iface == &objbsc)
1323             CHECK_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
1324         else
1325             CHECK_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1326         if(!bind_to_object)
1327             ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
1328                download_state);
1329         WideCharToMultiByte(CP_ACP, 0, szStatusText, -1, mime_type, sizeof(mime_type)-1, NULL, NULL);
1330         break;
1331     case BINDSTATUS_BEGINDOWNLOADDATA:
1332         if(iface == &objbsc)
1333             CHECK_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
1334         else
1335             CHECK_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1336         ok(szStatusText != NULL, "szStatusText == NULL\n");
1337         if(szStatusText) {
1338             if(filedwl_api) {
1339                 /* FIXME */
1340             }else {
1341                 ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1342             }
1343         }
1344         if(!bind_to_object)
1345             ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
1346                download_state);
1347         download_state = DOWNLOADING;
1348         break;
1349     case BINDSTATUS_DOWNLOADINGDATA:
1350         CHECK_EXPECT2(OnProgress_DOWNLOADINGDATA);
1351         ok(iface != &objbsc, "unexpected call\n");
1352         ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
1353            download_state);
1354         break;
1355     case BINDSTATUS_ENDDOWNLOADDATA:
1356         if(iface == &objbsc)
1357             CHECK_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
1358         else
1359             CHECK_EXPECT(OnProgress_ENDDOWNLOADDATA);
1360         ok(szStatusText != NULL, "szStatusText == NULL\n");
1361         if(szStatusText) {
1362             if(filedwl_api) {
1363                 /* FIXME */
1364             }else {
1365                 ok(!lstrcmpW(szStatusText, urls[test_protocol]), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1366             }
1367         }
1368         ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
1369            download_state);
1370         download_state = END_DOWNLOAD;
1371         break;
1372     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
1373         if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST) {
1374             if(iface == &objbsc)
1375                 CHECK_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
1376             else
1377                 CHECK_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
1378         }else {  /* FIXME */
1379             CLEAR_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
1380             CLEAR_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
1381         }
1382
1383         ok(szStatusText != NULL, "szStatusText == NULL\n");
1384         if(szStatusText && test_protocol == FILE_TEST)
1385             ok(!lstrcmpW(file_url+8, szStatusText), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1386         break;
1387     case BINDSTATUS_CLASSIDAVAILABLE:
1388     {
1389         CLSID clsid;
1390         HRESULT hr;
1391         if(iface != &objbsc)
1392             ok(0, "unexpected call\n");
1393         else if(1||emulate_protocol)
1394             CHECK_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
1395         else
1396             todo_wine CHECK_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
1397         hr = CLSIDFromString((LPCOLESTR)szStatusText, &clsid);
1398         ok(hr == S_OK, "CLSIDFromString failed with error 0x%08x\n", hr);
1399         ok(IsEqualCLSID(&clsid, &CLSID_HTMLDocument),
1400             "Expected clsid to be CLSID_HTMLDocument instead of %s\n", debugstr_guid(&clsid));
1401         break;
1402     }
1403     case BINDSTATUS_BEGINSYNCOPERATION:
1404         CHECK_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
1405         if(iface != &objbsc)
1406             ok(0, "unexpected call\n");
1407         ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1408         break;
1409     case BINDSTATUS_ENDSYNCOPERATION:
1410         CHECK_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
1411         if(iface != &objbsc)
1412             ok(0, "unexpected call\n");
1413         ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1414         break;
1415     case BINDSTATUS_PROXYDETECTING:
1416         trace("BINDSTATUS_PROXYDETECTING\n");
1417         break;
1418     case BINDSTATUS_COOKIE_SENT:
1419         trace("BINDSTATUS_COOKIE_SENT\n");
1420         break;
1421     default:
1422         ok(0, "unexpected code %d\n", ulStatusCode);
1423     };
1424
1425     if(current_binding) {
1426         IWinInetHttpInfo *http_info;
1427         HRESULT hres;
1428
1429         hres = IBinding_QueryInterface(current_binding, &IID_IWinInetHttpInfo, (void**)&http_info);
1430         if(!emulate_protocol && test_protocol != FILE_TEST && is_urlmon_protocol(test_protocol))
1431             ok(hres == S_OK, "Could not get IWinInetHttpInfo iface: %08x\n", hres);
1432         else
1433             ok(hres == E_NOINTERFACE,
1434                "QueryInterface(IID_IWinInetHttpInfo) returned: %08x, expected E_NOINTERFACE\n", hres);
1435         if(SUCCEEDED(hres))
1436             IWinInetHttpInfo_Release(http_info);
1437     }
1438
1439     return S_OK;
1440 }
1441
1442 static HRESULT WINAPI statusclb_OnStopBinding(IBindStatusCallbackEx *iface, HRESULT hresult, LPCWSTR szError)
1443 {
1444     if(iface == &objbsc) {
1445         CHECK_EXPECT(Obj_OnStopBinding);
1446         stopped_obj_binding = TRUE;
1447     }else {
1448         CHECK_EXPECT(OnStopBinding);
1449         stopped_binding = TRUE;
1450     }
1451
1452     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1453
1454     /* ignore DNS failure */
1455     if (hresult == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
1456         return S_OK;
1457
1458     if(filedwl_api)
1459         ok(SUCCEEDED(hresult), "binding failed: %08x\n", hresult);
1460     else
1461         ok(hresult == binding_hres, "binding failed: %08x, expected %08x\n", hresult, binding_hres);
1462     ok(szError == NULL, "szError should be NULL\n");
1463
1464     if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) && emulate_protocol) {
1465         SetEvent(complete_event);
1466         if(iface != &objbsc)
1467             WaitForSingleObject(complete_event2, INFINITE);
1468     }
1469
1470     return S_OK;
1471 }
1472
1473 static HRESULT WINAPI statusclb_GetBindInfo(IBindStatusCallbackEx *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
1474 {
1475     DWORD cbSize;
1476
1477     if(iface == &objbsc)
1478         CHECK_EXPECT(Obj_GetBindInfo);
1479     else
1480         CHECK_EXPECT(GetBindInfo);
1481
1482     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1483
1484     *grfBINDF = bindf;
1485     cbSize = pbindinfo->cbSize;
1486     memset(pbindinfo, 0, cbSize);
1487     pbindinfo->cbSize = cbSize;
1488
1489     return S_OK;
1490 }
1491
1492 static HRESULT WINAPI statusclb_OnDataAvailable(IBindStatusCallbackEx *iface, DWORD grfBSCF,
1493         DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
1494 {
1495     HRESULT hres;
1496     DWORD readed;
1497     BYTE buf[512];
1498     CHAR clipfmt[512];
1499
1500     if(iface == &objbsc)
1501         ok(0, "unexpected call\n");
1502
1503     CHECK_EXPECT2(OnDataAvailable);
1504
1505     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1506
1507     ok(download_state == DOWNLOADING || download_state == END_DOWNLOAD,
1508        "Download state was %d, expected DOWNLOADING or END_DOWNLOAD\n",
1509        download_state);
1510     data_available = TRUE;
1511
1512     ok(pformatetc != NULL, "pformatetx == NULL\n");
1513     if(pformatetc) {
1514         if (mime_type[0]) {
1515             clipfmt[0] = 0;
1516             ok(GetClipboardFormatName(pformatetc->cfFormat, clipfmt, sizeof(clipfmt)-1),
1517                "GetClipboardFormatName failed, error %d\n", GetLastError());
1518             ok(!lstrcmp(clipfmt, mime_type), "clipformat %x != mime_type, \"%s\" != \"%s\"\n",
1519                pformatetc->cfFormat, clipfmt, mime_type);
1520         } else {
1521             ok(pformatetc->cfFormat == 0, "clipformat=%x\n", pformatetc->cfFormat);
1522         }
1523         ok(pformatetc->ptd == NULL, "ptd = %p\n", pformatetc->ptd);
1524         ok(pformatetc->dwAspect == 1, "dwAspect=%u\n", pformatetc->dwAspect);
1525         ok(pformatetc->lindex == -1, "lindex=%d\n", pformatetc->lindex);
1526         ok(pformatetc->tymed == tymed, "tymed=%u, expected %u\n", pformatetc->tymed, tymed);
1527     }
1528
1529     ok(pstgmed != NULL, "stgmeg == NULL\n");
1530     ok(pstgmed->tymed == tymed, "tymed=%u, expected %u\n", pstgmed->tymed, tymed);
1531     ok(pstgmed->pUnkForRelease != NULL, "pUnkForRelease == NULL\n");
1532
1533     switch(pstgmed->tymed) {
1534     case TYMED_ISTREAM:
1535         if(grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
1536             hres = IStream_Write(U(*pstgmed).pstm, buf, 10, NULL);
1537             ok(hres == STG_E_ACCESSDENIED,
1538                "Write failed: %08x, expected STG_E_ACCESSDENIED\n", hres);
1539
1540             hres = IStream_Commit(U(*pstgmed).pstm, 0);
1541             ok(hres == E_NOTIMPL, "Commit failed: %08x, expected E_NOTIMPL\n", hres);
1542
1543             hres = IStream_Revert(U(*pstgmed).pstm);
1544             ok(hres == E_NOTIMPL, "Revert failed: %08x, expected E_NOTIMPL\n", hres);
1545         }
1546
1547         ok(U(*pstgmed).pstm != NULL, "U(*pstgmed).pstm == NULL\n");
1548         if(callback_read) {
1549             do {
1550                 hres = IStream_Read(U(*pstgmed).pstm, buf, 512, &readed);
1551                 if(test_protocol == HTTP_TEST && emulate_protocol && readed)
1552                     ok(buf[0] == (use_cache_file && !(bindf&BINDF_ASYNCHRONOUS) ? 'X' : '?'), "buf[0] = '%c'\n", buf[0]);
1553             }while(hres == S_OK);
1554             ok(hres == S_FALSE || hres == E_PENDING, "IStream_Read returned %08x\n", hres);
1555         }
1556         break;
1557
1558     case TYMED_FILE:
1559         if(test_protocol == FILE_TEST)
1560             ok(!lstrcmpW(pstgmed->u.lpszFileName, INDEX_HTML+7),
1561                "unexpected file name %s\n", wine_dbgstr_w(pstgmed->u.lpszFileName));
1562         else if(emulate_protocol)
1563             ok(!lstrcmpW(pstgmed->u.lpszFileName, cache_fileW),
1564                "unexpected file name %s\n", wine_dbgstr_w(pstgmed->u.lpszFileName));
1565         else
1566             ok(pstgmed->u.lpszFileName != NULL, "lpszFileName == NULL\n");
1567     }
1568
1569     if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
1570        && emulate_protocol && prot_state < 4 && (!bind_to_object || prot_state > 1))
1571         SetEvent(complete_event);
1572
1573     return S_OK;
1574 }
1575
1576 static HRESULT WINAPI statusclb_OnObjectAvailable(IBindStatusCallbackEx *iface, REFIID riid, IUnknown *punk)
1577 {
1578     CHECK_EXPECT(OnObjectAvailable);
1579
1580     if(iface != &objbsc)
1581         ok(0, "unexpected call\n");
1582
1583     ok(IsEqualGUID(&IID_IUnknown, riid), "riid = %s\n", debugstr_guid(riid));
1584     ok(punk != NULL, "punk == NULL\n");
1585
1586     return S_OK;
1587 }
1588
1589 static HRESULT WINAPI statusclb_GetBindInfoEx(IBindStatusCallbackEx *iface, DWORD *grfBINDF, BINDINFO *pbindinfo,
1590         DWORD *grfBINDF2, DWORD *pdwReserved)
1591 {
1592     CHECK_EXPECT(GetBindInfoEx);
1593
1594     ok(grfBINDF != NULL, "grfBINDF == NULL\n");
1595     ok(grfBINDF2 != NULL, "grfBINDF2 == NULL\n");
1596     ok(pbindinfo != NULL, "pbindinfo == NULL\n");
1597     ok(pdwReserved != NULL, "dwReserved == NULL\n");
1598
1599     return S_OK;
1600 }
1601
1602 static const IBindStatusCallbackExVtbl BindStatusCallbackVtbl = {
1603     statusclb_QueryInterface,
1604     statusclb_AddRef,
1605     statusclb_Release,
1606     statusclb_OnStartBinding,
1607     statusclb_GetPriority,
1608     statusclb_OnLowResource,
1609     statusclb_OnProgress,
1610     statusclb_OnStopBinding,
1611     statusclb_GetBindInfo,
1612     statusclb_OnDataAvailable,
1613     statusclb_OnObjectAvailable,
1614     statusclb_GetBindInfoEx
1615 };
1616
1617 static IBindStatusCallbackEx bsc = { &BindStatusCallbackVtbl };
1618 static IBindStatusCallbackEx objbsc = { &BindStatusCallbackVtbl };
1619
1620 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
1621 {
1622     *ppv = NULL;
1623     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1624     return E_NOINTERFACE;
1625 }
1626
1627 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
1628 {
1629     return 2;
1630 }
1631
1632 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
1633 {
1634     return 1;
1635 }
1636
1637 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
1638 {
1639     switch(mkp) {
1640     case MIMETYPEPROP:
1641         CHECK_EXPECT(PutProperty_MIMETYPEPROP);
1642         ok(!lstrcmpW(val, wszTextHtml), "val = %s\n", wine_dbgstr_w(val));
1643         break;
1644     case CLASSIDPROP:
1645         CHECK_EXPECT(PutProperty_CLASSIDPROP);
1646         break;
1647     default:
1648         break;
1649     }
1650
1651     return S_OK;
1652 }
1653
1654 static const IMonikerPropVtbl MonikerPropVtbl = {
1655     MonikerProp_QueryInterface,
1656     MonikerProp_AddRef,
1657     MonikerProp_Release,
1658     MonikerProp_PutProperty
1659 };
1660
1661 static IMonikerProp MonikerProp = { &MonikerPropVtbl };
1662
1663 static HRESULT WINAPI PersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
1664 {
1665     *ppv = NULL;
1666
1667     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IPersistMoniker, riid))
1668         *ppv = iface;
1669     else if(IsEqualGUID(&IID_IMonikerProp, riid))
1670         *ppv = &MonikerProp;
1671
1672     if(*ppv)
1673         return S_OK;
1674
1675     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1676     return E_NOINTERFACE;
1677 }
1678
1679 static ULONG WINAPI PersistMoniker_AddRef(IPersistMoniker *iface)
1680 {
1681     return 2;
1682 }
1683
1684 static ULONG WINAPI PersistMoniker_Release(IPersistMoniker *iface)
1685 {
1686     return 1;
1687 }
1688
1689 static HRESULT WINAPI PersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
1690 {
1691     ok(0, "unexpected call\n");
1692     return E_NOTIMPL;
1693 }
1694
1695 static HRESULT WINAPI PersistMoniker_IsDirty(IPersistMoniker *iface)
1696 {
1697     ok(0, "unexpected call\n");
1698     return E_NOTIMPL;
1699 }
1700
1701 static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
1702                                           IMoniker *pimkName, LPBC pibc, DWORD grfMode)
1703 {
1704     IUnknown *unk;
1705     HRESULT hres;
1706
1707     static WCHAR cbinding_contextW[] =
1708         {'C','B','i','n','d','i','n','g',' ','C','o','n','t','e','x','t',0};
1709
1710     CHECK_EXPECT(Load);
1711     ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1712
1713     if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
1714         ok(!fFullyAvailable, "fFulyAvailable = %x\n", fFullyAvailable);
1715     else
1716         ok(fFullyAvailable, "fFulyAvailable = %x\n", fFullyAvailable);
1717     ok(pimkName != NULL, "pimkName == NULL\n");
1718     ok(pibc != NULL, "pibc == NULL\n");
1719     ok(grfMode == 0x12, "grfMode = %x\n", grfMode);
1720
1721     hres = IBindCtx_GetObjectParam(pibc, cbinding_contextW, &unk);
1722     ok(hres == S_OK, "GetObjectParam(CBinding Context) failed: %08x\n", hres);
1723     if(SUCCEEDED(hres)) {
1724         IBinding *binding;
1725
1726         hres = IUnknown_QueryInterface(unk, &IID_IBinding, (void**)&binding);
1727         ok(hres == S_OK, "Could not get IBinding: %08x\n", hres);
1728
1729         IBinding_Release(binding);
1730         IUnknown_Release(unk);
1731     }
1732
1733     SET_EXPECT(QueryInterface_IServiceProvider);
1734     hres = RegisterBindStatusCallback(pibc, (IBindStatusCallback*)&bsc, NULL, 0);
1735     ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
1736     CHECK_CALLED(QueryInterface_IServiceProvider);
1737
1738     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
1739     SET_EXPECT(GetBindInfo);
1740     SET_EXPECT(OnStartBinding);
1741     if(test_redirect)
1742         SET_EXPECT(OnProgress_REDIRECTING);
1743     SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1744     if(test_protocol == FILE_TEST)
1745         SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
1746     if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
1747         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
1748     SET_EXPECT(LockRequest);
1749     SET_EXPECT(OnDataAvailable);
1750     if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
1751         SET_EXPECT(OnStopBinding);
1752
1753     hres = IMoniker_BindToStorage(pimkName, pibc, NULL, &IID_IStream, (void**)&unk);
1754     ok(hres == S_OK, "Load failed: %08x\n", hres);
1755
1756     CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
1757     CHECK_CALLED(GetBindInfo);
1758     CHECK_CALLED(OnStartBinding);
1759     if(test_redirect)
1760         CHECK_CALLED(OnProgress_REDIRECTING);
1761     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
1762     if(test_protocol == FILE_TEST)
1763         CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
1764     if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
1765         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
1766     CHECK_CALLED(LockRequest);
1767     CHECK_CALLED(OnDataAvailable);
1768     if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
1769         CHECK_CALLED(OnStopBinding);
1770
1771     if(unk)
1772         IUnknown_Release(unk);
1773
1774     return S_OK;
1775 }
1776
1777 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName, LPBC pbc, BOOL fRemember)
1778 {
1779     ok(0, "unexpected call\n");
1780     return E_NOTIMPL;
1781 }
1782
1783 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
1784 {
1785     ok(0, "unexpected call\n");
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **pimkName)
1790 {
1791     ok(0, "unexpected call\n");
1792     return E_NOTIMPL;
1793 }
1794
1795 static const IPersistMonikerVtbl PersistMonikerVtbl = {
1796     PersistMoniker_QueryInterface,
1797     PersistMoniker_AddRef,
1798     PersistMoniker_Release,
1799     PersistMoniker_GetClassID,
1800     PersistMoniker_IsDirty,
1801     PersistMoniker_Load,
1802     PersistMoniker_Save,
1803     PersistMoniker_SaveCompleted,
1804     PersistMoniker_GetCurMoniker
1805 };
1806
1807 static IPersistMoniker PersistMoniker = { &PersistMonikerVtbl };
1808
1809 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1810 {
1811     *ppv = NULL;
1812
1813     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1814         *ppv = iface;
1815         return S_OK;
1816     }
1817
1818     if(IsEqualGUID(&IID_IMarshal, riid))
1819         return E_NOINTERFACE;
1820     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1821         return E_NOINTERFACE;
1822
1823     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1824     return E_NOTIMPL;
1825 }
1826
1827 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1828 {
1829     return 2;
1830 }
1831
1832 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1833 {
1834     return 1;
1835 }
1836
1837 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1838 {
1839     CHECK_EXPECT(CreateInstance);
1840     ok(!outer, "outer = %p\n", outer);
1841     ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
1842     *ppv = &PersistMoniker;
1843     return S_OK;
1844 }
1845
1846 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1847 {
1848     ok(0, "unexpected call\n");
1849     return S_OK;
1850 }
1851
1852 static const IClassFactoryVtbl ClassFactoryVtbl = {
1853     ClassFactory_QueryInterface,
1854     ClassFactory_AddRef,
1855     ClassFactory_Release,
1856     ClassFactory_CreateInstance,
1857     ClassFactory_LockServer
1858 };
1859
1860 static IClassFactory mime_cf = { &ClassFactoryVtbl };
1861
1862 static void test_CreateAsyncBindCtx(void)
1863 {
1864     IBindCtx *bctx = (IBindCtx*)0x0ff00ff0;
1865     IUnknown *unk;
1866     HRESULT hres;
1867     ULONG ref;
1868     BIND_OPTS bindopts;
1869
1870     hres = CreateAsyncBindCtx(0, NULL, NULL, &bctx);
1871     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
1872     ok(bctx == (IBindCtx*)0x0ff00ff0, "bctx should not be changed\n");
1873
1874     hres = CreateAsyncBindCtx(0, NULL, NULL, NULL);
1875     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
1876
1877     SET_EXPECT(QueryInterface_IServiceProvider);
1878     hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
1879     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n", hres);
1880     CHECK_CALLED(QueryInterface_IServiceProvider);
1881
1882     bindopts.cbStruct = sizeof(bindopts);
1883     hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1884     ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1885     ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1886                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1887     ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1888                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1889                 bindopts.grfMode);
1890     ok(bindopts.dwTickCountDeadline == 0,
1891                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1892
1893     hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
1894     ok(hres == E_NOINTERFACE, "QueryInterface(IID_IAsyncBindCtx) failed: %08x, expected E_NOINTERFACE\n", hres);
1895     if(SUCCEEDED(hres))
1896         IUnknown_Release(unk);
1897
1898     ref = IBindCtx_Release(bctx);
1899     ok(ref == 0, "bctx should be destroyed here\n");
1900 }
1901
1902 static void test_CreateAsyncBindCtxEx(void)
1903 {
1904     IBindCtx *bctx = NULL, *bctx2 = NULL, *bctx_arg = NULL;
1905     IUnknown *unk;
1906     BIND_OPTS bindopts;
1907     HRESULT hres;
1908
1909     static WCHAR testW[] = {'t','e','s','t',0};
1910
1911     if (!pCreateAsyncBindCtxEx) {
1912         win_skip("CreateAsyncBindCtxEx not present\n");
1913         return;
1914     }
1915
1916     hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, NULL, 0);
1917     ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed: %08x, expected E_INVALIDARG\n", hres);
1918
1919     hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
1920     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1921
1922     if(SUCCEEDED(hres)) {
1923         bindopts.cbStruct = sizeof(bindopts);
1924         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1925         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1926         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1927                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1928         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1929                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1930                 bindopts.grfMode);
1931         ok(bindopts.dwTickCountDeadline == 0,
1932                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1933
1934         IBindCtx_Release(bctx);
1935     }
1936
1937     CreateBindCtx(0, &bctx_arg);
1938     hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
1939     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1940
1941     if(SUCCEEDED(hres)) {
1942         bindopts.cbStruct = sizeof(bindopts);
1943         hres = IBindCtx_GetBindOptions(bctx, &bindopts);
1944         ok(SUCCEEDED(hres), "IBindCtx_GetBindOptions failed: %08x\n", hres);
1945         ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
1946                 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
1947         ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
1948                 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
1949                 bindopts.grfMode);
1950         ok(bindopts.dwTickCountDeadline == 0,
1951                 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
1952
1953         IBindCtx_Release(bctx);
1954     }
1955
1956     IBindCtx_Release(bctx_arg);
1957
1958     SET_EXPECT(QueryInterface_IServiceProvider);
1959     hres = pCreateAsyncBindCtxEx(NULL, 0, (IBindStatusCallback*)&bsc, NULL, &bctx, 0);
1960     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1961     CHECK_CALLED(QueryInterface_IServiceProvider);
1962
1963     hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
1964     ok(hres == S_OK, "QueryInterface(IID_IAsyncBindCtx) failed: %08x\n", hres);
1965     if(SUCCEEDED(hres))
1966         IUnknown_Release(unk);
1967
1968     IBindCtx_Release(bctx);
1969
1970     hres = CreateBindCtx(0, &bctx2);
1971     ok(hres == S_OK, "CreateBindCtx failed: %08x\n", hres);
1972
1973     hres = pCreateAsyncBindCtxEx(bctx2, 0, NULL, NULL, &bctx, 0);
1974     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
1975
1976     hres = IBindCtx_RegisterObjectParam(bctx2, testW, (IUnknown*)&Protocol);
1977     ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
1978
1979     hres = IBindCtx_GetObjectParam(bctx, testW, &unk);
1980     ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
1981     ok(unk == (IUnknown*)&Protocol, "unexpected unk %p\n", unk);
1982
1983     IBindCtx_Release(bctx);
1984     IBindCtx_Release(bctx2);
1985 }
1986
1987 static void test_GetBindInfoEx(IBindStatusCallback *holder)
1988 {
1989     IBindStatusCallbackEx *bscex;
1990     BINDINFO bindinfo = {sizeof(bindinfo)};
1991     DWORD bindf, bindf2, dw;
1992     HRESULT hres;
1993
1994     hres = IBindStatusCallback_QueryInterface(holder, &IID_IBindStatusCallbackEx, (void**)&bscex);
1995     if(FAILED(hres)) {
1996         win_skip("IBindStatusCallbackEx not supported\n");
1997         return;
1998     }
1999
2000     use_bscex = TRUE;
2001
2002     bindf = 0;
2003     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2004     SET_EXPECT(GetBindInfoEx);
2005     hres = IBindStatusCallback_GetBindInfo(holder, &bindf, &bindinfo);
2006     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2007     CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2008     CHECK_CALLED(GetBindInfoEx);
2009
2010     bindf = bindf2 = dw = 0;
2011     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2012     SET_EXPECT(GetBindInfoEx);
2013     hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, &bindf, &bindinfo, &bindf2, &dw);
2014     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2015     CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2016     CHECK_CALLED(GetBindInfoEx);
2017
2018     use_bscex = FALSE;
2019
2020     bindf = bindf2 = dw = 0xdeadbeef;
2021     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2022     SET_EXPECT(GetBindInfo);
2023     hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, &bindf, &bindinfo, &bindf2, &dw);
2024     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2025     CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2026     CHECK_CALLED(GetBindInfo);
2027     ok(bindf2 == 0xdeadbeef, "bindf2 = %x\n", bindf2);
2028     ok(dw == 0xdeadbeef, "dw = %x\n", dw);
2029
2030     IBindStatusCallbackEx_Release(bscex);
2031 }
2032
2033 static BOOL test_bscholder(IBindStatusCallback *holder)
2034 {
2035     IServiceProvider *serv_prov;
2036     IHttpNegotiate *http_negotiate, *http_negotiate_serv;
2037     IHttpNegotiate2 *http_negotiate2, *http_negotiate2_serv;
2038     IAuthenticate *authenticate, *authenticate_serv;
2039     IInternetProtocol *protocol;
2040     BINDINFO bindinfo = {sizeof(bindinfo)};
2041     BOOL ret = TRUE;
2042     LPWSTR wstr;
2043     DWORD dw;
2044     HRESULT hres;
2045
2046     hres = IBindStatusCallback_QueryInterface(holder, &IID_IServiceProvider, (void**)&serv_prov);
2047     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2048
2049     dw = 0xdeadbeef;
2050     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2051     SET_EXPECT(GetBindInfo);
2052     hres = IBindStatusCallback_GetBindInfo(holder, &dw, &bindinfo);
2053     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2054     CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2055     CHECK_CALLED(GetBindInfo);
2056
2057     test_GetBindInfoEx(holder);
2058
2059     SET_EXPECT(OnStartBinding);
2060     hres = IBindStatusCallback_OnStartBinding(holder, 0, (void*)0xdeadbeef);
2061     ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
2062     CHECK_CALLED(OnStartBinding);
2063
2064     hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate, (void**)&http_negotiate);
2065     ok(hres == S_OK, "Could not get IHttpNegotiate interface: %08x\n", hres);
2066
2067     SET_EXPECT(QueryInterface_IHttpNegotiate);
2068     hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2069                                          (void**)&http_negotiate_serv);
2070     ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2071     CLEAR_CALLED(QueryInterface_IHttpNegotiate); /* IE <8 */
2072
2073     ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2074
2075     wstr = (void*)0xdeadbeef;
2076     SET_EXPECT(QueryInterface_IHttpNegotiate);
2077     SET_EXPECT(BeginningTransaction);
2078     hres = IHttpNegotiate_BeginningTransaction(http_negotiate_serv, urls[test_protocol], emptyW, 0, &wstr);
2079     CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2080     CHECK_CALLED(BeginningTransaction);
2081     ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
2082     ok(wstr == NULL, "wstr = %p\n", wstr);
2083
2084     IHttpNegotiate_Release(http_negotiate_serv);
2085
2086     hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2087                                          (void**)&http_negotiate_serv);
2088     ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2089     ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2090     IHttpNegotiate_Release(http_negotiate_serv);
2091
2092     hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate2, (void**)&http_negotiate2);
2093     if(SUCCEEDED(hres)) {
2094         have_IHttpNegotiate2 = TRUE;
2095
2096         SET_EXPECT(QueryInterface_IHttpNegotiate2);
2097         hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate2, &IID_IHttpNegotiate2,
2098                                              (void**)&http_negotiate2_serv);
2099         ok(hres == S_OK, "Could not get IHttpNegotiate2 service: %08x\n", hres);
2100         CLEAR_CALLED(QueryInterface_IHttpNegotiate2); /* IE <8 */
2101         ok(http_negotiate2 == http_negotiate2_serv, "http_negotiate != http_negotiate_serv\n");
2102
2103         SET_EXPECT(QueryInterface_IHttpNegotiate2);
2104         SET_EXPECT(GetRootSecurityId);
2105         hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, (void*)0xdeadbeef, (void*)0xdeadbeef, 0);
2106         ok(hres == E_NOTIMPL, "GetRootSecurityId failed: %08x\n", hres);
2107         CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate2); /* IE8 */
2108         CHECK_CALLED(GetRootSecurityId);
2109
2110         IHttpNegotiate_Release(http_negotiate2_serv);
2111         IHttpNegotiate_Release(http_negotiate2);
2112     }else {
2113         skip("Could not get IHttpNegotiate2\n");
2114         ret = FALSE;
2115     }
2116
2117     SET_EXPECT(OnProgress_FINDINGRESOURCE);
2118     hres = IBindStatusCallback_OnProgress(holder, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
2119     ok(hres == S_OK, "OnProgress failed: %08x\n", hres);
2120     CHECK_CALLED(OnProgress_FINDINGRESOURCE);
2121
2122     SET_EXPECT(QueryInterface_IHttpNegotiate);
2123     SET_EXPECT(OnResponse);
2124     wstr = (void*)0xdeadbeef;
2125     hres = IHttpNegotiate_OnResponse(http_negotiate, 200, emptyW, NULL, NULL);
2126     ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
2127     CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2128     CHECK_CALLED(OnResponse);
2129
2130     IHttpNegotiate_Release(http_negotiate);
2131
2132     hres = IBindStatusCallback_QueryInterface(holder, &IID_IAuthenticate, (void**)&authenticate);
2133     ok(hres == S_OK, "Could not get IAuthenticate interface: %08x\n", hres);
2134
2135     SET_EXPECT(QueryInterface_IAuthenticate);
2136     SET_EXPECT(QueryService_IAuthenticate);
2137     hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2138                                          (void**)&authenticate_serv);
2139     ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2140     CLEAR_CALLED(QueryInterface_IAuthenticate); /* IE <8 */
2141     CLEAR_CALLED(QueryService_IAuthenticate); /* IE <8 */
2142     ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2143     IAuthenticate_Release(authenticate_serv);
2144
2145     hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2146                                          (void**)&authenticate_serv);
2147     ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2148     ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2149
2150     IAuthenticate_Release(authenticate);
2151     IAuthenticate_Release(authenticate_serv);
2152
2153     SET_EXPECT(OnStopBinding);
2154     hres = IBindStatusCallback_OnStopBinding(holder, S_OK, NULL);
2155     ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
2156     CHECK_CALLED(OnStopBinding);
2157
2158     SET_EXPECT(QueryInterface_IInternetProtocol);
2159     SET_EXPECT(QueryService_IInternetProtocol);
2160     hres = IServiceProvider_QueryService(serv_prov, &IID_IInternetProtocol, &IID_IInternetProtocol,
2161                                          (void**)&protocol);
2162     ok(hres == E_NOINTERFACE, "QueryService(IInternetProtocol) failed: %08x\n", hres);
2163     CHECK_CALLED(QueryInterface_IInternetProtocol);
2164     CHECK_CALLED(QueryService_IInternetProtocol);
2165
2166     IServiceProvider_Release(serv_prov);
2167     return ret;
2168 }
2169
2170 static BOOL test_RegisterBindStatusCallback(void)
2171 {
2172     IBindStatusCallback *prevbsc, *clb;
2173     IBindCtx *bindctx;
2174     BOOL ret = TRUE;
2175     IUnknown *unk;
2176     HRESULT hres;
2177
2178     hres = CreateBindCtx(0, &bindctx);
2179     ok(hres == S_OK, "BindCtx failed: %08x\n", hres);
2180
2181     SET_EXPECT(QueryInterface_IServiceProvider);
2182
2183     hres = IBindCtx_RegisterObjectParam(bindctx, BSCBHolder, (IUnknown*)&bsc);
2184     ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
2185
2186     SET_EXPECT(QueryInterface_IBindStatusCallback);
2187     SET_EXPECT(QueryInterface_IBindStatusCallbackHolder);
2188     prevbsc = (void*)0xdeadbeef;
2189     hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc, &prevbsc, 0);
2190     ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2191     ok(prevbsc == (IBindStatusCallback*)&bsc, "prevbsc=%p\n", prevbsc);
2192     CHECK_CALLED(QueryInterface_IBindStatusCallback);
2193     CHECK_CALLED(QueryInterface_IBindStatusCallbackHolder);
2194
2195     CHECK_CALLED(QueryInterface_IServiceProvider);
2196
2197     hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2198     ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2199
2200     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
2201     IUnknown_Release(unk);
2202     ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2203     ok(clb != (IBindStatusCallback*)&bsc, "bsc == clb\n");
2204
2205     if(!test_bscholder(clb))
2206         ret = FALSE;
2207
2208     IBindStatusCallback_Release(clb);
2209
2210     hres = RevokeBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc);
2211     ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2212
2213     unk = (void*)0xdeadbeef;
2214     hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2215     ok(hres == E_FAIL, "GetObjectParam failed: %08x\n", hres);
2216     ok(unk == NULL, "unk != NULL\n");
2217
2218     if(unk)
2219         IUnknown_Release(unk);
2220
2221     hres = RevokeBindStatusCallback(bindctx, (void*)0xdeadbeef);
2222     ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2223
2224     hres = RevokeBindStatusCallback(NULL, (void*)0xdeadbeef);
2225     ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2226
2227     hres = RevokeBindStatusCallback(bindctx, NULL);
2228     ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2229
2230     IBindCtx_Release(bindctx);
2231     return ret;
2232 }
2233
2234 #define BINDTEST_EMULATE       0x0001
2235 #define BINDTEST_TOOBJECT      0x0002
2236 #define BINDTEST_FILEDWLAPI    0x0004
2237 #define BINDTEST_HTTPRESPONSE  0x0008
2238 #define BINDTEST_REDIRECT      0x0010
2239 #define BINDTEST_USE_CACHE     0x0020
2240 #define BINDTEST_NO_CALLBACK_READ  0x0040
2241
2242 static void init_bind_test(int protocol, DWORD flags, DWORD t)
2243 {
2244     test_protocol = protocol;
2245     emulate_protocol = (flags & BINDTEST_EMULATE) != 0;
2246     download_state = BEFORE_DOWNLOAD;
2247     stopped_binding = FALSE;
2248     stopped_obj_binding = FALSE;
2249     data_available = FALSE;
2250     mime_type[0] = 0;
2251     binding_hres = S_OK;
2252     bind_to_object = (flags & BINDTEST_TOOBJECT) != 0;
2253     tymed = t;
2254     filedwl_api = (flags & BINDTEST_FILEDWLAPI) != 0;
2255     if(flags & BINDTEST_HTTPRESPONSE)
2256         urls[HTTP_TEST] = SHORT_RESPONSE_URL;
2257     else
2258         urls[HTTP_TEST] = WINE_ABOUT_URL;
2259     test_redirect = (flags & BINDTEST_REDIRECT) != 0;
2260     use_cache_file = (flags & BINDTEST_USE_CACHE) != 0;
2261     callback_read = !(flags & BINDTEST_NO_CALLBACK_READ);
2262 }
2263
2264 static void test_BindToStorage(int protocol, DWORD flags, DWORD t)
2265 {
2266     IMoniker *mon;
2267     HRESULT hres;
2268     LPOLESTR display_name;
2269     IBindCtx *bctx;
2270     MSG msg;
2271     IBindStatusCallback *previousclb;
2272     IUnknown *unk = (IUnknown*)0x00ff00ff;
2273     IBinding *bind;
2274
2275     init_bind_test(protocol, flags, t);
2276
2277     SET_EXPECT(QueryInterface_IServiceProvider);
2278     hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
2279     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
2280     CHECK_CALLED(QueryInterface_IServiceProvider);
2281     if(FAILED(hres))
2282         return;
2283
2284     SET_EXPECT(QueryInterface_IServiceProvider);
2285     hres = RegisterBindStatusCallback(bctx, (IBindStatusCallback*)&bsc, &previousclb, 0);
2286     ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2287     ok(previousclb == (IBindStatusCallback*)&bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
2288     CHECK_CALLED(QueryInterface_IServiceProvider);
2289     if(previousclb)
2290         IBindStatusCallback_Release(previousclb);
2291
2292     hres = CreateURLMoniker(NULL, test_protocol == FILE_TEST ? file_url : urls[test_protocol], &mon);
2293     ok(SUCCEEDED(hres), "failed to create moniker: %08x\n", hres);
2294     if(FAILED(hres)) {
2295         IBindCtx_Release(bctx);
2296         return;
2297     }
2298
2299     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
2300     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
2301     if(SUCCEEDED(hres))
2302         IBinding_Release(bind);
2303
2304     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
2305     ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
2306     ok(!lstrcmpW(display_name, urls[test_protocol]),
2307        "GetDisplayName got wrong name %s\n", wine_dbgstr_w(display_name));
2308     CoTaskMemFree(display_name);
2309
2310     if(tymed == TYMED_FILE && (test_protocol == ABOUT_TEST || test_protocol == ITS_TEST))
2311         binding_hres = INET_E_DATA_NOT_AVAILABLE;
2312
2313     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2314     SET_EXPECT(GetBindInfo);
2315     SET_EXPECT(QueryInterface_IInternetProtocol);
2316     if(!emulate_protocol)
2317         SET_EXPECT(QueryService_IInternetProtocol);
2318     SET_EXPECT(OnStartBinding);
2319     if(emulate_protocol) {
2320         if(is_urlmon_protocol(test_protocol))
2321             SET_EXPECT(SetPriority);
2322         SET_EXPECT(Start);
2323         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2324             SET_EXPECT(Terminate);
2325         if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
2326             SET_EXPECT(UnlockRequest);
2327     }else {
2328         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2329             SET_EXPECT(QueryInterface_IInternetBindInfo);
2330             SET_EXPECT(QueryService_IInternetBindInfo);
2331             SET_EXPECT(QueryInterface_IHttpNegotiate);
2332             SET_EXPECT(QueryInterface_IWindowForBindingUI);
2333             SET_EXPECT(QueryService_IWindowForBindingUI);
2334             SET_EXPECT(BeginningTransaction);
2335             SET_EXPECT(QueryInterface_IHttpNegotiate2);
2336             SET_EXPECT(GetRootSecurityId);
2337             SET_EXPECT(OnProgress_FINDINGRESOURCE);
2338             SET_EXPECT(OnProgress_CONNECTING);
2339         }
2340         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST
2341            || test_protocol == FILE_TEST)
2342             SET_EXPECT(OnProgress_SENDINGREQUEST);
2343         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2344             SET_EXPECT(QueryInterface_IHttpNegotiate);
2345             SET_EXPECT(OnResponse);
2346         }
2347         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
2348         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
2349         if(test_protocol == FILE_TEST)
2350             SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
2351         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST)
2352             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
2353         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
2354         if(tymed != TYMED_FILE || test_protocol != ABOUT_TEST)
2355             SET_EXPECT(OnDataAvailable);
2356         SET_EXPECT(OnStopBinding);
2357     }
2358
2359     hres = IMoniker_BindToStorage(mon, bctx, NULL, tymed == TYMED_ISTREAM ? &IID_IStream : &IID_IUnknown, (void**)&unk);
2360     if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2361         && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
2362     {
2363         skip("Network unreachable, skipping tests\n");
2364         return;
2365     }
2366
2367     if(!(bindf & BINDF_ASYNCHRONOUS) && tymed == TYMED_FILE) {
2368         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
2369         ok(unk == NULL, "unk != NULL\n");
2370     }else if(((bindf & BINDF_ASYNCHRONOUS) && !data_available)
2371        || (tymed == TYMED_FILE && test_protocol == FILE_TEST)) {
2372         ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
2373         ok(unk == NULL, "istr should be NULL\n");
2374     }else if(tymed == TYMED_FILE && test_protocol == ABOUT_TEST) {
2375         ok(hres == INET_E_DATA_NOT_AVAILABLE,
2376            "IMoniker_BindToStorage failed: %08x, expected INET_E_DATA_NOT_AVAILABLE\n", hres);
2377         ok(unk == NULL, "istr should be NULL\n");
2378     }else {
2379         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
2380         ok(unk != NULL, "unk == NULL\n");
2381     }
2382     if(unk && callback_read)
2383         IUnknown_Release(unk);
2384
2385     if(FAILED(hres))
2386         return;
2387
2388     while((bindf & BINDF_ASYNCHRONOUS) &&
2389           !stopped_binding && GetMessage(&msg,NULL,0,0)) {
2390         TranslateMessage(&msg);
2391         DispatchMessage(&msg);
2392     }
2393
2394     CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2395     CHECK_CALLED(GetBindInfo);
2396     CHECK_CALLED(QueryInterface_IInternetProtocol);
2397     if(!emulate_protocol)
2398         CHECK_CALLED(QueryService_IInternetProtocol);
2399     CHECK_CALLED(OnStartBinding);
2400     if(emulate_protocol) {
2401         if(is_urlmon_protocol(test_protocol))
2402             CHECK_CALLED(SetPriority);
2403         CHECK_CALLED(Start);
2404         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2405             if(tymed == TYMED_FILE)
2406                 CLEAR_CALLED(Read);
2407             CHECK_CALLED(Terminate);
2408         }
2409         if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
2410             CHECK_CALLED(UnlockRequest);
2411     }else {
2412         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2413             CLEAR_CALLED(QueryInterface_IInternetBindInfo);
2414             CLEAR_CALLED(QueryService_IInternetBindInfo);
2415             CHECK_CALLED(QueryInterface_IHttpNegotiate);
2416             CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
2417             CLEAR_CALLED(QueryService_IWindowForBindingUI);
2418             CHECK_CALLED(BeginningTransaction);
2419             if (have_IHttpNegotiate2)
2420             {
2421                 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
2422                 CHECK_CALLED(GetRootSecurityId);
2423             }
2424             if(http_is_first || test_protocol == HTTPS_TEST) {
2425                 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
2426                 CHECK_CALLED(OnProgress_CONNECTING);
2427             }else todo_wine {
2428                 CHECK_NOT_CALLED(OnProgress_FINDINGRESOURCE);
2429                 /* IE7 does call this */
2430                 CLEAR_CALLED(OnProgress_CONNECTING);
2431             }
2432         }
2433         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
2434             CHECK_CALLED(OnProgress_SENDINGREQUEST);
2435         else if(test_protocol == FTP_TEST)
2436             todo_wine CHECK_CALLED(OnProgress_SENDINGREQUEST);
2437         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2438             CLEAR_CALLED(QueryInterface_IHttpNegotiate);
2439             CHECK_CALLED(OnResponse);
2440         }
2441         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
2442         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
2443         if(test_protocol == FILE_TEST)
2444             CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
2445         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST)
2446             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2447         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
2448         if(tymed != TYMED_FILE || test_protocol != ABOUT_TEST)
2449             CHECK_CALLED(OnDataAvailable);
2450         CHECK_CALLED(OnStopBinding);
2451     }
2452
2453     ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2454     ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
2455
2456     if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2457         http_is_first = FALSE;
2458
2459     if(!callback_read) {
2460         BYTE buf[512];
2461         DWORD readed;
2462         IStream *stream;
2463
2464         hres = IUnknown_QueryInterface(unk, &IID_IStream, (void**)&stream);
2465         ok(hres == S_OK, "Could not get IStream iface: %08x\n", hres);
2466         IUnknown_Release(unk);
2467
2468         do {
2469             readed = 0xdeadbeef;
2470             hres = IStream_Read(stream, buf, sizeof(buf), &readed);
2471             ok(readed != 0xdeadbeef, "readed = 0xdeadbeef\n");
2472             if(emulate_protocol && test_protocol == HTTP_TEST && readed)
2473                 ok(buf[0] == (use_cache_file && !(bindf&BINDF_ASYNCHRONOUS) ? 'X' : '?'), "buf[0] = '%c'\n", buf[0]);
2474         }while(hres == S_OK);
2475         ok(hres == S_FALSE, "IStream_Read returned %08x\n", hres);
2476         ok(!readed, "readed = %d\n", readed);
2477
2478         IStream_Release(stream);
2479     }
2480 }
2481
2482 static void test_BindToObject(int protocol, DWORD flags)
2483 {
2484     IMoniker *mon;
2485     HRESULT hres;
2486     LPOLESTR display_name;
2487     IBindCtx *bctx;
2488     DWORD regid;
2489     MSG msg;
2490     IUnknown *unk = (IUnknown*)0x00ff00ff;
2491     IBinding *bind;
2492
2493     init_bind_test(protocol, BINDTEST_TOOBJECT|flags, TYMED_ISTREAM);
2494
2495     if(emulate_protocol)
2496         CoRegisterClassObject(&CLSID_HTMLDocument, (IUnknown *)&mime_cf,
2497                               CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2498
2499     SET_EXPECT(QueryInterface_IServiceProvider);
2500     hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&objbsc, NULL, &bctx);
2501     ok(SUCCEEDED(hres), "CreateAsyncBindCtx failed: %08x\n\n", hres);
2502     CHECK_CALLED(QueryInterface_IServiceProvider);
2503     if(FAILED(hres))
2504         return;
2505
2506     hres = CreateURLMoniker(NULL, test_protocol == FILE_TEST ? file_url : urls[test_protocol], &mon);
2507     ok(SUCCEEDED(hres), "failed to create moniker: %08x\n", hres);
2508     if(FAILED(hres)) {
2509         IBindCtx_Release(bctx);
2510         return;
2511     }
2512
2513     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
2514     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
2515     if(SUCCEEDED(hres))
2516         IBinding_Release(bind);
2517
2518     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
2519     ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
2520     ok(!lstrcmpW(display_name, urls[test_protocol]), "GetDisplayName got wrong name\n");
2521
2522     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2523     SET_EXPECT(Obj_GetBindInfo);
2524     SET_EXPECT(QueryInterface_IInternetProtocol);
2525     if(!emulate_protocol)
2526         SET_EXPECT(QueryService_IInternetProtocol);
2527     SET_EXPECT(Obj_OnStartBinding);
2528     if(emulate_protocol) {
2529         if(is_urlmon_protocol(test_protocol))
2530             SET_EXPECT(SetPriority);
2531         SET_EXPECT(Start);
2532         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2533             SET_EXPECT(Terminate);
2534         if(test_protocol == FILE_TEST)
2535             SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
2536         SET_EXPECT(UnlockRequest);
2537     }else {
2538         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2539             SET_EXPECT(QueryInterface_IHttpNegotiate);
2540             SET_EXPECT(BeginningTransaction);
2541             SET_EXPECT(QueryInterface_IHttpNegotiate2);
2542             SET_EXPECT(GetRootSecurityId);
2543             SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
2544             SET_EXPECT(Obj_OnProgress_CONNECTING);
2545             SET_EXPECT(QueryInterface_IWindowForBindingUI);
2546             SET_EXPECT(QueryService_IWindowForBindingUI);
2547         }
2548         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
2549             SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
2550         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2551             SET_EXPECT(QueryInterface_IHttpNegotiate);
2552             SET_EXPECT(OnResponse);
2553         }
2554         SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
2555         SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
2556         if(test_protocol == FILE_TEST)
2557             SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
2558         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2559             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
2560         SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
2561         SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
2562         SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
2563         SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
2564         SET_EXPECT(OnObjectAvailable);
2565         SET_EXPECT(Obj_OnStopBinding);
2566     }
2567
2568     hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
2569
2570     if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2571         && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
2572     {
2573         skip( "Network unreachable, skipping tests\n" );
2574         return;
2575     }
2576
2577     /* no point testing the calls if binding didn't even work */
2578     if (FAILED(hres)) return;
2579
2580     if(bindf & BINDF_ASYNCHRONOUS) {
2581         ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToObject failed: %08x\n", hres);
2582         ok(unk == NULL, "istr should be NULL\n");
2583     }else {
2584         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
2585         ok(unk != NULL, "unk == NULL\n");
2586         if(emulate_protocol)
2587             ok(unk == (IUnknown*)&PersistMoniker, "unk != PersistMoniker\n");
2588     }
2589     if(unk)
2590         IUnknown_Release(unk);
2591
2592     while((bindf & BINDF_ASYNCHRONOUS) &&
2593           !((!emulate_protocol || stopped_binding) && stopped_obj_binding) && GetMessage(&msg,NULL,0,0)) {
2594         TranslateMessage(&msg);
2595         DispatchMessage(&msg);
2596     }
2597
2598     CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx);
2599     CHECK_CALLED(Obj_GetBindInfo);
2600     CHECK_CALLED(QueryInterface_IInternetProtocol);
2601     if(!emulate_protocol)
2602         CHECK_CALLED(QueryService_IInternetProtocol);
2603     CHECK_CALLED(Obj_OnStartBinding);
2604     if(emulate_protocol) {
2605         if(is_urlmon_protocol(test_protocol))
2606             CHECK_CALLED(SetPriority);
2607         CHECK_CALLED(Start);
2608         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2609             CHECK_CALLED(Terminate);
2610         if(test_protocol == FILE_TEST)
2611             CLEAR_CALLED(OnProgress_MIMETYPEAVAILABLE); /* not called in IE7 */
2612         CHECK_CALLED(UnlockRequest);
2613     }else {
2614         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2615             CHECK_CALLED(QueryInterface_IHttpNegotiate);
2616             CHECK_CALLED(BeginningTransaction);
2617             if (have_IHttpNegotiate2)
2618             {
2619                 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
2620                 CHECK_CALLED(GetRootSecurityId);
2621             }
2622             if(http_is_first) {
2623                 CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
2624                 CHECK_CALLED(Obj_OnProgress_CONNECTING);
2625             }else todo_wine {
2626                 CHECK_NOT_CALLED(Obj_OnProgress_FINDINGRESOURCE);
2627                 /* IE7 does call this */
2628                 CLEAR_CALLED(Obj_OnProgress_CONNECTING);
2629             }
2630             CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
2631             CLEAR_CALLED(QueryService_IWindowForBindingUI);
2632         }
2633         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST) {
2634             if(urls[test_protocol] == SHORT_RESPONSE_URL)
2635                 CLEAR_CALLED(Obj_OnProgress_SENDINGREQUEST);
2636             else
2637                 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
2638         }
2639         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2640             CLEAR_CALLED(QueryInterface_IHttpNegotiate);
2641             CHECK_CALLED(OnResponse);
2642         }
2643         CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
2644         CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
2645         if(test_protocol == FILE_TEST)
2646             CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
2647         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2648             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2649         CLEAR_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
2650         CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
2651         CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
2652         CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
2653         CHECK_CALLED(OnObjectAvailable);
2654         CHECK_CALLED(Obj_OnStopBinding);
2655     }
2656
2657     if(test_protocol != HTTP_TEST || emulate_protocol || !(bindf & BINDF_ASYNCHRONOUS)) {
2658         ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2659         ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
2660     }else {
2661         todo_wine ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2662         IBindCtx_Release(bctx);
2663     }
2664
2665     if(emulate_protocol)
2666         CoRevokeClassObject(regid);
2667
2668     if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2669         http_is_first = FALSE;
2670 }
2671
2672 static void test_URLDownloadToFile(DWORD prot, BOOL emul)
2673 {
2674     BOOL res;
2675     HRESULT hres;
2676
2677     init_bind_test(prot, BINDTEST_FILEDWLAPI | (emul ? BINDTEST_EMULATE : 0), TYMED_FILE);
2678
2679     SET_EXPECT(GetBindInfo);
2680     SET_EXPECT(QueryInterface_IInternetProtocol);
2681     if(!emulate_protocol) {
2682         SET_EXPECT(QueryInterface_IServiceProvider);
2683         SET_EXPECT(QueryService_IInternetProtocol);
2684     }
2685     SET_EXPECT(OnStartBinding);
2686     if(emulate_protocol) {
2687         if(is_urlmon_protocol(test_protocol))
2688             SET_EXPECT(SetPriority);
2689         SET_EXPECT(Start);
2690         SET_EXPECT(UnlockRequest);
2691     }else {
2692         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2693             SET_EXPECT(QueryInterface_IHttpNegotiate);
2694             SET_EXPECT(BeginningTransaction);
2695             SET_EXPECT(QueryInterface_IHttpNegotiate2);
2696             SET_EXPECT(GetRootSecurityId);
2697             SET_EXPECT(QueryInterface_IWindowForBindingUI);
2698             SET_EXPECT(OnProgress_CONNECTING);
2699         }
2700         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
2701             SET_EXPECT(OnProgress_SENDINGREQUEST);
2702         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2703             SET_EXPECT(QueryInterface_IHttpNegotiate);
2704             SET_EXPECT(OnResponse);
2705         }
2706         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
2707         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
2708         if(test_protocol == FILE_TEST)
2709             SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
2710         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2711             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
2712         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
2713         SET_EXPECT(OnStopBinding);
2714     }
2715
2716     hres = URLDownloadToFileW(NULL, test_protocol == FILE_TEST ? file_url : urls[test_protocol],
2717             dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
2718     ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
2719
2720     CHECK_CALLED(GetBindInfo);
2721     CHECK_CALLED(QueryInterface_IInternetProtocol);
2722     if(!emulate_protocol) {
2723         CHECK_CALLED(QueryInterface_IServiceProvider);
2724         CHECK_CALLED(QueryService_IInternetProtocol);
2725     }
2726     CHECK_CALLED(OnStartBinding);
2727     if(emulate_protocol) {
2728         if(is_urlmon_protocol(test_protocol))
2729             CHECK_CALLED(SetPriority);
2730         CHECK_CALLED(Start);
2731         CHECK_CALLED(UnlockRequest);
2732     }else {
2733         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2734             CHECK_CALLED(QueryInterface_IHttpNegotiate);
2735             CHECK_CALLED(BeginningTransaction);
2736             if (have_IHttpNegotiate2)
2737             {
2738                 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
2739                 CHECK_CALLED(GetRootSecurityId);
2740             }
2741             CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
2742             CLEAR_CALLED(OnProgress_CONNECTING);
2743         }
2744         if(test_protocol == FILE_TEST)
2745             CHECK_CALLED(OnProgress_SENDINGREQUEST);
2746         else if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2747             CLEAR_CALLED(OnProgress_SENDINGREQUEST); /* not called by IE7 */
2748         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
2749             CLEAR_CALLED(QueryInterface_IHttpNegotiate);
2750             CHECK_CALLED(OnResponse);
2751         }
2752         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
2753         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
2754         if(test_protocol == FILE_TEST)
2755             CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
2756         if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2757             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2758         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
2759         CHECK_CALLED(OnStopBinding);
2760     }
2761
2762     res = DeleteFileA(dwl_htmlA);
2763     ok(res, "DeleteFile failed: %u\n", GetLastError());
2764
2765     if(prot != FILE_TEST || emul)
2766         return;
2767
2768     hres = URLDownloadToFileW(NULL, urls[test_protocol], dwl_htmlW, 0, NULL);
2769     ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
2770
2771     res = DeleteFileA(dwl_htmlA);
2772     ok(res, "DeleteFile failed: %u\n", GetLastError());
2773 }
2774
2775 static void set_file_url(char *path)
2776 {
2777     CHAR file_urlA[INTERNET_MAX_URL_LENGTH];
2778     CHAR INDEX_HTMLA[MAX_PATH];
2779
2780     lstrcpyA(file_urlA, "file:///");
2781     lstrcatA(file_urlA, path);
2782     MultiByteToWideChar(CP_ACP, 0, file_urlA, -1, file_url, INTERNET_MAX_URL_LENGTH);
2783
2784     lstrcpyA(INDEX_HTMLA, "file://");
2785     lstrcatA(INDEX_HTMLA, path);
2786     MultiByteToWideChar(CP_ACP, 0, INDEX_HTMLA, -1, INDEX_HTML, MAX_PATH);
2787 }
2788
2789 static void create_file(void)
2790 {
2791     HANDLE file;
2792     DWORD size;
2793     CHAR path[MAX_PATH];
2794
2795     static const char html_doc[] = "<HTML></HTML>";
2796
2797     file = CreateFileA(wszIndexHtmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2798             FILE_ATTRIBUTE_NORMAL, NULL);
2799     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
2800     if(file == INVALID_HANDLE_VALUE)
2801         return;
2802
2803     WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
2804     CloseHandle(file);
2805
2806     GetCurrentDirectoryA(MAX_PATH, path);
2807     lstrcatA(path, "\\");
2808     lstrcatA(path, wszIndexHtmlA);
2809     set_file_url(path);
2810 }
2811
2812 static void create_cache_file(void)
2813 {
2814     char buf[6500];
2815     HANDLE file;
2816     DWORD size;
2817
2818     file = CreateFileW(test_txtW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2819             FILE_ATTRIBUTE_NORMAL, NULL);
2820     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
2821     if(file == INVALID_HANDLE_VALUE)
2822         return;
2823
2824     memset(buf, 'X', sizeof(buf));
2825     WriteFile(file, buf, sizeof(buf), &size, NULL);
2826     CloseHandle(file);
2827
2828     size = GetCurrentDirectoryW(MAX_PATH, cache_file_name);
2829     cache_file_name[size] = '\\';
2830     memcpy(cache_file_name+size+1, test_txtW, sizeof(test_txtW));
2831 }
2832
2833 static void test_ReportResult(HRESULT exhres)
2834 {
2835     IMoniker *mon = NULL;
2836     IBindCtx *bctx = NULL;
2837     IUnknown *unk = (void*)0xdeadbeef;
2838     HRESULT hres;
2839
2840     init_bind_test(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
2841     binding_hres = exhres;
2842
2843     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
2844     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2845
2846     SET_EXPECT(QueryInterface_IServiceProvider);
2847     hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
2848     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
2849     CHECK_CALLED(QueryInterface_IServiceProvider);
2850
2851     SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2852     SET_EXPECT(GetBindInfo);
2853     SET_EXPECT(QueryInterface_IInternetProtocol);
2854     SET_EXPECT(OnStartBinding);
2855     if(is_urlmon_protocol(test_protocol))
2856         SET_EXPECT(SetPriority);
2857     SET_EXPECT(Start);
2858
2859     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
2860     if(SUCCEEDED(exhres))
2861         ok(hres == S_OK || hres == MK_S_ASYNCHRONOUS, "BindToStorage failed: %08x\n", hres);
2862     else
2863         ok(hres == exhres || hres == MK_S_ASYNCHRONOUS,
2864            "BindToStorage failed: %08x, expected %08x or MK_S_ASYNCHRONOUS\n", hres, exhres);
2865
2866     CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2867     CHECK_CALLED(GetBindInfo);
2868     CHECK_CALLED(QueryInterface_IInternetProtocol);
2869     CHECK_CALLED(OnStartBinding);
2870     if(is_urlmon_protocol(test_protocol))
2871         CHECK_CALLED(SetPriority);
2872     CHECK_CALLED(Start);
2873
2874     ok(unk == NULL, "unk=%p\n", unk);
2875
2876     IBindCtx_Release(bctx);
2877     IMoniker_Release(mon);
2878 }
2879
2880 static void test_BindToStorage_fail(void)
2881 {
2882     IMoniker *mon = NULL;
2883     IBindCtx *bctx = NULL;
2884     IUnknown *unk;
2885     HRESULT hres;
2886
2887     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
2888     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2889     if(FAILED(hres))
2890         return;
2891
2892     hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
2893     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2894
2895     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
2896     ok(hres == MK_E_SYNTAX || hres == INET_E_DATA_NOT_AVAILABLE,
2897        "hres=%08x, expected MK_E_SYNTAX or INET_E_DATA_NOT_AVAILABLE\n", hres);
2898
2899     IBindCtx_Release(bctx);
2900
2901     IMoniker_Release(mon);
2902
2903     test_ReportResult(E_NOTIMPL);
2904     test_ReportResult(S_FALSE);
2905 }
2906
2907 static void test_StdURLMoniker(void)
2908 {
2909     IMoniker *mon, *async_mon;
2910     LPOLESTR display_name;
2911     HRESULT hres;
2912
2913     hres = CoCreateInstance(&IID_IInternet, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2914             &IID_IMoniker, (void**)&mon);
2915     ok(hres == S_OK, "Could not create IInternet instance: %08x\n", hres);
2916     if(FAILED(hres))
2917         return;
2918
2919     hres = IMoniker_QueryInterface(mon, &IID_IAsyncMoniker, (void**)&async_mon);
2920     ok(hres == S_OK, "Could not get IAsyncMoniker iface: %08x\n", hres);
2921     ok(mon == async_mon, "mon != async_mon\n");
2922     IMoniker_Release(async_mon);
2923
2924     hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
2925     ok(hres == E_OUTOFMEMORY, "GetDisplayName failed: %08x, expected E_OUTOFMEMORY\n", hres);
2926
2927     IMoniker_Release(mon);
2928 }
2929
2930 START_TEST(url)
2931 {
2932     HMODULE hurlmon;
2933
2934     hurlmon = GetModuleHandle("urlmon.dll");
2935     pCreateAsyncBindCtxEx = (void*) GetProcAddress(hurlmon, "CreateAsyncBindCtxEx");
2936
2937     complete_event = CreateEvent(NULL, FALSE, FALSE, NULL);
2938     complete_event2 = CreateEvent(NULL, FALSE, FALSE, NULL);
2939     thread_id = GetCurrentThreadId();
2940     create_file();
2941     create_cache_file();
2942
2943     test_create();
2944
2945     trace("test CreateAsyncBindCtx...\n");
2946     test_CreateAsyncBindCtx();
2947
2948     trace("test CreateAsyncBindCtxEx...\n");
2949     test_CreateAsyncBindCtxEx();
2950
2951     trace("test RegisterBindStatusCallback...\n");
2952     if(test_RegisterBindStatusCallback()) {
2953         trace("test BindToStorage failures...\n");
2954         test_BindToStorage_fail();
2955
2956         trace("synchronous http test (COM not initialised)...\n");
2957         test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
2958
2959         CoInitialize(NULL);
2960
2961         trace("test StdURLMoniker...\n");
2962         test_StdURLMoniker();
2963
2964         trace("synchronous http test...\n");
2965         test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
2966
2967         trace("emulated synchronous http test (to file)...\n");
2968         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
2969
2970         trace("synchronous http test (to object)...\n");
2971         test_BindToObject(HTTP_TEST, 0);
2972
2973         trace("emulated synchronous http test (with cache)...\n");
2974         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
2975
2976         trace("emulated synchronous http test (with cache, no read)...\n");
2977         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
2978
2979         trace("synchronous http test (with cache, no read)...\n");
2980         test_BindToStorage(HTTP_TEST, BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
2981
2982         trace("synchronous file test...\n");
2983         test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
2984
2985         trace("emulated synchronous file test (to file)...\n");
2986         test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
2987
2988         trace("synchronous file test (to object)...\n");
2989         test_BindToObject(FILE_TEST, 0);
2990
2991         bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
2992
2993         trace("http test...\n");
2994         test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
2995
2996         trace("http test (to file)...\n");
2997         test_BindToStorage(HTTP_TEST, 0, TYMED_FILE);
2998
2999         trace("http test (to object)...\n");
3000         test_BindToObject(HTTP_TEST, 0);
3001
3002         trace("http test (short response)...\n");
3003         http_is_first = TRUE;
3004         test_BindToStorage(HTTP_TEST, BINDTEST_HTTPRESPONSE, TYMED_ISTREAM);
3005
3006         trace("http test (short response, to object)...\n");
3007         test_BindToObject(HTTP_TEST, 0);
3008
3009         trace("emulated http test...\n");
3010         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3011
3012         trace("emulated http test (to object)...\n");
3013         test_BindToObject(HTTP_TEST, BINDTEST_EMULATE);
3014
3015         trace("emulated http test (to object, redirect)...\n");
3016         test_BindToObject(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT);
3017
3018         trace("emulated http test (to file)...\n");
3019         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
3020
3021         trace("emulated http test (redirect)...\n");
3022         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT, TYMED_ISTREAM);
3023
3024         trace("emulated http test (with cache)...\n");
3025         test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
3026
3027         trace("asynchronous https test...\n");
3028         test_BindToStorage(HTTPS_TEST, 0, TYMED_ISTREAM);
3029
3030         trace("emulated https test...\n");
3031         test_BindToStorage(HTTPS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3032
3033         trace("about test...\n");
3034         test_BindToStorage(ABOUT_TEST, 0, TYMED_ISTREAM);
3035
3036         trace("about test (to file)...\n");
3037         test_BindToStorage(ABOUT_TEST, 0, TYMED_FILE);
3038
3039         trace("about test (to object)...\n");
3040         test_BindToObject(ABOUT_TEST, 0);
3041
3042         trace("emulated about test...\n");
3043         test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3044
3045         trace("emulated about test (to file)...\n");
3046         test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_FILE);
3047
3048         trace("emulated about test (to object)...\n");
3049         test_BindToObject(ABOUT_TEST, BINDTEST_EMULATE);
3050
3051         trace("file test...\n");
3052         test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
3053
3054         trace("file test (to file)...\n");
3055         test_BindToStorage(FILE_TEST, 0, TYMED_FILE);
3056
3057         trace("file test (to object)...\n");
3058         test_BindToObject(FILE_TEST, 0);
3059
3060         trace("emulated file test...\n");
3061         test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3062
3063         trace("emulated file test (to file)...\n");
3064         test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
3065
3066         trace("emulated file test (to object)...\n");
3067         test_BindToObject(FILE_TEST, BINDTEST_EMULATE);
3068
3069         trace("emulated its test...\n");
3070         test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3071
3072         trace("emulated its test (to file)...\n");
3073         test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_FILE);
3074
3075         trace("emulated mk test...\n");
3076         test_BindToStorage(MK_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3077
3078         trace("test URLDownloadToFile for file protocol...\n");
3079         test_URLDownloadToFile(FILE_TEST, FALSE);
3080
3081         trace("test URLDownloadToFile for emulated file protocol...\n");
3082         test_URLDownloadToFile(FILE_TEST, TRUE);
3083
3084         trace("test URLDownloadToFile for http protocol...\n");
3085         test_URLDownloadToFile(HTTP_TEST, FALSE);
3086
3087         bindf |= BINDF_NOWRITECACHE;
3088
3089         trace("ftp test...\n");
3090         test_BindToStorage(FTP_TEST, 0, TYMED_ISTREAM);
3091
3092         trace("test failures...\n");
3093         test_BindToStorage_fail();
3094     }
3095
3096     DeleteFileA(wszIndexHtmlA);
3097     DeleteFileW(test_txtW);
3098     CloseHandle(complete_event);
3099     CloseHandle(complete_event2);
3100     CoUninitialize();
3101 }