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