git.oblomov.eu Git - wine/blob - dlls/urlmon/tests/url.c

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