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