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