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