rostests/winetests/urlmon/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                 CHECK_NOT_CALLED(OnProgress_CONNECTING);
2126             }
2127         }
2128         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
2129             CHECK_CALLED(OnProgress_SENDINGREQUEST);
2130         if(test_protocol == HTTP_TEST)
2131             CHECK_CALLED(OnResponse);
2132         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
2133         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
2134         if(test_protocol == FILE_TEST)
2135             CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
2136         if(test_protocol == HTTP_TEST)
2137             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2138         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
2139         if(tymed != TYMED_FILE || test_protocol != ABOUT_TEST)
2140             CHECK_CALLED(OnDataAvailable);
2141         CHECK_CALLED(OnStopBinding);
2142     }
2143
2144     ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2145     ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
2146
2147     if(test_protocol == HTTP_TEST)
2148         http_is_first = FALSE;
2149 }
2150
2151 static void test_BindToObject(int protocol, BOOL emul)
2152 {
2153     IMoniker *mon;
2154     HRESULT hres;
2155     LPOLESTR display_name;
2156     IBindCtx *bctx;
2157     DWORD regid;
2158     MSG msg;
2159     IUnknown *unk = (IUnknown*)0x00ff00ff;
2160     IBinding *bind;
2161
2162     init_bind_test(protocol, BINDTEST_TOOBJECT | (emul ? BINDTEST_EMULATE : 0), TYMED_ISTREAM);
2163
2164     if(emul)
2165         CoRegisterClassObject(&CLSID_HTMLDocument, (IUnknown *)&mime_cf,
2166                               CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2167
2168     SET_EXPECT(QueryInterface_IServiceProvider);
2169     hres = CreateAsyncBindCtx(0, &objbsc, NULL, &bctx);
2170     ok(SUCCEEDED(hres), "CreateAsyncBindCtx failed: %08x\n\n", hres);
2171     CHECK_CALLED(QueryInterface_IServiceProvider);
2172     if(FAILED(hres))
2173         return;
2174
2175     hres = CreateURLMoniker(NULL, test_protocol == FILE_TEST ? file_url : urls[test_protocol], &mon);
2176     ok(SUCCEEDED(hres), "failed to create moniker: %08x\n", hres);
2177     if(FAILED(hres)) {
2178         IBindCtx_Release(bctx);
2179         return;
2180     }
2181
2182     hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
2183     ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
2184     if(SUCCEEDED(hres))
2185         IBinding_Release(bind);
2186
2187     hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
2188     ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
2189     ok(!lstrcmpW(display_name, urls[test_protocol]), "GetDisplayName got wrong name\n");
2190
2191     SET_EXPECT(Obj_GetBindInfo);
2192     SET_EXPECT(QueryInterface_IInternetProtocol);
2193     if(!emulate_protocol)
2194         SET_EXPECT(QueryService_IInternetProtocol);
2195     SET_EXPECT(Obj_OnStartBinding);
2196     if(emulate_protocol) {
2197         SET_EXPECT(Start);
2198         if(test_protocol == HTTP_TEST)
2199             SET_EXPECT(Terminate);
2200         if(test_protocol == FILE_TEST)
2201             SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
2202         SET_EXPECT(UnlockRequest);
2203     }else {
2204         if(test_protocol == HTTP_TEST) {
2205             SET_EXPECT(QueryInterface_IHttpNegotiate);
2206             SET_EXPECT(BeginningTransaction);
2207             SET_EXPECT(QueryInterface_IHttpNegotiate2);
2208             SET_EXPECT(GetRootSecurityId);
2209             SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
2210             SET_EXPECT(Obj_OnProgress_CONNECTING);
2211         }
2212         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
2213             SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
2214         if(test_protocol == HTTP_TEST)
2215             SET_EXPECT(OnResponse);
2216         SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
2217         SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
2218         if(test_protocol == FILE_TEST)
2219             SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
2220         if(test_protocol == HTTP_TEST)
2221             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
2222         SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
2223         SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
2224         SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
2225         SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
2226         SET_EXPECT(OnObjectAvailable);
2227         SET_EXPECT(Obj_OnStopBinding);
2228     }
2229
2230     hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
2231
2232     if (test_protocol == HTTP_TEST && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
2233     {
2234         skip( "Network unreachable, skipping tests\n" );
2235         return;
2236     }
2237
2238     /* no point testing the calls if binding didn't even work */
2239     if (FAILED(hres)) return;
2240
2241     if(bindf & BINDF_ASYNCHRONOUS) {
2242         ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToObject failed: %08x\n", hres);
2243         ok(unk == NULL, "istr should be NULL\n");
2244     }else {
2245         ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
2246         ok(unk != NULL, "unk == NULL\n");
2247         if(emul)
2248             ok(unk == (IUnknown*)&PersistMoniker, "unk != PersistMoniker\n");
2249     }
2250     if(unk)
2251         IUnknown_Release(unk);
2252
2253     while((bindf & BINDF_ASYNCHRONOUS) &&
2254           !((!emul || stopped_binding) && stopped_obj_binding) && GetMessage(&msg,NULL,0,0)) {
2255         TranslateMessage(&msg);
2256         DispatchMessage(&msg);
2257     }
2258
2259     CHECK_CALLED(Obj_GetBindInfo);
2260     CHECK_CALLED(QueryInterface_IInternetProtocol);
2261     if(!emulate_protocol)
2262         CHECK_CALLED(QueryService_IInternetProtocol);
2263     CHECK_CALLED(Obj_OnStartBinding);
2264     if(emulate_protocol) {
2265         CHECK_CALLED(Start);
2266         if(test_protocol == HTTP_TEST)
2267             CHECK_CALLED(Terminate);
2268         if(test_protocol == FILE_TEST)
2269             CLEAR_CALLED(OnProgress_MIMETYPEAVAILABLE); /* not called in IE7 */
2270         CHECK_CALLED(UnlockRequest);
2271     }else {
2272         if(test_protocol == HTTP_TEST) {
2273             CHECK_CALLED(QueryInterface_IHttpNegotiate);
2274             CHECK_CALLED(BeginningTransaction);
2275             /* QueryInterface_IHttpNegotiate2 and GetRootSecurityId
2276              * called on WinXP but not on Win98 */
2277             CLEAR_CALLED(QueryInterface_IHttpNegotiate2);
2278             CLEAR_CALLED(GetRootSecurityId);
2279             if(http_is_first) {
2280                 CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
2281                 CHECK_CALLED(Obj_OnProgress_CONNECTING);
2282             }else todo_wine {
2283                 CHECK_NOT_CALLED(Obj_OnProgress_FINDINGRESOURCE);
2284                 CHECK_NOT_CALLED(Obj_OnProgress_CONNECTING);
2285             }
2286         }
2287         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST) {
2288             if(urls[test_protocol] == SHORT_RESPONSE_URL)
2289                 CLEAR_CALLED(Obj_OnProgress_SENDINGREQUEST);
2290             else
2291                 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
2292         }
2293         if(test_protocol == HTTP_TEST)
2294             CHECK_CALLED(OnResponse);
2295         CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
2296         CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
2297         if(test_protocol == FILE_TEST)
2298             CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
2299         if(test_protocol == HTTP_TEST)
2300             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2301         CLEAR_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
2302         CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
2303         CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
2304         CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
2305         CHECK_CALLED(OnObjectAvailable);
2306         CHECK_CALLED(Obj_OnStopBinding);
2307     }
2308
2309     if(test_protocol != HTTP_TEST || emul || urls[test_protocol] == SHORT_RESPONSE_URL) {
2310         ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2311         ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
2312     }else {
2313         todo_wine ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
2314
2315         if(bindf & BINDF_ASYNCHRONOUS)
2316             ok(IBindCtx_Release(bctx) != 0, "bctx should not be destroyed here\n");
2317         else
2318             todo_wine ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
2319     }
2320
2321     if(emul)
2322         CoRevokeClassObject(regid);
2323
2324     if(test_protocol == HTTP_TEST)
2325         http_is_first = FALSE;
2326 }
2327
2328 static void test_URLDownloadToFile(DWORD prot, BOOL emul)
2329 {
2330     BOOL res;
2331     HRESULT hres;
2332
2333     init_bind_test(prot, BINDTEST_FILEDWLAPI | (emul ? BINDTEST_EMULATE : 0), TYMED_FILE);
2334
2335     SET_EXPECT(GetBindInfo);
2336     SET_EXPECT(QueryInterface_IInternetProtocol);
2337     if(!emulate_protocol) {
2338         SET_EXPECT(QueryInterface_IServiceProvider);
2339         SET_EXPECT(QueryService_IInternetProtocol);
2340     }
2341     SET_EXPECT(OnStartBinding);
2342     if(emulate_protocol) {
2343         SET_EXPECT(Start);
2344         SET_EXPECT(UnlockRequest);
2345     }else {
2346         if(test_protocol == HTTP_TEST) {
2347             SET_EXPECT(QueryInterface_IHttpNegotiate);
2348             SET_EXPECT(BeginningTransaction);
2349             SET_EXPECT(QueryInterface_IHttpNegotiate2);
2350             SET_EXPECT(GetRootSecurityId);
2351         }
2352         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
2353             SET_EXPECT(OnProgress_SENDINGREQUEST);
2354         if(test_protocol == HTTP_TEST)
2355             SET_EXPECT(OnResponse);
2356         SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
2357         SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
2358         if(test_protocol == FILE_TEST)
2359             SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
2360         if(test_protocol == HTTP_TEST)
2361             SET_EXPECT(OnProgress_DOWNLOADINGDATA);
2362         SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
2363         SET_EXPECT(OnStopBinding);
2364     }
2365
2366     hres = URLDownloadToFileW(NULL, test_protocol == FILE_TEST ? file_url : urls[test_protocol], dwl_htmlW, 0, &bsc);
2367     ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
2368
2369     CHECK_CALLED(GetBindInfo);
2370     CHECK_CALLED(QueryInterface_IInternetProtocol);
2371     if(!emulate_protocol) {
2372         CHECK_CALLED(QueryInterface_IServiceProvider);
2373         CHECK_CALLED(QueryService_IInternetProtocol);
2374     }
2375     CHECK_CALLED(OnStartBinding);
2376     if(emulate_protocol) {
2377         CHECK_CALLED(Start);
2378         CHECK_CALLED(UnlockRequest);
2379     }else {
2380         if(test_protocol == HTTP_TEST) {
2381             CHECK_CALLED(QueryInterface_IHttpNegotiate);
2382             CHECK_CALLED(BeginningTransaction);
2383             CHECK_CALLED(QueryInterface_IHttpNegotiate2);
2384             CHECK_CALLED(GetRootSecurityId);
2385         }
2386         if(test_protocol == HTTP_TEST || test_protocol == FILE_TEST)
2387             CHECK_CALLED(OnProgress_SENDINGREQUEST);
2388         if(test_protocol == HTTP_TEST)
2389             CHECK_CALLED(OnResponse);
2390         CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
2391         CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
2392         if(test_protocol == FILE_TEST)
2393             CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
2394         if(test_protocol == HTTP_TEST)
2395             CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
2396         CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
2397         CHECK_CALLED(OnStopBinding);
2398     }
2399
2400     res = DeleteFileW(dwl_htmlW);
2401     ok(res, "DeleteFile failed: %u\n", GetLastError());
2402
2403     if(prot != FILE_TEST || emul)
2404         return;
2405
2406     hres = URLDownloadToFileW(NULL, urls[test_protocol], dwl_htmlW, 0, NULL);
2407     ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
2408
2409     res = DeleteFileW(dwl_htmlW);
2410     ok(res, "DeleteFile failed: %u\n", GetLastError());
2411 }
2412
2413 static void set_file_url(void)
2414 {
2415     int len;
2416
2417     static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
2418
2419     memcpy(file_url, wszFile, sizeof(wszFile));
2420     len = sizeof(wszFile)/sizeof(WCHAR);
2421     file_url[len++] = '/';
2422     len += GetCurrentDirectoryW(sizeof(file_url)/sizeof(WCHAR)-len, file_url+len);
2423     file_url[len++] = '\\';
2424     memcpy(file_url+len, wszIndexHtml, sizeof(wszIndexHtml));
2425
2426     memcpy(INDEX_HTML, wszFile, sizeof(wszIndexHtml));
2427     memmove(INDEX_HTML+7, file_url+8, (lstrlenW(file_url+8)+1)*sizeof(WCHAR));
2428 }
2429
2430 static void create_file(void)
2431 {
2432     HANDLE file;
2433     DWORD size;
2434
2435     static const char html_doc[] = "<HTML></HTML>";
2436
2437     file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2438             FILE_ATTRIBUTE_NORMAL, NULL);
2439     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
2440     if(file == INVALID_HANDLE_VALUE)
2441         return;
2442
2443     WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
2444     CloseHandle(file);
2445
2446     set_file_url();
2447 }
2448
2449 static void test_ReportResult(HRESULT exhres)
2450 {
2451     IMoniker *mon = NULL;
2452     IBindCtx *bctx = NULL;
2453     IUnknown *unk = (void*)0xdeadbeef;
2454     HRESULT hres;
2455
2456     init_bind_test(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
2457     binding_hres = exhres;
2458
2459     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
2460     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2461
2462     SET_EXPECT(QueryInterface_IServiceProvider);
2463     hres = CreateAsyncBindCtx(0, &bsc, NULL, &bctx);
2464     ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
2465     CHECK_CALLED(QueryInterface_IServiceProvider);
2466
2467     SET_EXPECT(GetBindInfo);
2468     SET_EXPECT(QueryInterface_IInternetProtocol);
2469     SET_EXPECT(OnStartBinding);
2470     SET_EXPECT(Start);
2471
2472     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
2473     if(SUCCEEDED(exhres))
2474         ok(hres == S_OK || hres == MK_S_ASYNCHRONOUS, "BindToStorage failed: %08x\n", hres);
2475     else
2476         ok(hres == exhres || hres == MK_S_ASYNCHRONOUS,
2477            "BindToStorage failed: %08x, expected %08x or MK_S_ASYNCHRONOUS\n", hres, exhres);
2478
2479     CHECK_CALLED(GetBindInfo);
2480     CHECK_CALLED(QueryInterface_IInternetProtocol);
2481     CHECK_CALLED(OnStartBinding);
2482     CHECK_CALLED(Start);
2483
2484     ok(unk == NULL, "unk=%p\n", unk);
2485
2486     IBindCtx_Release(bctx);
2487     IMoniker_Release(mon);
2488 }
2489
2490 static void test_BindToStorage_fail(void)
2491 {
2492     IMoniker *mon = NULL;
2493     IBindCtx *bctx = NULL;
2494     IUnknown *unk;
2495     HRESULT hres;
2496
2497     hres = CreateURLMoniker(NULL, ABOUT_BLANK, &mon);
2498     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2499     if(FAILED(hres))
2500         return;
2501
2502     hres = CreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
2503     ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2504
2505     hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
2506     ok(hres == MK_E_SYNTAX || hres == INET_E_DATA_NOT_AVAILABLE,
2507        "hres=%08x, expected MK_E_SYNTAX or INET_E_DATA_NOT_AVAILABLE\n", hres);
2508
2509     IBindCtx_Release(bctx);
2510
2511     IMoniker_Release(mon);
2512
2513     test_ReportResult(E_NOTIMPL);
2514     test_ReportResult(S_FALSE);
2515 }
2516
2517 static void gecko_installer_workaround(BOOL disable)
2518 {
2519     HKEY hkey;
2520     DWORD res;
2521
2522     static BOOL has_url = FALSE;
2523     static char url[2048];
2524
2525     if(!disable && !has_url)
2526         return;
2527
2528     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
2529     if(res != ERROR_SUCCESS)
2530         return;
2531
2532     if(disable) {
2533         DWORD type, size = sizeof(url);
2534
2535         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
2536         if(res == ERROR_SUCCESS && type == REG_SZ)
2537             has_url = TRUE;
2538
2539         RegDeleteValue(hkey, "GeckoUrl");
2540     }else {
2541         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
2542     }
2543
2544     RegCloseKey(hkey);
2545 }
2546
2547 START_TEST(url)
2548 {
2549     gecko_installer_workaround(TRUE);
2550
2551     complete_event = CreateEvent(NULL, FALSE, FALSE, NULL);
2552     complete_event2 = CreateEvent(NULL, FALSE, FALSE, NULL);
2553     thread_id = GetCurrentThreadId();
2554     create_file();
2555
2556     test_create();
2557     test_CreateAsyncBindCtx();
2558     test_CreateAsyncBindCtxEx();
2559     test_RegisterBindStatusCallback();
2560     test_BindToStorage_fail();
2561
2562     trace("synchronous http test (COM not initialised)...\n");
2563     test_BindToStorage(HTTP_TEST, FALSE, TYMED_ISTREAM);
2564
2565     CoInitialize(NULL);
2566
2567     trace("synchronous http test...\n");
2568     test_BindToStorage(HTTP_TEST, FALSE, TYMED_ISTREAM);
2569
2570     trace("synchronous http test (to object)...\n");
2571     test_BindToObject(HTTP_TEST, FALSE);
2572
2573     trace("synchronous file test...\n");
2574     test_BindToStorage(FILE_TEST, FALSE, TYMED_ISTREAM);
2575
2576     trace("synchronous file test (to object)...\n");
2577     test_BindToObject(FILE_TEST, FALSE);
2578
2579     bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
2580
2581     trace("http test...\n");
2582     test_BindToStorage(HTTP_TEST, FALSE, TYMED_ISTREAM);
2583
2584     trace("http test (to file)...\n");
2585     test_BindToStorage(HTTP_TEST, FALSE, TYMED_FILE);
2586
2587     trace("http test (to object)...\n");
2588     test_BindToObject(HTTP_TEST, FALSE);
2589
2590     trace("http test (short response)...\n");
2591     http_is_first = TRUE;
2592     urls[HTTP_TEST] = SHORT_RESPONSE_URL;
2593     test_BindToStorage(HTTP_TEST, FALSE, TYMED_ISTREAM);
2594
2595     trace("http test (short response, to object)...\n");
2596     test_BindToObject(HTTP_TEST, FALSE);
2597
2598     trace("emulated http test...\n");
2599     test_BindToStorage(HTTP_TEST, TRUE, TYMED_ISTREAM);
2600
2601     trace("emulated http test (to object)...\n");
2602     test_BindToObject(HTTP_TEST, TRUE);
2603
2604     trace("emulated http test (to file)...\n");
2605     test_BindToStorage(HTTP_TEST, TRUE, TYMED_FILE);
2606
2607     trace("about test...\n");
2608     test_BindToStorage(ABOUT_TEST, FALSE, TYMED_ISTREAM);
2609
2610     trace("about test (to file)...\n");
2611     test_BindToStorage(ABOUT_TEST, FALSE, TYMED_FILE);
2612
2613     trace("about test (to object)...\n");
2614     test_BindToObject(ABOUT_TEST, FALSE);
2615
2616     trace("emulated about test...\n");
2617     test_BindToStorage(ABOUT_TEST, TRUE, TYMED_ISTREAM);
2618
2619     trace("emulated about test (to file)...\n");
2620     test_BindToStorage(ABOUT_TEST, TRUE, TYMED_FILE);
2621
2622     trace("emulated about test (to object)...\n");
2623     test_BindToObject(ABOUT_TEST, TRUE);
2624
2625     trace("file test...\n");
2626     test_BindToStorage(FILE_TEST, FALSE, TYMED_ISTREAM);
2627
2628     trace("file test (to file)...\n");
2629     test_BindToStorage(FILE_TEST, FALSE, TYMED_FILE);
2630
2631     trace("file test (to object)...\n");
2632     test_BindToObject(FILE_TEST, FALSE);
2633
2634     trace("emulated file test...\n");
2635     test_BindToStorage(FILE_TEST, TRUE, TYMED_ISTREAM);
2636
2637     trace("emulated file test (to file)...\n");
2638     test_BindToStorage(FILE_TEST, TRUE, TYMED_FILE);
2639
2640     trace("emulated file test (to object)...\n");
2641     test_BindToObject(FILE_TEST, TRUE);
2642
2643     trace("emulated its test...\n");
2644     test_BindToStorage(ITS_TEST, TRUE, TYMED_ISTREAM);
2645
2646     trace("emulated its test (to file)...\n");
2647     test_BindToStorage(ITS_TEST, TRUE, TYMED_FILE);
2648
2649     trace("emulated mk test...\n");
2650     test_BindToStorage(MK_TEST, TRUE, TYMED_ISTREAM);
2651
2652     trace("test URLDownloadToFile for file protocol...\n");
2653     test_URLDownloadToFile(FILE_TEST, FALSE);
2654
2655     trace("test URLDownloadToFile for emulated file protocol...\n");
2656     test_URLDownloadToFile(FILE_TEST, TRUE);
2657
2658     trace("test URLDownloadToFile for http protocol...\n");
2659     test_URLDownloadToFile(HTTP_TEST, FALSE);
2660
2661     trace("test failures...\n");
2662     test_BindToStorage_fail();
2663
2664     DeleteFileW(wszIndexHtml);
2665     CloseHandle(complete_event);
2666     CloseHandle(complete_event2);
2667     CoUninitialize();
2668
2669     gecko_installer_workaround(FALSE);
2670 }