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