dlls/urlmon/tests/url.c

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