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