git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/htmldoc.c

   1 /*
   2  * Copyright 2005-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "mshtml.h"
  30 #include "docobj.h"
  31 #include "mshtmhst.h"
  32 #include "mshtmdid.h"
  33 #include "mshtmcid.h"
  34 #include "hlink.h"
  35 #include "idispids.h"
  36 #include "shlguid.h"
  37
  38 #include "initguid.h"
  39 DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
  40
  41 #define DEFINE_EXPECT(func) \
  42     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  43
  44 #define SET_EXPECT(func) \
  45     expect_ ## func = TRUE
  46
  47 #define SET_CALLED(func) \
  48     called_ ## func = TRUE
  49
  50 #define CHECK_EXPECT2(func) \
  51     do { \
  52         ok(expect_ ##func, "unexpected call " #func "\n"); \
  53         called_ ## func = TRUE; \
  54     }while(0)
  55
  56 #define CHECK_EXPECT(func) \
  57     do { \
  58         CHECK_EXPECT2(func); \
  59         expect_ ## func = FALSE; \
  60     }while(0)
  61
  62 #define CHECK_CALLED(func) \
  63     do { \
  64         ok(called_ ## func, "expected " #func "\n"); \
  65         expect_ ## func = called_ ## func = FALSE; \
  66     }while(0)
  67
  68 static IOleDocumentView *view = NULL;
  69 static HWND container_hwnd = NULL, hwnd = NULL, last_hwnd = NULL;
  70
  71 DEFINE_EXPECT(LockContainer);
  72 DEFINE_EXPECT(SetActiveObject);
  73 DEFINE_EXPECT(GetWindow);
  74 DEFINE_EXPECT(CanInPlaceActivate);
  75 DEFINE_EXPECT(OnInPlaceActivate);
  76 DEFINE_EXPECT(OnInPlaceActivateEx);
  77 DEFINE_EXPECT(OnUIActivate);
  78 DEFINE_EXPECT(GetWindowContext);
  79 DEFINE_EXPECT(OnUIDeactivate);
  80 DEFINE_EXPECT(OnInPlaceDeactivate);
  81 DEFINE_EXPECT(OnInPlaceDeactivateEx);
  82 DEFINE_EXPECT(GetContainer);
  83 DEFINE_EXPECT(ShowUI);
  84 DEFINE_EXPECT(ActivateMe);
  85 DEFINE_EXPECT(GetHostInfo);
  86 DEFINE_EXPECT(HideUI);
  87 DEFINE_EXPECT(GetOptionKeyPath);
  88 DEFINE_EXPECT(GetOverrideKeyPath);
  89 DEFINE_EXPECT(SetStatusText);
  90 DEFINE_EXPECT(QueryStatus_SETPROGRESSTEXT);
  91 DEFINE_EXPECT(QueryStatus_OPEN);
  92 DEFINE_EXPECT(QueryStatus_NEW);
  93 DEFINE_EXPECT(Exec_SETPROGRESSMAX);
  94 DEFINE_EXPECT(Exec_SETPROGRESSPOS);
  95 DEFINE_EXPECT(Exec_HTTPEQUIV_DONE);
  96 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE_0);
  97 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE_1);
  98 DEFINE_EXPECT(Exec_ShellDocView_37);
  99 DEFINE_EXPECT(Exec_UPDATECOMMANDS);
 100 DEFINE_EXPECT(Exec_SETTITLE);
 101 DEFINE_EXPECT(Exec_HTTPEQUIV);
 102 DEFINE_EXPECT(Exec_MSHTML_PARSECOMPLETE);
 103 DEFINE_EXPECT(Invoke_AMBIENT_USERMODE);
 104 DEFINE_EXPECT(Invoke_AMBIENT_DLCONTROL);
 105 DEFINE_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
 106 DEFINE_EXPECT(Invoke_AMBIENT_SILENT);
 107 DEFINE_EXPECT(Invoke_AMBIENT_USERAGENT);
 108 DEFINE_EXPECT(Invoke_AMBIENT_PALETTE);
 109 DEFINE_EXPECT(GetDropTarget);
 110 DEFINE_EXPECT(UpdateUI);
 111 DEFINE_EXPECT(Navigate);
 112 DEFINE_EXPECT(OnFrameWindowActivate);
 113 DEFINE_EXPECT(OnChanged_READYSTATE);
 114 DEFINE_EXPECT(OnChanged_1005);
 115 DEFINE_EXPECT(GetDisplayName);
 116 DEFINE_EXPECT(BindToStorage);
 117 DEFINE_EXPECT(IsSystemMoniker);
 118 DEFINE_EXPECT(GetBindResult);
 119 DEFINE_EXPECT(Abort);
 120 DEFINE_EXPECT(Read);
 121 DEFINE_EXPECT(CreateInstance);
 122 DEFINE_EXPECT(Start);
 123 DEFINE_EXPECT(Terminate);
 124 DEFINE_EXPECT(Protocol_Read);
 125 DEFINE_EXPECT(LockRequest);
 126 DEFINE_EXPECT(UnlockRequest);
 127 DEFINE_EXPECT(OnFocus_TRUE);
 128 DEFINE_EXPECT(OnFocus_FALSE);
 129 DEFINE_EXPECT(RequestUIActivate);
 130 DEFINE_EXPECT(InPlaceFrame_SetBorderSpace);
 131 DEFINE_EXPECT(InPlaceUIWindow_SetActiveObject);
 132 DEFINE_EXPECT(GetExternal);
 133
 134 static IUnknown *doc_unk;
 135 static BOOL expect_LockContainer_fLock;
 136 static BOOL expect_SetActiveObject_active, expect_InPlaceUIWindow_SetActiveObject_active = TRUE;
 137 static BOOL ipsex;
 138 static BOOL set_clientsite = FALSE, container_locked = FALSE;
 139 static BOOL readystate_set_loading = FALSE, load_from_stream;
 140 static BOOL editmode = FALSE;
 141 static int stream_read, protocol_read;
 142 static enum load_state_t {
 143     LD_DOLOAD,
 144     LD_LOADING,
 145     LD_INTERACTIVE,
 146     LD_COMPLETE,
 147     LD_NO
 148 } load_state;
 149
 150 static LPCOLESTR expect_status_text = NULL;
 151
 152 static const char html_page[] =
 153 "<html>"
 154 "<head><link rel=\"stylesheet\" type=\"text/css\" href=\"test.css\"></head>"
 155 "<body>test</body>"
 156 "</html>";
 157
 158 static const char css_data[] = "body {color: red}";
 159
 160 static const WCHAR doc_url[] = {'w','i','n','e','t','e','s','t',':','d','o','c',0};
 161 static const WCHAR about_blank_url[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 162
 163 static HRESULT QueryInterface(REFIID riid, void **ppv);
 164 static void test_readyState(IUnknown*);
 165 static void test_MSHTML_QueryStatus(IUnknown*,DWORD);
 166 static BOOL nogecko = FALSE;
 167
 168 static void test_GetCurMoniker(IUnknown*,IMoniker*,LPCWSTR);
 169
 170 static const WCHAR wszTimesNewRoman[] =
 171     {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
 172 static const WCHAR wszArial[] =
 173     {'A','r','i','a','l',0};
 174
 175 static const char *debugstr_guid(REFIID riid)
 176 {
 177     static char buf[50];
 178
 179     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 180             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 181             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 182             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 183
 184     return buf;
 185 }
 186
 187 #define EXPECT_UPDATEUI  1
 188 #define EXPECT_SETTITLE  2
 189
 190 static void test_timer(DWORD flags)
 191 {
 192     BOOL *b = &called_Exec_SETTITLE;
 193     MSG msg;
 194
 195     if(flags & EXPECT_UPDATEUI) {
 196         SET_EXPECT(UpdateUI);
 197         SET_EXPECT(Exec_UPDATECOMMANDS);
 198         b = &called_UpdateUI;
 199     }
 200     if(flags & EXPECT_SETTITLE)
 201         SET_EXPECT(Exec_SETTITLE);
 202
 203     while(!*b && GetMessage(&msg, hwnd, 0, 0)) {
 204         TranslateMessage(&msg);
 205         DispatchMessage(&msg);
 206     }
 207
 208     if(flags & EXPECT_UPDATEUI) {
 209         CHECK_CALLED(UpdateUI);
 210         CHECK_CALLED(Exec_UPDATECOMMANDS);
 211     }
 212     if(flags & EXPECT_SETTITLE)
 213         CHECK_CALLED(Exec_SETTITLE);
 214 }
 215
 216 static HRESULT WINAPI External_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 217 {
 218     *ppv = NULL;
 219
 220     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
 221         *ppv = iface;
 222         return S_OK;
 223     }
 224
 225     ok(0, "unexpected riid: %s\n", debugstr_guid(riid));
 226     return E_NOINTERFACE;
 227 }
 228
 229 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 230 {
 231     return 2;
 232 }
 233
 234 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 235 {
 236     return 1;
 237 }
 238
 239 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 240 {
 241     ok(0, "unexpected call\n");
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 246         ITypeInfo **ppTInfo)
 247 {
 248     ok(0, "unexpected call\n");
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 253         UINT cNames, LCID lcid, DISPID *rgDispId)
 254 {
 255     ok(0, "unexpected call\n");
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI External_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 260         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 261         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 262 {
 263     ok(0, "unexpected call\n");
 264     return E_NOTIMPL;
 265 }
 266
 267 static const IDispatchVtbl ExternalVtbl = {
 268     External_QueryInterface,
 269     Dispatch_AddRef,
 270     Dispatch_Release,
 271     Dispatch_GetTypeInfoCount,
 272     Dispatch_GetTypeInfo,
 273     Dispatch_GetIDsOfNames,
 274     External_Invoke
 275 };
 276
 277 static IDispatch External = { &ExternalVtbl };
 278
 279 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 280 {
 281     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
 282         *ppv = iface;
 283         return S_OK;
 284     }
 285
 286     *ppv = NULL;
 287     return E_NOINTERFACE;
 288 }
 289
 290 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
 291 {
 292     return 2;
 293 }
 294
 295 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
 296 {
 297     return 1;
 298 }
 299
 300 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 301         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 302         DWORD grfPI, DWORD dwReserved)
 303 {
 304     BINDINFO bindinfo;
 305     DWORD bindf = 0;
 306     HRESULT hres;
 307
 308     static const WCHAR wszTextCss[] = {'t','e','x','t','/','c','s','s',0};
 309     static const WCHAR empty_str = {0};
 310
 311     CHECK_EXPECT(Start);
 312
 313     ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
 314     ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
 315     ok(!grfPI, "grfPI = %x\n", grfPI);
 316     ok(!dwReserved, "dwReserved = %d\n", dwReserved);
 317
 318     memset(&bindinfo, 0, sizeof(bindinfo));
 319     bindinfo.cbSize = sizeof(bindinfo);
 320     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
 321     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
 322     ok(bindf == (BINDF_FROMURLMON|BINDF_PULLDATA|BINDF_NEEDFILE|BINDF_ASYNCSTORAGE|BINDF_ASYNCHRONOUS),
 323        "bindf = %x\n", bindf);
 324
 325     ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize=%d\n", bindinfo.cbSize);
 326     ok(bindinfo.szExtraInfo == NULL, "bindinfo.szExtraInfo=%p\n", bindinfo.szExtraInfo);
 327     /* TODO: test stgmedData */
 328     ok(bindinfo.grfBindInfoF == 0, "bindinfo.grfBinfInfoF=%08x\n", bindinfo.grfBindInfoF);
 329     ok(bindinfo.dwBindVerb == 0, "bindinfo.dwBindVerb=%d\n", bindinfo.dwBindVerb);
 330     ok(bindinfo.szCustomVerb == 0, "bindinfo.szCustomVerb=%p\n", bindinfo.szCustomVerb);
 331     ok(bindinfo.cbstgmedData == 0, "bindinfo.cbstgmedData=%d\n", bindinfo.cbstgmedData);
 332     ok(bindinfo.dwOptions == 0x80000, "bindinfo.dwOptions=%x\n", bindinfo.dwOptions);
 333     ok(bindinfo.dwOptionsFlags == 0, "bindinfo.dwOptionsFlags=%d\n", bindinfo.dwOptionsFlags);
 334     /* TODO: test dwCodePage */
 335     /* TODO: test securityAttributes */
 336     ok(IsEqualGUID(&IID_NULL, &bindinfo.iid), "unexpected bindinfo.iid\n");
 337     ok(bindinfo.pUnk == NULL, "bindinfo.pUnk=%p\n", bindinfo.pUnk);
 338     ok(bindinfo.dwReserved == 0, "bindinfo.dwReserved=%d\n", bindinfo.dwReserved);
 339
 340     hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 341             BINDSTATUS_CACHEFILENAMEAVAILABLE, &empty_str);
 342     ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
 343
 344     hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 345             BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextCss);
 346     ok(hres == S_OK,
 347        "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
 348
 349     hres = IInternetProtocolSink_ReportData(pOIProtSink,
 350             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION, 13, 13);
 351     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 352
 353     hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 354     ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 355
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
 360         PROTOCOLDATA *pProtocolData)
 361 {
 362     ok(0, "unexpected call\n");
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 367         DWORD dwOptions)
 368 {
 369     ok(0, "unexpected call\n");
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 374 {
 375     CHECK_EXPECT(Terminate);
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
 380 {
 381     ok(0, "unexpected call\n");
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
 386 {
 387     ok(0, "unexpected call\n");
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
 392         ULONG cb, ULONG *pcbRead)
 393 {
 394     CHECK_EXPECT2(Protocol_Read);
 395
 396     ok(pv != NULL, "pv == NULL\n");
 397     ok(cb > sizeof(css_data), "cb < sizeof(css_data)\n");
 398     ok(pcbRead != NULL, "pcbRead == NULL\n");
 399     ok(!*pcbRead, "*pcbRead=%d\n", *pcbRead);
 400
 401     if(protocol_read)
 402         return S_FALSE;
 403
 404     protocol_read += *pcbRead = sizeof(css_data)-1;
 405     memcpy(pv, css_data, sizeof(css_data)-1);
 406     return S_OK;
 407 }
 408
 409 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
 410         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 411 {
 412     ok(0, "unexpected call\n");
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 417 {
 418     CHECK_EXPECT(LockRequest);
 419     return S_OK;
 420 }
 421
 422 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
 423 {
 424     CHECK_EXPECT(UnlockRequest);
 425     return S_OK;
 426 }
 427
 428 static const IInternetProtocolVtbl ProtocolVtbl = {
 429     Protocol_QueryInterface,
 430     Protocol_AddRef,
 431     Protocol_Release,
 432     Protocol_Start,
 433     Protocol_Continue,
 434     Protocol_Abort,
 435     Protocol_Terminate,
 436     Protocol_Suspend,
 437     Protocol_Resume,
 438     Protocol_Read,
 439     Protocol_Seek,
 440     Protocol_LockRequest,
 441     Protocol_UnlockRequest
 442 };
 443
 444 static IInternetProtocol Protocol = { &ProtocolVtbl };
 445
 446 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 447 {
 448     if(!IsEqualGUID(&IID_IInternetProtocolInfo, riid))
 449         ok(0, "unexpected call\n");
 450     return E_NOINTERFACE;
 451 }
 452
 453 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 454 {
 455     return 2;
 456 }
 457
 458 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 459 {
 460     return 1;
 461 }
 462
 463 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
 464                                         REFIID riid, void **ppv)
 465 {
 466     if(IsEqualGUID(&IID_IInternetProtocolInfo, riid))
 467         return E_NOINTERFACE;
 468
 469     CHECK_EXPECT(CreateInstance);
 470     ok(ppv != NULL, "ppv == NULL\n");
 471
 472     *ppv = &Protocol;
 473     return S_OK;
 474 }
 475
 476 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 477 {
 478     ok(0, "unexpected call\n");
 479     return S_OK;
 480 }
 481
 482 static const IClassFactoryVtbl ClassFactoryVtbl = {
 483     ClassFactory_QueryInterface,
 484     ClassFactory_AddRef,
 485     ClassFactory_Release,
 486     ClassFactory_CreateInstance,
 487     ClassFactory_LockServer
 488 };
 489
 490 static IClassFactory ClassFactory = { &ClassFactoryVtbl };
 491
 492 static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv)
 493 {
 494     ok(0, "unexpected call\n");
 495     return E_NOTIMPL;
 496 }
 497
 498 static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface)
 499 {
 500     return 2;
 501 }
 502
 503 static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface)
 504 {
 505     return 1;
 506 }
 507
 508 static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface,
 509                                                   IHlinkBrowseContext *pihlbc)
 510 {
 511     ok(0, "unexpected call\n");
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface,
 516                                                   IHlinkBrowseContext **ppihlbc)
 517 {
 518     ok(0, "unexpected call\n");
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc,
 523                                           IBindStatusCallback *pibsc, IHlink *pihlNavigate)
 524 {
 525     HRESULT hres;
 526
 527     CHECK_EXPECT(Navigate);
 528
 529     ok(grfHLNF == 0, "grfHLNF=%d, expected 0\n", grfHLNF);
 530     ok(pbc != NULL, "pbc == NULL\n");
 531     ok(pibsc != NULL, "pubsc == NULL\n");
 532     ok(pihlNavigate != NULL, "puhlNavigate == NULL\n");
 533
 534     if(pihlNavigate) {
 535         LPWSTR frame_name = (LPWSTR)0xdeadbeef;
 536         LPWSTR location = (LPWSTR)0xdeadbeef;
 537         IHlinkSite *site;
 538         IMoniker *mon = NULL;
 539         DWORD site_data = 0xdeadbeef;
 540
 541         hres = IHlink_GetTargetFrameName(pihlNavigate, &frame_name);
 542         ok(hres == S_FALSE, "GetTargetFrameName failed: %08x\n", hres);
 543         ok(frame_name == NULL, "frame_name = %p\n", frame_name);
 544
 545         hres = IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location);
 546         ok(hres == S_OK, "GetMonikerReference failed: %08x\n", hres);
 547         ok(location == NULL, "location = %p\n", location);
 548         ok(mon != NULL, "mon == NULL\n");
 549
 550         hres = IHlink_GetHlinkSite(pihlNavigate, &site, &site_data);
 551         ok(hres == S_OK, "GetHlinkSite failed: %08x\n", hres);
 552         ok(site == NULL, "site = %p\n, expected NULL\n", site);
 553         ok(site_data == 0xdeadbeef, "site_data = %x\n", site_data);
 554     }
 555
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF,
 560         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved)
 561 {
 562     ok(0, "unexpected call\n");
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID,
 567         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName)
 568 {
 569     ok(0, "unexpected call\n");
 570     return E_NOTIMPL;
 571 }
 572
 573 static const IHlinkFrameVtbl HlinkFrameVtbl = {
 574     HlinkFrame_QueryInterface,
 575     HlinkFrame_AddRef,
 576     HlinkFrame_Release,
 577     HlinkFrame_SetBrowseContext,
 578     HlinkFrame_GetBrowseContext,
 579     HlinkFrame_Navigate,
 580     HlinkFrame_OnNavigate,
 581     HlinkFrame_UpdateHlink
 582 };
 583
 584 static IHlinkFrame HlinkFrame = { &HlinkFrameVtbl };
 585
 586 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 587         REFIID riid, void**ppv)
 588 {
 589     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 590         *ppv = iface;
 591         return S_OK;
 592     }
 593
 594     ok(0, "unexpected call\n");
 595     return E_NOINTERFACE;
 596 }
 597
 598 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 599 {
 600     return 2;
 601 }
 602
 603 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 604 {
 605     return 1;
 606 }
 607
 608 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 609 {
 610     switch(dispID) {
 611     case DISPID_READYSTATE:
 612         CHECK_EXPECT2(OnChanged_READYSTATE);
 613         test_MSHTML_QueryStatus(NULL, OLECMDF_SUPPORTED
 614             | (editmode && (load_state == LD_INTERACTIVE || load_state == LD_COMPLETE)
 615                ? OLECMDF_ENABLED : 0));
 616
 617         if(readystate_set_loading) {
 618             readystate_set_loading = FALSE;
 619             load_state = LD_LOADING;
 620         }
 621         test_readyState(NULL);
 622         return S_OK;
 623     case 1005:
 624         CHECK_EXPECT(OnChanged_1005);
 625         test_readyState(NULL);
 626         load_state = LD_INTERACTIVE;
 627         return S_OK;
 628     }
 629
 630     ok(0, "unexpected id %d\n", dispID);
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 635 {
 636     ok(0, "unexpected call\n");
 637     return E_NOTIMPL;
 638 }
 639
 640 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 641     PropertyNotifySink_QueryInterface,
 642     PropertyNotifySink_AddRef,
 643     PropertyNotifySink_Release,
 644     PropertyNotifySink_OnChanged,
 645     PropertyNotifySink_OnRequestEdit
 646 };
 647
 648 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 649
 650 static HRESULT WINAPI Stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
 651 {
 652     ok(0, "unexpected call\n");
 653     return E_NOINTERFACE;
 654 }
 655
 656 static ULONG WINAPI Stream_AddRef(IStream *iface)
 657 {
 658     return 2;
 659 }
 660
 661 static ULONG WINAPI Stream_Release(IStream *iface)
 662 {
 663     return 1;
 664 }
 665
 666 static HRESULT WINAPI Stream_Read(IStream *iface, void *pv,
 667                                   ULONG cb, ULONG *pcbRead)
 668 {
 669     CHECK_EXPECT2(Read);
 670     ok(pv != NULL, "pv == NULL\n");
 671     ok(cb > sizeof(html_page), "cb = %d\n", cb);
 672     ok(pcbRead != NULL, "pcbRead == NULL\n");
 673     ok(!*pcbRead, "*pcbRead = %d\n", *pcbRead);
 674
 675     if(stream_read)
 676         return S_FALSE;
 677
 678     memcpy(pv, html_page, sizeof(html_page)-1);
 679     stream_read += *pcbRead = sizeof(html_page)-1;
 680     return S_OK;
 681 }
 682
 683 static HRESULT WINAPI Stream_Write(IStream *iface, const void *pv,
 684                                           ULONG cb, ULONG *pcbWritten)
 685 {
 686     ok(0, "unexpected call\n");
 687     return E_NOTIMPL;
 688 }
 689
 690 static HRESULT WINAPI Stream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
 691                                          DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 692 {
 693     ok(0, "unexpected call\n");
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI Stream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
 698 {
 699     ok(0, "unexpected call\n");
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI Stream_CopyTo(IStream *iface, IStream *pstm,
 704         ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
 705 {
 706     ok(0, "unexpected call\n");
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI Stream_Commit(IStream *iface, DWORD grfCommitFlags)
 711 {
 712     ok(0, "unexpected call\n");
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI Stream_Revert(IStream *iface)
 717 {
 718     ok(0, "unexpected call\n");
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI Stream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
 723                                                ULARGE_INTEGER cb, DWORD dwLockType)
 724 {
 725     ok(0, "unexpected call\n");
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI Stream_UnlockRegion(IStream *iface,
 730         ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 731 {
 732     ok(0, "unexpected call\n");
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI Stream_Stat(IStream *iface, STATSTG *pstatstg,
 737                                          DWORD dwStatFlag)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI Stream_Clone(IStream *iface, IStream **ppstm)
 744 {
 745     ok(0, "unexpected call\n");
 746     return E_NOTIMPL;
 747 }
 748
 749 static const IStreamVtbl StreamVtbl = {
 750     Stream_QueryInterface,
 751     Stream_AddRef,
 752     Stream_Release,
 753     Stream_Read,
 754     Stream_Write,
 755     Stream_Seek,
 756     Stream_SetSize,
 757     Stream_CopyTo,
 758     Stream_Commit,
 759     Stream_Revert,
 760     Stream_LockRegion,
 761     Stream_UnlockRegion,
 762     Stream_Stat,
 763     Stream_Clone
 764 };
 765
 766 static IStream Stream = { &StreamVtbl };
 767
 768 static HRESULT WINAPI Binding_QueryInterface(IBinding *iface, REFIID riid, void **ppv)
 769 {
 770     if(IsEqualGUID(&IID_IWinInetHttpInfo, riid))
 771         return E_NOINTERFACE; /* TODO */
 772
 773     if(IsEqualGUID(&IID_IWinInetInfo, riid))
 774         return E_NOINTERFACE; /* TODO */
 775
 776     ok(0, "unexpected call\n");
 777     return E_NOINTERFACE;
 778 }
 779
 780 static ULONG WINAPI Binding_AddRef(IBinding *iface)
 781 {
 782     return 2;
 783 }
 784
 785 static ULONG WINAPI Binding_Release(IBinding *iface)
 786 {
 787     return 1;
 788 }
 789
 790 static HRESULT WINAPI Binding_Abort(IBinding *iface)
 791 {
 792     CHECK_EXPECT(Abort);
 793     return S_OK;
 794 }
 795
 796 static HRESULT WINAPI Binding_Suspend(IBinding *iface)
 797 {
 798     ok(0, "unexpected call\n");
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI Binding_Resume(IBinding *iface)
 803 {
 804     ok(0, "unexpected call\n");
 805     return E_NOTIMPL;
 806 }
 807
 808 static HRESULT WINAPI Binding_SetPriority(IBinding *iface, LONG nPriority)
 809 {
 810     ok(0, "unexpected call\n");
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI Binding_GetPriority(IBinding *iface, LONG *pnPriority)
 815 {
 816     ok(0, "unexpected call\n");
 817     return E_NOTIMPL;
 818 }
 819
 820 static HRESULT WINAPI Binding_GetBindResult(IBinding *iface, CLSID *pclsidProtocol,
 821         DWORD *pdwResult, LPOLESTR *pszResult, DWORD *pdwReserved)
 822 {
 823     CHECK_EXPECT(GetBindResult);
 824     return E_NOTIMPL;
 825 }
 826
 827 static const IBindingVtbl BindingVtbl = {
 828     Binding_QueryInterface,
 829     Binding_AddRef,
 830     Binding_Release,
 831     Binding_Abort,
 832     Binding_Suspend,
 833     Binding_Resume,
 834     Binding_SetPriority,
 835     Binding_GetPriority,
 836     Binding_GetBindResult
 837 };
 838
 839 static IBinding Binding = { &BindingVtbl };
 840
 841 static HRESULT WINAPI Moniker_QueryInterface(IMoniker *iface, REFIID riid, void **ppv)
 842 {
 843     *ppv = NULL;
 844     ok(0, "unexpected riid: %s\n", debugstr_guid(riid));
 845     return E_NOINTERFACE;
 846 }
 847
 848 static ULONG WINAPI Moniker_AddRef(IMoniker *iface)
 849 {
 850     return 2;
 851 }
 852
 853 static ULONG WINAPI Moniker_Release(IMoniker *iface)
 854 {
 855     return 1;
 856 }
 857
 858 static HRESULT WINAPI Moniker_GetClassID(IMoniker *iface, CLSID *pClassID)
 859 {
 860     ok(0, "unexpected call\n");
 861     return E_NOTIMPL;
 862 }
 863
 864 static HRESULT WINAPI Moniker_IsDirty(IMoniker *iface)
 865 {
 866     ok(0, "unexpected call\n");
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI Moniker_Load(IMoniker *iface, IStream *pStm)
 871 {
 872     ok(0, "unexpected call\n");
 873     return E_NOTIMPL;
 874 }
 875
 876 static HRESULT WINAPI Moniker_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
 877 {
 878     ok(0, "unexpected call\n");
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI Moniker_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
 883 {
 884     ok(0, "unexpected call\n");
 885     return E_NOTIMPL;
 886 }
 887
 888 static HRESULT WINAPI Moniker_BindToObject(IMoniker *iface, IBindCtx *pcb, IMoniker *pmkToLeft,
 889         REFIID riidResult, void **ppvResult)
 890 {
 891     ok(0, "unexpected call\n");
 892     return E_NOTIMPL;
 893 }
 894
 895 static HRESULT WINAPI Moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 896         REFIID riid, void **ppv)
 897 {
 898     IBindStatusCallback *callback = NULL;
 899     FORMATETC formatetc = {0xc02d, NULL, 1, -1, TYMED_ISTREAM};
 900     STGMEDIUM stgmedium;
 901     BINDINFO bindinfo;
 902     DWORD bindf;
 903     HRESULT hres;
 904
 905     static OLECHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
 906     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 907
 908     CHECK_EXPECT(BindToStorage);
 909
 910     ok(pbc != NULL, "pbc == NULL\n");
 911     ok(pmkToLeft == NULL, "pmkToLeft=%p\n", pmkToLeft);
 912     ok(IsEqualGUID(&IID_IStream, riid), "unexpected riid\n");
 913     ok(ppv != NULL, "ppv == NULL\n");
 914     ok(*ppv == NULL, "*ppv=%p\n", *ppv);
 915
 916     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown**)&callback);
 917     ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
 918     ok(callback != NULL, "callback == NULL\n");
 919
 920     memset(&bindinfo, 0xf0, sizeof(bindinfo));
 921     bindinfo.cbSize = sizeof(bindinfo);
 922
 923     hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo);
 924     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
 925     ok(bindf == (BINDF_PULLDATA|BINDF_ASYNCSTORAGE|BINDF_ASYNCHRONOUS), "bindf = %08x\n", bindf);
 926     ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize=%d\n", bindinfo.cbSize);
 927     ok(bindinfo.szExtraInfo == NULL, "bindinfo.szExtraInfo=%p\n", bindinfo.szExtraInfo);
 928     /* TODO: test stgmedData */
 929     ok(bindinfo.grfBindInfoF == 0, "bindinfo.grfBinfInfoF=%08x\n", bindinfo.grfBindInfoF);
 930     ok(bindinfo.dwBindVerb == 0, "bindinfo.dwBindVerb=%d\n", bindinfo.dwBindVerb);
 931     ok(bindinfo.szCustomVerb == 0, "bindinfo.szCustomVerb=%p\n", bindinfo.szCustomVerb);
 932     ok(bindinfo.cbstgmedData == 0, "bindinfo.cbstgmedData=%d\n", bindinfo.cbstgmedData);
 933     ok(bindinfo.dwOptions == 0x80000 || bindinfo.dwOptions == 0x4080000,
 934        "bindinfo.dwOptions=%x\n", bindinfo.dwOptions);
 935     ok(bindinfo.dwOptionsFlags == 0, "bindinfo.dwOptionsFlags=%d\n", bindinfo.dwOptionsFlags);
 936     /* TODO: test dwCodePage */
 937     /* TODO: test securityAttributes */
 938     ok(IsEqualGUID(&IID_NULL, &bindinfo.iid), "unexpected bindinfo.iid\n");
 939     ok(bindinfo.pUnk == NULL, "bindinfo.pUnk=%p\n", bindinfo.pUnk);
 940     ok(bindinfo.dwReserved == 0, "bindinfo.dwReserved=%d\n", bindinfo.dwReserved);
 941
 942     hres = IBindStatusCallback_OnStartBinding(callback, 0, &Binding);
 943     ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
 944
 945     hres = IBindStatusCallback_OnProgress(callback, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE,
 946                                           wszTextHtml);
 947     ok(hres == S_OK, "OnProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
 948
 949     hres = IBindStatusCallback_OnProgress(callback, sizeof(html_page)-1, sizeof(html_page)-1,
 950                                           BINDSTATUS_BEGINDOWNLOADDATA, doc_url);
 951     ok(hres == S_OK, "OnProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
 952
 953     SET_EXPECT(Read);
 954     stgmedium.tymed = TYMED_ISTREAM;
 955     U(stgmedium).pstm = &Stream;
 956     stgmedium.pUnkForRelease = (IUnknown*)iface;
 957     hres = IBindStatusCallback_OnDataAvailable(callback,
 958             BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
 959             sizeof(html_page)-1, &formatetc, &stgmedium);
 960     ok(hres == S_OK, "OnDataAvailable failed: %08x\n", hres);
 961     CHECK_CALLED(Read);
 962
 963     hres = IBindStatusCallback_OnProgress(callback, sizeof(html_page)-1, sizeof(html_page)-1,
 964             BINDSTATUS_ENDDOWNLOADDATA, NULL);
 965     ok(hres == S_OK, "OnProgress(BINDSTATUS_ENDDOWNLOADDATA) failed: %08x\n", hres);
 966
 967     hres = IBindStatusCallback_OnStopBinding(callback, S_OK, NULL);
 968     ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
 969
 970     IBindStatusCallback_Release(callback);
 971
 972     return S_OK;
 973 }
 974
 975 static HRESULT WINAPI Moniker_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar,
 976         IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
 977 {
 978     ok(0, "unexpected call\n");
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI Moniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight,
 983         BOOL fOnlyIfNotGeneric, IMoniker **ppnkComposite)
 984 {
 985     ok(0, "unexpected call\n");
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI Moniker_Enum(IMoniker *iface, BOOL fForwrd, IEnumMoniker **ppenumMoniker)
 990 {
 991     ok(0, "unexpected call\n");
 992     return E_NOTIMPL;
 993 }
 994
 995 static HRESULT WINAPI Moniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
 996 {
 997     ok(0, "unexpected call\n");
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI Moniker_Hash(IMoniker *iface, DWORD *pdwHash)
1002 {
1003     ok(0, "unexpected call\n");
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI Moniker_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
1008         IMoniker *pmkNewlyRunning)
1009 {
1010     ok(0, "unexpected call\n");
1011     return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI Moniker_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc,
1015         IMoniker *pmkToLeft, FILETIME *pFileTime)
1016 {
1017     ok(0, "unexpected call\n");
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI Moniker_Inverse(IMoniker *iface, IMoniker **ppmk)
1022 {
1023     ok(0, "unexpected call\n");
1024     return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI Moniker_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther,
1028         IMoniker **ppmkPrefix)
1029 {
1030     ok(0, "unexpected call\n");
1031     return E_NOTIMPL;
1032 }
1033
1034 static HRESULT WINAPI Moniker_RelativePathTo(IMoniker *iface, IMoniker *pmkOther,
1035         IMoniker **pmkRelPath)
1036 {
1037     ok(0, "unexpected call\n");
1038     return E_NOTIMPL;
1039 }
1040
1041 static HRESULT WINAPI Moniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc,
1042         IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
1043 {
1044     CHECK_EXPECT2(GetDisplayName);
1045
1046     /* ok(pbc != NULL, "pbc == NULL\n"); */
1047     ok(pmkToLeft == NULL, "pmkToLeft=%p\n", pmkToLeft);
1048     ok(ppszDisplayName != NULL, "ppszDisplayName == NULL\n");
1049
1050     *ppszDisplayName = CoTaskMemAlloc(sizeof(doc_url));
1051     memcpy(*ppszDisplayName, doc_url, sizeof(doc_url));
1052
1053     return S_OK;
1054 }
1055
1056 static HRESULT WINAPI Moniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc,
1057         IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
1058 {
1059     ok(0, "unexpected call\n");
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI Moniker_IsSystemMoniker(IMoniker *iface, DWORD *pdwMksys)
1064 {
1065     CHECK_EXPECT(IsSystemMoniker);
1066     return E_NOTIMPL;
1067 }
1068
1069 static const IMonikerVtbl MonikerVtbl = {
1070     Moniker_QueryInterface,
1071     Moniker_AddRef,
1072     Moniker_Release,
1073     Moniker_GetClassID,
1074     Moniker_IsDirty,
1075     Moniker_Load,
1076     Moniker_Save,
1077     Moniker_GetSizeMax,
1078     Moniker_BindToObject,
1079     Moniker_BindToStorage,
1080     Moniker_Reduce,
1081     Moniker_ComposeWith,
1082     Moniker_Enum,
1083     Moniker_IsEqual,
1084     Moniker_Hash,
1085     Moniker_IsRunning,
1086     Moniker_GetTimeOfLastChange,
1087     Moniker_Inverse,
1088     Moniker_CommonPrefixWith,
1089     Moniker_RelativePathTo,
1090     Moniker_GetDisplayName,
1091     Moniker_ParseDisplayName,
1092     Moniker_IsSystemMoniker
1093 };
1094
1095 static IMoniker Moniker = { &MonikerVtbl };
1096
1097 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
1098 {
1099     return QueryInterface(riid, ppv);
1100 }
1101
1102 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
1103 {
1104     return 2;
1105 }
1106
1107 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
1108 {
1109     return 1;
1110 }
1111
1112 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
1113         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
1114 {
1115     ok(0, "unexpected call\n");
1116     return E_NOTIMPL;
1117 }
1118
1119 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
1120         IEnumUnknown **ppenum)
1121 {
1122     ok(0, "unexpected call\n");
1123     return E_NOTIMPL;
1124 }
1125
1126 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
1127 {
1128     CHECK_EXPECT(LockContainer);
1129     ok(expect_LockContainer_fLock == fLock, "fLock=%x, expected %x\n", fLock, expect_LockContainer_fLock);
1130     return S_OK;
1131 }
1132
1133 static const IOleContainerVtbl OleContainerVtbl = {
1134     OleContainer_QueryInterface,
1135     OleContainer_AddRef,
1136     OleContainer_Release,
1137     OleContainer_ParseDisplayName,
1138     OleContainer_EnumObjects,
1139     OleContainer_LockContainer
1140 };
1141
1142 static IOleContainer OleContainer = { &OleContainerVtbl };
1143
1144 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1145 {
1146     ok(0, "unexpected call\n");
1147     return E_NOINTERFACE;
1148 }
1149
1150 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1151 {
1152     return 2;
1153 }
1154
1155 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1156 {
1157     return 1;
1158 }
1159
1160 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1161 {
1162     ok(0, "unexpected call\n");
1163     return E_NOTIMPL;
1164 }
1165
1166 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1167 {
1168     ok(0, "unexpected call\n");
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1173 {
1174     ok(0, "unexpected call\n");
1175     return E_NOTIMPL;
1176 }
1177
1178 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1179         LPCBORDERWIDTHS pborderwidths)
1180 {
1181     ok(0, "unexpected call\n");
1182     return E_NOTIMPL;
1183 }
1184
1185 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1186         LPCBORDERWIDTHS pborderwidths)
1187 {
1188     CHECK_EXPECT(InPlaceFrame_SetBorderSpace);
1189     return S_OK;
1190 }
1191
1192 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1193         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1194 {
1195     static const WCHAR wszHTML_Document[] =
1196         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
1197
1198     CHECK_EXPECT2(InPlaceUIWindow_SetActiveObject);
1199
1200     if(expect_InPlaceUIWindow_SetActiveObject_active) {
1201         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
1202         if(pActiveObject && PRIMARYLANGID(GetSystemDefaultLangID()) == LANG_ENGLISH)
1203             ok(!lstrcmpW(wszHTML_Document, pszObjName), "pszObjName != \"HTML Document\"\n");
1204     }
1205     else {
1206         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
1207         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
1208     }
1209     expect_InPlaceUIWindow_SetActiveObject_active = !expect_InPlaceUIWindow_SetActiveObject_active;
1210     return S_OK;
1211 }
1212
1213 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1214         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1215 {
1216     static const WCHAR wszHTML_Document[] =
1217         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
1218
1219     CHECK_EXPECT2(SetActiveObject);
1220
1221     if(expect_SetActiveObject_active) {
1222         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
1223         if(pActiveObject && PRIMARYLANGID(GetSystemDefaultLangID()) == LANG_ENGLISH)
1224             ok(!lstrcmpW(wszHTML_Document, pszObjName), "pszObjName != \"HTML Document\"\n");
1225     }else {
1226         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
1227         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
1228     }
1229
1230     return S_OK;
1231 }
1232
1233 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1234         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1235 {
1236     ok(0, "unexpected call\n");
1237     return E_NOTIMPL;
1238 }
1239
1240 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1241         HOLEMENU holemenu, HWND hwndActiveObject)
1242 {
1243     ok(0, "unexpected call\n");
1244     return E_NOTIMPL;
1245 }
1246
1247 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1248 {
1249     ok(0, "unexpected call\n");
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1254 {
1255     CHECK_EXPECT2(SetStatusText);
1256     if(!expect_status_text)
1257         ok(pszStatusText == NULL, "pszStatusText=%p, expected NULL\n", pszStatusText);
1258     return S_OK;
1259 }
1260
1261 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1262 {
1263     ok(0, "unexpected call\n");
1264     return E_NOTIMPL;
1265 }
1266
1267 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1268 {
1269     ok(0, "unexpected call\n");
1270     return E_NOTIMPL;
1271 }
1272
1273 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1274     InPlaceFrame_QueryInterface,
1275     InPlaceFrame_AddRef,
1276     InPlaceFrame_Release,
1277     InPlaceFrame_GetWindow,
1278     InPlaceFrame_ContextSensitiveHelp,
1279     InPlaceFrame_GetBorder,
1280     InPlaceFrame_RequestBorderSpace,
1281     InPlaceFrame_SetBorderSpace,
1282     InPlaceFrame_SetActiveObject,
1283     InPlaceFrame_InsertMenus,
1284     InPlaceFrame_SetMenu,
1285     InPlaceFrame_RemoveMenus,
1286     InPlaceFrame_SetStatusText,
1287     InPlaceFrame_EnableModeless,
1288     InPlaceFrame_TranslateAccelerator
1289 };
1290
1291 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1292
1293 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1294     InPlaceFrame_QueryInterface,
1295     InPlaceFrame_AddRef,
1296     InPlaceFrame_Release,
1297     InPlaceFrame_GetWindow,
1298     InPlaceFrame_ContextSensitiveHelp,
1299     InPlaceFrame_GetBorder,
1300     InPlaceFrame_RequestBorderSpace,
1301     InPlaceFrame_SetBorderSpace,
1302     InPlaceUIWindow_SetActiveObject,
1303 };
1304
1305 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1306
1307 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSiteEx *iface, REFIID riid, void **ppv)
1308 {
1309     return QueryInterface(riid, ppv);
1310 }
1311
1312 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSiteEx *iface)
1313 {
1314     return 2;
1315 }
1316
1317 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSiteEx *iface)
1318 {
1319     return 1;
1320 }
1321
1322 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSiteEx *iface, HWND *phwnd)
1323 {
1324     CHECK_EXPECT(GetWindow);
1325     ok(phwnd != NULL, "phwnd = NULL\n");
1326     *phwnd = container_hwnd;
1327     return S_OK;
1328 }
1329
1330 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSiteEx *iface, BOOL fEnterMode)
1331 {
1332     ok(0, "unexpected call\n");
1333     return E_NOTIMPL;
1334 }
1335
1336 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSiteEx *iface)
1337 {
1338     CHECK_EXPECT(CanInPlaceActivate);
1339     return S_OK;
1340 }
1341
1342 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSiteEx *iface)
1343 {
1344     CHECK_EXPECT(OnInPlaceActivate);
1345     return S_OK;
1346 }
1347
1348 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSiteEx *iface)
1349 {
1350     CHECK_EXPECT(OnUIActivate);
1351     return S_OK;
1352 }
1353
1354 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSiteEx *iface,
1355         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1356         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1357 {
1358     static const RECT rect = {0,0,500,500};
1359
1360     CHECK_EXPECT(GetWindowContext);
1361
1362     ok(ppFrame != NULL, "ppFrame = NULL\n");
1363     if(ppFrame)
1364         *ppFrame = &InPlaceFrame;
1365     ok(ppDoc != NULL, "ppDoc = NULL\n");
1366     if(ppDoc)
1367         *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1368     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
1369     if(lprcPosRect)
1370         memcpy(lprcPosRect, &rect, sizeof(RECT));
1371     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
1372     if(lprcClipRect)
1373         memcpy(lprcClipRect, &rect, sizeof(RECT));
1374     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
1375     if(lpFrameInfo) {
1376         lpFrameInfo->cb = sizeof(*lpFrameInfo);
1377         lpFrameInfo->fMDIApp = FALSE;
1378         lpFrameInfo->hwndFrame = container_hwnd;
1379         lpFrameInfo->haccel = NULL;
1380         lpFrameInfo->cAccelEntries = 0;
1381     }
1382
1383     return S_OK;
1384 }
1385
1386 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSiteEx *iface, SIZE scrollExtant)
1387 {
1388     ok(0, "unexpected call\n");
1389     return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSiteEx *iface, BOOL fUndoable)
1393 {
1394     CHECK_EXPECT(OnUIDeactivate);
1395     ok(!fUndoable, "fUndoable = TRUE\n");
1396     return S_OK;
1397 }
1398
1399 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSiteEx *iface)
1400 {
1401     CHECK_EXPECT(OnInPlaceDeactivate);
1402     return S_OK;
1403 }
1404
1405 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSiteEx *iface)
1406 {
1407     ok(0, "unexpected call\n");
1408     return E_NOTIMPL;
1409 }
1410
1411 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSiteEx *iface)
1412 {
1413     ok(0, "unexpected call\n");
1414     return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSiteEx *iface, LPCRECT lprcPosRect)
1418 {
1419     ok(0, "unexpected call\n");
1420     return E_NOTIMPL;
1421 }
1422
1423 static HRESULT WINAPI InPlaceSiteEx_OnInPlaceActivateEx(IOleInPlaceSiteEx *iface, BOOL *pfNoRedraw, DWORD dwFlags)
1424 {
1425     CHECK_EXPECT(OnInPlaceActivateEx);
1426
1427     ok(pfNoRedraw != NULL, "pfNoRedraw == NULL\n");
1428     ok(!*pfNoRedraw, "*pfNoRedraw == TRUE\n");
1429     ok(dwFlags == 0, "dwFlags = %08x\n", dwFlags);
1430
1431     return S_OK;
1432 }
1433
1434 static HRESULT WINAPI InPlaceSiteEx_OnInPlaceDeactivateEx(IOleInPlaceSiteEx *iface, BOOL fNoRedraw)
1435 {
1436     CHECK_EXPECT(OnInPlaceDeactivateEx);
1437
1438     ok(fNoRedraw, "fNoRedraw == FALSE\n");
1439
1440     return S_OK;
1441 }
1442
1443 static HRESULT WINAPI InPlaceSiteEx_RequestUIActivate(IOleInPlaceSiteEx *iface)
1444 {
1445     CHECK_EXPECT(RequestUIActivate);
1446     return S_OK;
1447 }
1448
1449 static const IOleInPlaceSiteExVtbl InPlaceSiteVtbl = {
1450     InPlaceSite_QueryInterface,
1451     InPlaceSite_AddRef,
1452     InPlaceSite_Release,
1453     InPlaceSite_GetWindow,
1454     InPlaceSite_ContextSensitiveHelp,
1455     InPlaceSite_CanInPlaceActivate,
1456     InPlaceSite_OnInPlaceActivate,
1457     InPlaceSite_OnUIActivate,
1458     InPlaceSite_GetWindowContext,
1459     InPlaceSite_Scroll,
1460     InPlaceSite_OnUIDeactivate,
1461     InPlaceSite_OnInPlaceDeactivate,
1462     InPlaceSite_DiscardUndoState,
1463     InPlaceSite_DeactivateAndUndo,
1464     InPlaceSite_OnPosRectChange,
1465     InPlaceSiteEx_OnInPlaceActivateEx,
1466     InPlaceSiteEx_OnInPlaceDeactivateEx,
1467     InPlaceSiteEx_RequestUIActivate
1468 };
1469
1470 static IOleInPlaceSiteEx InPlaceSiteEx = { &InPlaceSiteVtbl };
1471
1472 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1473 {
1474     return QueryInterface(riid, ppv);
1475 }
1476
1477 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1478 {
1479     return 2;
1480 }
1481
1482 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1483 {
1484     return 1;
1485 }
1486
1487 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1488 {
1489     ok(0, "unexpected call\n");
1490     return E_NOTIMPL;
1491 }
1492
1493 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAsign, DWORD dwWhichMoniker,
1494         IMoniker **ppmon)
1495 {
1496     ok(0, "unexpected call\n");
1497     return E_NOTIMPL;
1498 }
1499
1500 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1501 {
1502     CHECK_EXPECT(GetContainer);
1503     ok(ppContainer != NULL, "ppContainer = NULL\n");
1504     *ppContainer = &OleContainer;
1505     return S_OK;
1506 }
1507
1508 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1509 {
1510     ok(0, "unexpected call\n");
1511     return E_NOTIMPL;
1512 }
1513
1514 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1515 {
1516     ok(0, "unexpected call\n");
1517     return E_NOTIMPL;
1518 }
1519
1520 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1521 {
1522     ok(0, "unexpected call\n");
1523     return E_NOTIMPL;
1524 }
1525
1526 static const IOleClientSiteVtbl ClientSiteVtbl = {
1527     ClientSite_QueryInterface,
1528     ClientSite_AddRef,
1529     ClientSite_Release,
1530     ClientSite_SaveObject,
1531     ClientSite_GetMoniker,
1532     ClientSite_GetContainer,
1533     ClientSite_ShowObject,
1534     ClientSite_OnShowWindow,
1535     ClientSite_RequestNewObjectLayout
1536 };
1537
1538 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1539
1540 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1541 {
1542     return QueryInterface(riid, ppv);
1543 }
1544
1545 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1546 {
1547     return 2;
1548 }
1549
1550 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1551 {
1552     return 1;
1553 }
1554
1555 typedef enum
1556 {
1557     CallUIActivate_None,
1558     CallUIActivate_ActivateMe,
1559     CallUIActivate_AfterShow,
1560 } CallUIActivate;
1561
1562 static BOOL call_UIActivate = CallUIActivate_ActivateMe;
1563 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1564 {
1565     IOleDocument *document;
1566     HRESULT hres;
1567
1568     CHECK_EXPECT(ActivateMe);
1569     ok(pViewToActivate != NULL, "pViewToActivate = NULL\n");
1570
1571     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1572     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1573
1574     if(SUCCEEDED(hres)) {
1575         hres = IOleDocument_CreateView(document, (IOleInPlaceSite*)&InPlaceSiteEx, NULL, 0, &view);
1576         ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1577
1578         if(SUCCEEDED(hres)) {
1579             IOleInPlaceActiveObject *activeobj = NULL;
1580             IOleInPlaceSite *inplacesite = NULL;
1581             HWND tmp_hwnd = NULL;
1582             static RECT rect = {0,0,400,500};
1583
1584             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1585             ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
1586             ok(inplacesite == (IOleInPlaceSite*)&InPlaceSiteEx, "inplacesite=%p, expected %p\n",
1587                     inplacesite, &InPlaceSiteEx);
1588
1589             hres = IOleDocumentView_SetInPlaceSite(view, (IOleInPlaceSite*)&InPlaceSiteEx);
1590             ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1591
1592             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1593             ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
1594             ok(inplacesite == (IOleInPlaceSite*)&InPlaceSiteEx, "inplacesite=%p, expected %p\n",
1595                     inplacesite, &InPlaceSiteEx);
1596
1597             hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobj);
1598             ok(hres == S_OK, "Could not get IOleInPlaceActiveObject: %08x\n", hres);
1599
1600             if(activeobj) {
1601                 IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
1602                 ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1603                 ok(hwnd == NULL, "hwnd=%p, expeted NULL\n", hwnd);
1604             }
1605
1606             if(call_UIActivate == CallUIActivate_ActivateMe) {
1607                 SET_EXPECT(CanInPlaceActivate);
1608                 SET_EXPECT(GetWindowContext);
1609                 SET_EXPECT(GetWindow);
1610                 if(ipsex)
1611                     SET_EXPECT(OnInPlaceActivateEx);
1612                 else
1613                     SET_EXPECT(OnInPlaceActivate);
1614                 SET_EXPECT(SetStatusText);
1615                 SET_EXPECT(Exec_SETPROGRESSMAX);
1616                 SET_EXPECT(Exec_SETPROGRESSPOS);
1617                 SET_EXPECT(OnUIActivate);
1618                 SET_EXPECT(SetActiveObject);
1619                 SET_EXPECT(ShowUI);
1620                 expect_SetActiveObject_active = TRUE;
1621                 expect_status_text = NULL;
1622
1623                 hres = IOleDocumentView_UIActivate(view, TRUE);
1624
1625                 if(FAILED(hres)) {
1626                     trace("UIActivate failed: %08x\n", hres);
1627                     return hres;
1628                 }
1629                 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1630
1631                 CHECK_CALLED(CanInPlaceActivate);
1632                 CHECK_CALLED(GetWindowContext);
1633                 CHECK_CALLED(GetWindow);
1634                 if(ipsex)
1635                     CHECK_CALLED(OnInPlaceActivateEx);
1636                 else
1637                     CHECK_CALLED(OnInPlaceActivate);
1638                 CHECK_CALLED(SetStatusText);
1639                 CHECK_CALLED(Exec_SETPROGRESSMAX);
1640                 CHECK_CALLED(Exec_SETPROGRESSPOS);
1641                 CHECK_CALLED(OnUIActivate);
1642                 CHECK_CALLED(SetActiveObject);
1643                 CHECK_CALLED(ShowUI);
1644
1645                 if(activeobj) {
1646                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
1647                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1648                     ok(hwnd != NULL, "hwnd == NULL\n");
1649                     if(last_hwnd)
1650                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
1651                 }
1652
1653                 hres = IOleDocumentView_UIActivate(view, TRUE);
1654                 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1655
1656                 if(activeobj) {
1657                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &tmp_hwnd);
1658                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1659                     ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
1660                 }
1661             }
1662
1663             hres = IOleDocumentView_SetRect(view, &rect);
1664             ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1665
1666             if(call_UIActivate == CallUIActivate_ActivateMe) {
1667                 hres = IOleDocumentView_Show(view, TRUE);
1668                 ok(hres == S_OK, "Show failed: %08x\n", hres);
1669             }else {
1670                 SET_EXPECT(CanInPlaceActivate);
1671                 SET_EXPECT(GetWindowContext);
1672                 SET_EXPECT(GetWindow);
1673                 if(ipsex)
1674                     SET_EXPECT(OnInPlaceActivateEx);
1675                 else
1676                     SET_EXPECT(OnInPlaceActivate);
1677                 SET_EXPECT(SetStatusText);
1678                 SET_EXPECT(Exec_SETPROGRESSMAX);
1679                 SET_EXPECT(Exec_SETPROGRESSPOS);
1680                 SET_EXPECT(OnUIActivate);
1681                 expect_status_text = (load_state == LD_COMPLETE ? (LPCOLESTR)0xdeadbeef : NULL);
1682
1683                 hres = IOleDocumentView_Show(view, TRUE);
1684                 ok(hres == S_OK, "Show failed: %08x\n", hres);
1685
1686                 CHECK_CALLED(CanInPlaceActivate);
1687                 CHECK_CALLED(GetWindowContext);
1688                 CHECK_CALLED(GetWindow);
1689                 if(ipsex)
1690                     CHECK_CALLED(OnInPlaceActivateEx);
1691                 else
1692                     CHECK_CALLED(OnInPlaceActivate);
1693                 CHECK_CALLED(SetStatusText);
1694                 CHECK_CALLED(Exec_SETPROGRESSMAX);
1695                 CHECK_CALLED(Exec_SETPROGRESSPOS);
1696
1697                 if(activeobj) {
1698                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
1699                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1700                     ok(hwnd != NULL, "hwnd == NULL\n");
1701                     if(last_hwnd)
1702                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
1703                 }
1704             }
1705
1706             test_timer(EXPECT_UPDATEUI | ((load_state == LD_LOADING) ? EXPECT_SETTITLE : 0));
1707
1708             if(activeobj)
1709                 IOleInPlaceActiveObject_Release(activeobj);
1710         }
1711
1712         IOleDocument_Release(document);
1713     }
1714
1715     return S_OK;
1716 }
1717
1718 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1719     DocumentSite_QueryInterface,
1720     DocumentSite_AddRef,
1721     DocumentSite_Release,
1722     DocumentSite_ActivateMe
1723 };
1724
1725 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1726
1727 static HRESULT WINAPI OleControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv)
1728 {
1729     return QueryInterface(riid, ppv);
1730 }
1731
1732 static ULONG WINAPI OleControlSite_AddRef(IOleControlSite *iface)
1733 {
1734     return 2;
1735 }
1736
1737 static ULONG WINAPI OleControlSite_Release(IOleControlSite *iface)
1738 {
1739     return 1;
1740 }
1741
1742 static HRESULT WINAPI OleControlSite_OnControlInfoChanged(IOleControlSite *iface)
1743 {
1744     ok(0, "unexpected call\n");
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT WINAPI OleControlSite_LockInPlaceActive(IOleControlSite *iface, BOOL fLock)
1749 {
1750     ok(0, "unexpected call\n");
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT WINAPI OleControlSite_GetExtendedControl(IOleControlSite *iface, IDispatch **ppDisp)
1755 {
1756     ok(0, "unexpected call\n");
1757     return E_NOTIMPL;
1758 }
1759
1760 static HRESULT WINAPI OleControlSite_TransformCoords(IOleControlSite *iface, POINTL *pPtHimetric,
1761         POINTF *pPtfContainer, DWORD dwFlags)
1762 {
1763     ok(0, "unexpected call\n");
1764     return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI OleControlSite_TranslateAccelerator(IOleControlSite *iface,
1768         MSG *pMsg, DWORD grfModifiers)
1769 {
1770     ok(0, "unexpected call\n");
1771     return E_NOTIMPL;
1772 }
1773
1774 static HRESULT WINAPI OleControlSite_OnFocus(IOleControlSite *iface, BOOL fGotFocus)
1775 {
1776     if(fGotFocus)
1777         CHECK_EXPECT(OnFocus_TRUE);
1778     else
1779         CHECK_EXPECT2(OnFocus_FALSE);
1780     return S_OK;
1781 }
1782
1783 static HRESULT WINAPI OleControlSite_ShowPropertyFrame(IOleControlSite *iface)
1784 {
1785     ok(0, "unexpected call\n");
1786     return E_NOTIMPL;
1787 }
1788
1789 static const IOleControlSiteVtbl OleControlSiteVtbl = {
1790     OleControlSite_QueryInterface,
1791     OleControlSite_AddRef,
1792     OleControlSite_Release,
1793     OleControlSite_OnControlInfoChanged,
1794     OleControlSite_LockInPlaceActive,
1795     OleControlSite_GetExtendedControl,
1796     OleControlSite_TransformCoords,
1797     OleControlSite_TranslateAccelerator,
1798     OleControlSite_OnFocus,
1799     OleControlSite_ShowPropertyFrame
1800 };
1801
1802 static IOleControlSite OleControlSite = { &OleControlSiteVtbl };
1803
1804 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
1805 {
1806     return QueryInterface(riid, ppv);
1807 }
1808
1809 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
1810 {
1811     return 2;
1812 }
1813
1814 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
1815 {
1816     return 1;
1817 }
1818
1819 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
1820         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
1821 {
1822     ok(0, "unexpected call\n");
1823     return E_NOTIMPL;
1824 }
1825
1826 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
1827 {
1828     CHECK_EXPECT(GetHostInfo);
1829     ok(pInfo != NULL, "pInfo=NULL\n");
1830     if(pInfo) {
1831         ok(pInfo->cbSize == sizeof(DOCHOSTUIINFO), "pInfo->cbSize=%u\n", pInfo->cbSize);
1832         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08x, expected 0\n", pInfo->dwFlags);
1833         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
1834             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
1835             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
1836         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08x, expected 0\n", pInfo->dwDoubleClick);
1837         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
1838         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
1839     }
1840     return S_OK;
1841 }
1842
1843 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
1844         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
1845         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
1846 {
1847     CHECK_EXPECT(ShowUI);
1848
1849     if (editmode)
1850         ok(dwID == DOCHOSTUITYPE_AUTHOR, "dwID=%d, expected DOCHOSTUITYPE_AUTHOR\n", dwID);
1851     else
1852         ok(dwID == DOCHOSTUITYPE_BROWSE, "dwID=%d, expected DOCHOSTUITYPE_BROWSE\n", dwID);
1853     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
1854     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
1855     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
1856     if (expect_InPlaceUIWindow_SetActiveObject_active)
1857         ok(pDoc == (IOleInPlaceUIWindow *)&InPlaceUIWindow, "pDoc=%p, expected %p\n", pDoc, &InPlaceUIWindow);
1858     else
1859         ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
1860
1861     return S_OK;
1862 }
1863
1864 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
1865 {
1866     CHECK_EXPECT(HideUI);
1867     return S_OK;
1868 }
1869
1870 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
1871 {
1872     CHECK_EXPECT(UpdateUI);
1873     return S_OK;
1874 }
1875
1876 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
1877 {
1878     ok(0, "unexpected call\n");
1879     return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
1883 {
1884     ok(0, "unexpected call\n");
1885     return E_NOTIMPL;
1886 }
1887
1888 static BOOL expect_OnFrameWindowActivate_fActivate;
1889 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
1890 {
1891     CHECK_EXPECT2(OnFrameWindowActivate);
1892     ok(fActivate == expect_OnFrameWindowActivate_fActivate, "fActivate=%x\n", fActivate);
1893     return S_OK;
1894 }
1895
1896 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
1897         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
1898 {
1899     ok(0, "unexpected call\n");
1900     return E_NOTIMPL;
1901 }
1902
1903 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
1904         const GUID *pguidCmdGroup, DWORD nCmdID)
1905 {
1906     ok(0, "unexpected call\n");
1907     return E_NOTIMPL;
1908 }
1909
1910 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
1911         LPOLESTR *pchKey, DWORD dw)
1912 {
1913     CHECK_EXPECT(GetOptionKeyPath);
1914     ok(pchKey != NULL, "pchKey = NULL\n");
1915     ok(!dw, "dw=%d, expected 0\n", dw);
1916     if(pchKey)
1917         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
1918     return S_OK;
1919 }
1920
1921 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
1922         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
1923 {
1924     CHECK_EXPECT(GetDropTarget);
1925     /* TODO */
1926     return E_NOTIMPL;
1927 }
1928
1929 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
1930 {
1931     CHECK_EXPECT(GetExternal);
1932     *ppDispatch = &External;
1933     return S_FALSE;
1934 }
1935
1936 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
1937         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
1938 {
1939     ok(0, "unexpected call\n");
1940     return E_NOTIMPL;
1941 }
1942
1943 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
1944         IDataObject **ppPORet)
1945 {
1946     ok(0, "unexpected call\n");
1947     return E_NOTIMPL;
1948 }
1949
1950 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
1951         LPOLESTR *pchKey, DWORD dw)
1952 {
1953     CHECK_EXPECT(GetOverrideKeyPath);
1954     ok(pchKey != NULL, "pchKey = NULL\n");
1955     if(pchKey)
1956         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
1957     ok(!dw, "dw=%d, xepected 0\n", dw);
1958     return S_OK;
1959 }
1960
1961 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
1962     DocHostUIHandler_QueryInterface,
1963     DocHostUIHandler_AddRef,
1964     DocHostUIHandler_Release,
1965     DocHostUIHandler_ShowContextMenu,
1966     DocHostUIHandler_GetHostInfo,
1967     DocHostUIHandler_ShowUI,
1968     DocHostUIHandler_HideUI,
1969     DocHostUIHandler_UpdateUI,
1970     DocHostUIHandler_EnableModeless,
1971     DocHostUIHandler_OnDocWindowActivate,
1972     DocHostUIHandler_OnFrameWindowActivate,
1973     DocHostUIHandler_ResizeBorder,
1974     DocHostUIHandler_TranslateAccelerator,
1975     DocHostUIHandler_GetOptionKeyPath,
1976     DocHostUIHandler_GetDropTarget,
1977     DocHostUIHandler_GetExternal,
1978     DocHostUIHandler_TranslateUrl,
1979     DocHostUIHandler_FilterDataObject,
1980     DocHostUIHandler_GetOverrideKeyPath
1981 };
1982
1983 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
1984
1985 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
1986         REFIID riid, void **ppv)
1987 {
1988     return QueryInterface(riid, ppv);
1989 }
1990
1991 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
1992 {
1993     return 2;
1994 }
1995
1996 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
1997 {
1998     return 1;
1999 }
2000
2001 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
2002         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
2003 {
2004     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
2005     ok(cCmds == 1, "cCmds=%d, expected 1\n", cCmds);
2006     ok(!pCmdText, "pCmdText != NULL\n");
2007
2008     switch(prgCmds[0].cmdID) {
2009     case OLECMDID_SETPROGRESSTEXT:
2010         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
2011         prgCmds[0].cmdf = OLECMDF_ENABLED;
2012         return S_OK;
2013     case OLECMDID_OPEN:
2014         CHECK_EXPECT(QueryStatus_OPEN);
2015         prgCmds[0].cmdf = 0;
2016         return S_OK;
2017     case OLECMDID_NEW:
2018         CHECK_EXPECT(QueryStatus_NEW);
2019         prgCmds[0].cmdf = 0;
2020         return S_OK;
2021     default:
2022         ok(0, "unexpected command %d\n", prgCmds[0].cmdID);
2023     };
2024
2025     return E_FAIL;
2026 }
2027
2028 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
2029         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
2030 {
2031     test_readyState(NULL);
2032
2033     if(!pguidCmdGroup) {
2034         switch(nCmdID) {
2035         case OLECMDID_SETPROGRESSMAX:
2036             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
2037             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2038             ok(pvaIn != NULL, "pvaIn == NULL\n");
2039             if(pvaIn) {
2040                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2041                 if(load_state == LD_NO)
2042                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2043             }
2044             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2045             return S_OK;
2046         case OLECMDID_SETPROGRESSPOS:
2047             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
2048             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2049             ok(pvaIn != NULL, "pvaIn == NULL\n");
2050             if(pvaIn) {
2051                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2052                 if(load_state == LD_NO)
2053                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2054             }
2055             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2056             return S_OK;
2057         case OLECMDID_HTTPEQUIV_DONE:
2058             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
2059             ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2060             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2061             ok(pvaIn == NULL, "pvaIn=%p\n", pvaIn);
2062             load_state = LD_COMPLETE;
2063             return S_OK;
2064         case OLECMDID_SETDOWNLOADSTATE:
2065             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2066             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2067             ok(pvaIn != NULL, "pvaIn == NULL\n");
2068             ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d\n", V_VT(pvaIn));
2069
2070             switch(V_I4(pvaIn)) {
2071             case 0:
2072                 CHECK_EXPECT(Exec_SETDOWNLOADSTATE_0);
2073                 load_state = LD_INTERACTIVE;
2074                 break;
2075             case 1:
2076                 CHECK_EXPECT(Exec_SETDOWNLOADSTATE_1);
2077                 break;
2078             default:
2079                 ok(0, "unexpevted V_I4(pvaIn)=%d\n", V_I4(pvaIn));
2080             }
2081
2082             return S_OK;
2083         case OLECMDID_UPDATECOMMANDS:
2084             CHECK_EXPECT(Exec_UPDATECOMMANDS);
2085             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2086             ok(pvaIn == NULL, "pvaIn=%p\n", pvaIn);
2087             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2088             return S_OK;
2089         case OLECMDID_SETTITLE:
2090             CHECK_EXPECT2(Exec_SETTITLE);
2091             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2092             ok(pvaIn != NULL, "pvaIn == NULL\n");
2093             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2094             ok(V_VT(pvaIn) == VT_BSTR, "V_VT(pvaIn)=%d\n", V_VT(pvaIn));
2095             ok(V_BSTR(pvaIn) != NULL, "V_BSTR(pvaIn) == NULL\n"); /* TODO */
2096             return S_OK;
2097         case OLECMDID_HTTPEQUIV:
2098             CHECK_EXPECT2(Exec_HTTPEQUIV);
2099             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2100             /* TODO */
2101             return S_OK;
2102         default:
2103             ok(0, "unexpected command %d\n", nCmdID);
2104             return E_FAIL;
2105         };
2106     }
2107
2108     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
2109         ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2110
2111         switch(nCmdID) {
2112         case 37:
2113             CHECK_EXPECT2(Exec_ShellDocView_37);
2114
2115             if(load_from_stream)
2116                 test_GetCurMoniker(doc_unk, NULL, about_blank_url);
2117             else if(!editmode)
2118                 test_GetCurMoniker(doc_unk, &Moniker, NULL);
2119
2120             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2121             ok(pvaIn != NULL, "pvaIn == NULL\n");
2122             if(pvaIn) {
2123                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2124                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2125             }
2126             return S_OK;
2127         default:
2128             ok(0, "unexpected command %d\n", nCmdID);
2129             return E_FAIL;
2130         };
2131     }
2132
2133     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
2134         ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2135
2136         switch(nCmdID) {
2137         case IDM_PARSECOMPLETE:
2138             CHECK_EXPECT(Exec_MSHTML_PARSECOMPLETE);
2139             ok(pvaIn == NULL, "pvaIn != NULL\n");
2140             ok(pvaOut == NULL, "pvaOut != NULL\n");
2141             return S_OK;
2142         default:
2143             ok(0, "unexpected command %d\n", nCmdID);
2144         };
2145     }
2146
2147     if(IsEqualGUID(&CGID_DocHostCmdPriv, pguidCmdGroup))
2148         return E_FAIL; /* TODO */
2149
2150     ok(0, "unexpected pguidCmdGroup: %s\n", debugstr_guid(pguidCmdGroup));
2151     return E_NOTIMPL;
2152 }
2153
2154 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
2155     OleCommandTarget_QueryInterface,
2156     OleCommandTarget_AddRef,
2157     OleCommandTarget_Release,
2158     OleCommandTarget_QueryStatus,
2159     OleCommandTarget_Exec
2160 };
2161
2162 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
2163
2164 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
2165 {
2166     return QueryInterface(riid, ppv);
2167 }
2168
2169 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
2170         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2171         EXCEPINFO *pExcepInfo, UINT *puArgErr)
2172 {
2173     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
2174     ok(pDispParams != NULL, "pDispParams == NULL\n");
2175     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
2176     ok(puArgErr != NULL, "puArgErr == NULL\n");
2177     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
2178     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
2179     test_readyState(NULL);
2180
2181     switch(dispIdMember) {
2182     case DISPID_AMBIENT_USERMODE:
2183         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
2184         V_VT(pVarResult) = VT_BOOL;
2185         V_BOOL(pVarResult) = VARIANT_TRUE;
2186         return S_OK;
2187     case DISPID_AMBIENT_DLCONTROL:
2188         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
2189         return E_FAIL;
2190     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
2191         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2192         return E_FAIL;
2193     case DISPID_AMBIENT_SILENT:
2194         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
2195         V_VT(pVarResult) = VT_BOOL;
2196         V_BOOL(pVarResult) = VARIANT_FALSE;
2197         return S_OK;
2198     case DISPID_AMBIENT_USERAGENT:
2199         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
2200         return E_FAIL;
2201     case DISPID_AMBIENT_PALETTE:
2202         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
2203         return E_FAIL;
2204     };
2205
2206     ok(0, "unexpected dispid %d\n", dispIdMember);
2207     return E_FAIL;
2208 }
2209
2210 static IDispatchVtbl DispatchVtbl = {
2211     Dispatch_QueryInterface,
2212     Dispatch_AddRef,
2213     Dispatch_Release,
2214     Dispatch_GetTypeInfoCount,
2215     Dispatch_GetTypeInfo,
2216     Dispatch_GetIDsOfNames,
2217     Dispatch_Invoke
2218 };
2219
2220 static IDispatch Dispatch = { &DispatchVtbl };
2221
2222 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
2223                                                      REFIID riid, void **ppv)
2224 {
2225     return QueryInterface(riid, ppv);
2226 }
2227
2228 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
2229 {
2230     return 2;
2231 }
2232
2233 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
2234 {
2235     return 1;
2236 }
2237
2238 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
2239                                     REFIID riid, void **ppv)
2240 {
2241     /*
2242      * Services used by HTMLDocument:
2243      *
2244      * IOleUndoManager
2245      * IInternetSecurityManager
2246      * ITargetFrame
2247      * {D5F78C80-5252-11CF-90FA-00AA0042106E}
2248      * HTMLFrameBase
2249      * IShellObject
2250      * {3050F312-98B5-11CF-BB82-00AA00BDCE0B}
2251      * {53A2D5B1-D2FC-11D0-84E0-006097C9987D}
2252      * {AD7F6C62-F6BD-11D2-959B-006097C553C8}
2253      * DefView (?)
2254      * {6D12FE80-7911-11CF-9534-0000C05BAE0B}
2255      * IElementBehaviorFactory
2256      * {3050F429-98B5-11CF-BB82-00AA00BDCE0B}
2257      * STopLevelBrowser
2258      * IHTMLWindow2
2259      * IInternetProtocol
2260      * IWebBrowserApp
2261      * UrlHostory
2262      * IHTMLEditHost
2263      * IHlinkFrame
2264      */
2265
2266     if(IsEqualGUID(&IID_IHlinkFrame, guidService)) {
2267         ok(IsEqualGUID(&IID_IHlinkFrame, riid), "unexpected riid\n");
2268         *ppv = &HlinkFrame;
2269         return S_OK;
2270     }
2271
2272     return E_NOINTERFACE;
2273 }
2274
2275 static const IServiceProviderVtbl ServiceProviderVtbl = {
2276     ServiceProvider_QueryInterface,
2277     ServiceProvider_AddRef,
2278     ServiceProvider_Release,
2279     ServiceProvider_QueryService
2280 };
2281
2282 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
2283
2284 DEFINE_GUID(IID_unk1, 0xD48A6EC6,0x6A4A,0x11CF,0x94,0xA7,0x44,0x45,0x53,0x54,0x00,0x00); /* HTMLWindow2 ? */
2285 DEFINE_GUID(IID_unk2, 0x7BB0B520,0xB1A7,0x11D2,0xBB,0x23,0x00,0xC0,0x4F,0x79,0xAB,0xCD);
2286 DEFINE_GUID(IID_unk3, 0x000670BA,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
2287
2288 static HRESULT QueryInterface(REFIID riid, void **ppv)
2289 {
2290     *ppv = NULL;
2291
2292     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2293         *ppv = &ClientSite;
2294     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2295         *ppv = &DocumentSite;
2296     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
2297         *ppv = &DocHostUIHandler;
2298     else if(IsEqualGUID(&IID_IOleContainer, riid))
2299         *ppv = &OleContainer;
2300     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2301         *ppv = &InPlaceSiteEx;
2302     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
2303         *ppv = &OleCommandTarget;
2304     else if(IsEqualGUID(&IID_IDispatch, riid))
2305         *ppv = &Dispatch;
2306     else if(IsEqualGUID(&IID_IServiceProvider, riid))
2307         *ppv = &ServiceProvider;
2308     else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid))
2309         *ppv = ipsex ? &InPlaceSiteEx : NULL;
2310     else if(IsEqualGUID(&IID_IOleControlSite, riid))
2311         *ppv = &OleControlSite;
2312     else if(IsEqualGUID(&IID_IDocHostShowUI, riid))
2313         return E_NOINTERFACE; /* TODO */
2314     else if(IsEqualGUID(&IID_IProxyManager, riid))
2315         return E_NOINTERFACE; /* ? */
2316     else if(IsEqualGUID(&IID_unk1, riid))
2317         return E_NOINTERFACE; /* HTMLWindow2 ? */
2318     else if(IsEqualGUID(&IID_unk2, riid))
2319         return E_NOINTERFACE; /* ? */
2320     else if(IsEqualGUID(&IID_unk3, riid))
2321         return E_NOINTERFACE; /* ? */
2322     else
2323         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
2324
2325     if(*ppv)
2326         return S_OK;
2327     return E_NOINTERFACE;
2328 }
2329
2330 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2331 {
2332     return DefWindowProc(hwnd, msg, wParam, lParam);
2333 }
2334
2335 static void test_readyState(IUnknown *unk)
2336 {
2337     IHTMLDocument2 *htmldoc;
2338     BSTR state;
2339     HRESULT hres;
2340
2341     static const WCHAR wszUninitialized[] = {'u','n','i','n','i','t','i','a','l','i','z','e','d',0};
2342     static const WCHAR wszLoading[] = {'l','o','a','d','i','n','g',0};
2343     static const WCHAR wszInteractive[] = {'i','n','t','e','r','a','c','t','i','v','e',0};
2344     static const WCHAR wszComplete[] = {'c','o','m','p','l','e','t','e',0};
2345
2346     static const LPCWSTR expected_state[] = {
2347         wszUninitialized,
2348         wszLoading,
2349         wszInteractive,
2350         wszComplete,
2351         wszUninitialized
2352     };
2353
2354     if(!unk)
2355         unk = doc_unk;
2356
2357     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&htmldoc);
2358     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
2359     if(FAILED(hres))
2360         return;
2361
2362     hres = IHTMLDocument2_get_readyState(htmldoc, NULL);
2363     ok(hres == E_POINTER, "get_readyState failed: %08x, expected\n", hres);
2364
2365     hres = IHTMLDocument2_get_readyState(htmldoc, &state);
2366     ok(hres == S_OK, "get_ReadyState failed: %08x\n", hres);
2367     ok(!lstrcmpW(state, expected_state[load_state]), "unexpected state, expected %d\n", load_state);
2368
2369     IHTMLDocument_Release(htmldoc);
2370 }
2371
2372 static void test_ConnectionPoint(IConnectionPointContainer *container, REFIID riid)
2373 {
2374     IConnectionPointContainer *tmp_container = NULL;
2375     IConnectionPoint *cp;
2376     IID iid;
2377     HRESULT hres;
2378
2379     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2380     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2381     if(FAILED(hres))
2382         return;
2383
2384     hres = IConnectionPoint_GetConnectionInterface(cp, &iid);
2385     ok(hres == S_OK, "GetConnectionInterface failed: %08x\n", hres);
2386     ok(IsEqualGUID(riid, &iid), "wrong iid\n");
2387
2388     hres = IConnectionPoint_GetConnectionInterface(cp, NULL);
2389     ok(hres == E_POINTER, "GetConnectionInterface failed: %08x, expected E_POINTER\n", hres);
2390
2391     hres = IConnectionPoint_GetConnectionPointContainer(cp, &tmp_container);
2392     ok(hres == S_OK, "GetConnectionPointContainer failed: %08x\n", hres);
2393     ok(tmp_container == container, "container != tmp_container\n");
2394     if(SUCCEEDED(hres))
2395         IConnectionPointContainer_Release(tmp_container);
2396
2397     hres = IConnectionPoint_GetConnectionPointContainer(cp, NULL);
2398     ok(hres == E_POINTER, "GetConnectionPointContainer failed: %08x, expected E_POINTER\n", hres);
2399
2400     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2401         DWORD cookie;
2402
2403         hres = IConnectionPoint_Advise(cp, (IUnknown*)&PropertyNotifySink, &cookie);
2404         ok(hres == S_OK, "Advise failed: %08x\n", hres);
2405     }
2406
2407     IConnectionPoint_Release(cp);
2408 }
2409
2410 static void test_ConnectionPointContainer(IUnknown *unk)
2411 {
2412     IConnectionPointContainer *container;
2413     HRESULT hres;
2414
2415     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2416     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2417     if(FAILED(hres))
2418         return;
2419
2420     test_ConnectionPoint(container, &IID_IPropertyNotifySink);
2421     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents);
2422     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents2);
2423
2424     IConnectionPointContainer_Release(container);
2425 }
2426
2427 static void test_GetCurMoniker(IUnknown *unk, IMoniker *exmon, LPCWSTR exurl)
2428 {
2429     IHTMLDocument2 *doc;
2430     IPersistMoniker *permon;
2431     IMoniker *mon = (void*)0xdeadbeef;
2432     BSTR doc_url = (void*)0xdeadbeef;
2433     HRESULT hres;
2434
2435     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&permon);
2436     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08x\n", hres);
2437     if(FAILED(hres))
2438         return;
2439
2440     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&doc);
2441     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
2442
2443     hres = IHTMLDocument2_get_URL(doc, &doc_url);
2444     ok(hres == S_OK, "get_URL failed: %08x\n", hres);
2445
2446     hres = IPersistMoniker_GetCurMoniker(permon, &mon);
2447     IPersistMoniker_Release(permon);
2448
2449     if(exmon) {
2450         BSTR url;
2451         BOOL exb = expect_GetDisplayName;
2452         BOOL clb = called_GetDisplayName;
2453
2454         ok(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
2455         ok(mon == exmon, "mon(%p) != exmon(%p)\n", mon, exmon);
2456
2457         SET_EXPECT(GetDisplayName);
2458         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
2459         ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
2460         CHECK_CALLED(GetDisplayName);
2461         expect_GetDisplayName = exb;
2462         called_GetDisplayName = clb;
2463
2464         SysFreeString(url);
2465         ok(!lstrcmpW(url, doc_url), "url != doc_url\n");
2466     }else if(exurl) {
2467         BSTR url;
2468
2469         ok(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
2470
2471         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
2472         ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
2473
2474         ok(!lstrcmpW(url, exurl), "unexpected url\n");
2475         ok(!lstrcmpW(url, doc_url), "url != doc_url\n");
2476
2477         SysFreeString(url);
2478     }else {
2479         ok(hres == E_UNEXPECTED,
2480            "GetCurrentMoniker failed: %08x, expected E_UNEXPECTED\n", hres);
2481         ok(mon == (IMoniker*)0xdeadbeef, "mon=%p\n", mon);
2482         ok(!lstrcmpW(doc_url, about_blank_url), "doc_url is not about:blank\n");
2483     }
2484
2485     SysFreeString(doc_url);
2486     IHTMLDocument_Release(doc);
2487     if(mon && mon != (void*)0xdeadbeef)
2488         IMoniker_Release(mon);
2489 }
2490
2491 static void test_Load(IPersistMoniker *persist)
2492 {
2493     IBindCtx *bind;
2494     HRESULT hres;
2495     WCHAR sz_html_clientsite_objectparam[MAX_PATH];
2496
2497     lstrcpyW(sz_html_clientsite_objectparam, SZ_HTML_CLIENTSITE_OBJECTPARAM);
2498
2499     test_readyState((IUnknown*)persist);
2500
2501     CreateBindCtx(0, &bind);
2502     IBindCtx_RegisterObjectParam(bind, sz_html_clientsite_objectparam,
2503                                  (IUnknown*)&ClientSite);
2504
2505     SET_EXPECT(GetDisplayName);
2506     if(!set_clientsite) {
2507         SET_EXPECT(Invoke_AMBIENT_USERMODE);
2508         SET_EXPECT(GetHostInfo);
2509         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
2510         SET_EXPECT(Invoke_AMBIENT_SILENT);
2511         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2512         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
2513         SET_EXPECT(Invoke_AMBIENT_PALETTE);
2514         SET_EXPECT(GetOptionKeyPath);
2515         SET_EXPECT(GetOverrideKeyPath);
2516         SET_EXPECT(GetWindow);
2517         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
2518         SET_EXPECT(Exec_SETPROGRESSMAX);
2519         SET_EXPECT(Exec_SETPROGRESSPOS);
2520         SET_EXPECT(Exec_ShellDocView_37);
2521     }
2522     if(!container_locked) {
2523         SET_EXPECT(GetContainer);
2524         SET_EXPECT(LockContainer);
2525     }
2526     SET_EXPECT(OnChanged_READYSTATE);
2527     SET_EXPECT(BindToStorage);
2528     if(set_clientsite) {
2529         SET_EXPECT(Invoke_AMBIENT_SILENT);
2530         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2531         SET_EXPECT(Exec_ShellDocView_37);
2532     }
2533     expect_LockContainer_fLock = TRUE;
2534     readystate_set_loading = TRUE;
2535
2536     hres = IPersistMoniker_Load(persist, FALSE, &Moniker, bind, 0x12);
2537     ok(hres == S_OK, "Load failed: %08x\n", hres);
2538
2539     CHECK_CALLED(GetDisplayName);
2540     if(!set_clientsite) {
2541         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
2542         CHECK_CALLED(GetHostInfo);
2543         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
2544         CHECK_CALLED(Invoke_AMBIENT_SILENT);
2545         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2546         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
2547         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
2548         CHECK_CALLED(GetOptionKeyPath);
2549         CHECK_CALLED(GetOverrideKeyPath);
2550         CHECK_CALLED(GetWindow);
2551         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
2552         CHECK_CALLED(Exec_SETPROGRESSMAX);
2553         CHECK_CALLED(Exec_SETPROGRESSPOS);
2554         CHECK_CALLED(Exec_ShellDocView_37);
2555     }
2556     if(!container_locked) {
2557         CHECK_CALLED(GetContainer);
2558         CHECK_CALLED(LockContainer);
2559         container_locked = TRUE;
2560     }
2561     CHECK_CALLED(OnChanged_READYSTATE);
2562     CHECK_CALLED(BindToStorage);
2563     if(set_clientsite) {
2564         CHECK_CALLED(Invoke_AMBIENT_SILENT);
2565         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2566         CHECK_CALLED(Exec_ShellDocView_37);
2567     }
2568
2569     set_clientsite = container_locked = TRUE;
2570
2571     test_GetCurMoniker((IUnknown*)persist, &Moniker, NULL);
2572
2573     IBindCtx_Release(bind);
2574
2575     test_readyState((IUnknown*)persist);
2576 }
2577
2578 static void test_download(BOOL verb_done, BOOL css_dwl)
2579 {
2580     HWND hwnd;
2581     MSG msg;
2582
2583     hwnd = FindWindowA("Internet Explorer_Hidden", NULL);
2584     ok(hwnd != NULL, "Could not find hidden window\n");
2585
2586     test_readyState(NULL);
2587
2588     if(verb_done) {
2589         SET_EXPECT(Exec_SETPROGRESSMAX);
2590         if(!load_from_stream)
2591             SET_EXPECT(GetHostInfo);
2592     }
2593     SET_EXPECT(SetStatusText);
2594     SET_EXPECT(Exec_SETDOWNLOADSTATE_1);
2595     SET_EXPECT(GetDropTarget);
2596     if(css_dwl) {
2597         SET_EXPECT(CreateInstance);
2598         SET_EXPECT(Start);
2599         SET_EXPECT(LockRequest);
2600         SET_EXPECT(Terminate);
2601         SET_EXPECT(Protocol_Read);
2602         SET_EXPECT(UnlockRequest);
2603     }
2604     SET_EXPECT(OnChanged_1005);
2605     SET_EXPECT(OnChanged_READYSTATE);
2606     SET_EXPECT(Exec_SETPROGRESSPOS);
2607     SET_EXPECT(Exec_SETDOWNLOADSTATE_0);
2608     SET_EXPECT(Exec_MSHTML_PARSECOMPLETE);
2609     SET_EXPECT(Exec_HTTPEQUIV_DONE);
2610     expect_status_text = (LPWSTR)0xdeadbeef; /* TODO */
2611
2612     while(!called_Exec_HTTPEQUIV_DONE && GetMessage(&msg, NULL, 0, 0)) {
2613         TranslateMessage(&msg);
2614         DispatchMessage(&msg);
2615     }
2616
2617     if(verb_done) {
2618         CHECK_CALLED(Exec_SETPROGRESSMAX);
2619         if(!load_from_stream)
2620             CHECK_CALLED(GetHostInfo);
2621     }
2622     CHECK_CALLED(SetStatusText);
2623     CHECK_CALLED(Exec_SETDOWNLOADSTATE_1);
2624     CHECK_CALLED(GetDropTarget);
2625     if(css_dwl) {
2626         if(called_CreateInstance) {
2627             CHECK_CALLED(CreateInstance);
2628             CHECK_CALLED(Start);
2629             CHECK_CALLED(LockRequest);
2630             CHECK_CALLED(Terminate);
2631             CHECK_CALLED(Protocol_Read);
2632             CHECK_CALLED(UnlockRequest);
2633         }else {
2634             skip("CreateInstance not called. Assuming no Gecko installed.\n");
2635
2636             SET_CALLED(CreateInstance);
2637             SET_CALLED(Start);
2638             SET_CALLED(LockRequest);
2639             SET_CALLED(Terminate);
2640             SET_CALLED(Protocol_Read);
2641             SET_CALLED(UnlockRequest);
2642
2643             nogecko = TRUE;
2644         }
2645     }
2646     CHECK_CALLED(OnChanged_1005);
2647     CHECK_CALLED(OnChanged_READYSTATE);
2648     CHECK_CALLED(Exec_SETPROGRESSPOS);
2649     CHECK_CALLED(Exec_SETDOWNLOADSTATE_0);
2650     CHECK_CALLED(Exec_MSHTML_PARSECOMPLETE);
2651     CHECK_CALLED(Exec_HTTPEQUIV_DONE);
2652
2653     load_state = LD_COMPLETE;
2654
2655     test_readyState(NULL);
2656 }
2657
2658 static void test_Persist(IUnknown *unk)
2659 {
2660     IPersistMoniker *persist_mon;
2661     IPersistFile *persist_file;
2662     GUID guid;
2663     HRESULT hres;
2664
2665     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&persist_file);
2666     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08x\n", hres);
2667     if(SUCCEEDED(hres)) {
2668         hres = IPersist_GetClassID(persist_file, NULL);
2669         ok(hres == E_INVALIDARG, "GetClassID returned: %08x, expected E_INVALIDARG\n", hres);
2670
2671         hres = IPersist_GetClassID(persist_file, &guid);
2672         ok(hres == S_OK, "GetClassID failed: %08x\n", hres);
2673         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
2674
2675         IPersist_Release(persist_file);
2676     }
2677
2678     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&persist_mon);
2679     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08x\n", hres);
2680     if(SUCCEEDED(hres)) {
2681         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
2682         ok(hres == E_INVALIDARG, "GetClassID returned: %08x, expected E_INVALIDARG\n", hres);
2683
2684         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
2685         ok(hres == S_OK, "GetClassID failed: %08x\n", hres);
2686         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
2687
2688         if(load_state == LD_DOLOAD)
2689             test_Load(persist_mon);
2690
2691         test_readyState(unk);
2692
2693         IPersistMoniker_Release(persist_mon);
2694     }
2695 }
2696
2697 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
2698     0,
2699     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
2700     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
2701     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
2702     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
2703     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
2704     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
2705     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
2706     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
2707     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
2708     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
2709     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
2710     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
2711     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
2712     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
2713     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
2714     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
2715     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
2716     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
2717     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
2718     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
2719     0,
2720     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
2721     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
2722     0,0,0,0,0,0,
2723     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
2724     0,0,
2725     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
2726     0,0,
2727     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
2728     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
2729     0,0,0,0,0,
2730     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
2731     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
2732     0,0,
2733     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
2734     0,0,0,
2735     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
2736     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
2737 };
2738
2739 static void test_QueryStatus(IUnknown *unk, REFIID cgid, ULONG cmdid, DWORD cmdf)
2740 {
2741     IOleCommandTarget *cmdtrg;
2742     OLECMD olecmd = {cmdid, 0};
2743     HRESULT hres;
2744
2745     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2746     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget failed: %08x\n", hres);
2747     if(FAILED(hres))
2748         return;
2749
2750     hres = IOleCommandTarget_QueryStatus(cmdtrg, cgid, 1, &olecmd, NULL);
2751     ok(hres == S_OK, "QueryStatus(%u) failed: %08x\n", cmdid, hres);
2752
2753     IOleCommandTarget_Release(cmdtrg);
2754
2755     ok(olecmd.cmdID == cmdid, "cmdID changed\n");
2756     ok(olecmd.cmdf == cmdf, "(%u) cmdf=%08x, expected %08x\n", cmdid, olecmd.cmdf, cmdf);
2757 }
2758
2759 static void test_MSHTML_QueryStatus(IUnknown *unk, DWORD cmdf)
2760 {
2761     if(!unk)
2762         unk = doc_unk;
2763
2764     test_QueryStatus(unk, &CGID_MSHTML, IDM_FONTNAME, cmdf);
2765     test_QueryStatus(unk, &CGID_MSHTML, IDM_FONTSIZE, cmdf);
2766     test_QueryStatus(unk, &CGID_MSHTML, IDM_SELECTALL, cmdf|OLECMDF_ENABLED);
2767     test_QueryStatus(unk, &CGID_MSHTML, IDM_BOLD, cmdf);
2768     test_QueryStatus(unk, &CGID_MSHTML, IDM_FORECOLOR, cmdf);
2769     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYCENTER, cmdf);
2770     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYLEFT, cmdf);
2771     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT, cmdf);
2772     test_QueryStatus(unk, &CGID_MSHTML, IDM_ITALIC, cmdf);
2773     test_QueryStatus(unk, &CGID_MSHTML, IDM_UNDERLINE, cmdf);
2774     test_QueryStatus(unk, &CGID_MSHTML, IDM_HORIZONTALLINE, cmdf);
2775     test_QueryStatus(unk, &CGID_MSHTML, IDM_ORDERLIST, cmdf);
2776     test_QueryStatus(unk, &CGID_MSHTML, IDM_UNORDERLIST, cmdf);
2777     test_QueryStatus(unk, &CGID_MSHTML, IDM_INDENT, cmdf);
2778     test_QueryStatus(unk, &CGID_MSHTML, IDM_OUTDENT, cmdf);
2779     test_QueryStatus(unk, &CGID_MSHTML, IDM_DELETE, cmdf);
2780 }
2781
2782 static void test_OleCommandTarget(IUnknown *unk)
2783 {
2784     IOleCommandTarget *cmdtrg;
2785     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
2786     int i;
2787     HRESULT hres;
2788
2789     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2790     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget failed: %08x\n", hres);
2791     if(FAILED(hres))
2792         return;
2793
2794     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
2795         cmds[i].cmdID = i+1;
2796         cmds[i].cmdf = 0xf0f0;
2797     }
2798
2799     SET_EXPECT(QueryStatus_OPEN);
2800     SET_EXPECT(QueryStatus_NEW);
2801     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
2802     ok(hres == S_OK, "QueryStatus failed: %08x\n", hres);
2803     CHECK_CALLED(QueryStatus_OPEN);
2804     CHECK_CALLED(QueryStatus_NEW);
2805
2806     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
2807         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %x\n", i, cmds[i].cmdID);
2808         if(i+1 == OLECMDID_FIND)
2809             continue;
2810         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%x, expected %x\n",
2811                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
2812     }
2813
2814     ok(!cmds[OLECMDID_FIND-1].cmdf || cmds[OLECMDID_FIND-1].cmdf == (OLECMDF_SUPPORTED|OLECMDF_ENABLED),
2815        "cmds[OLECMDID_FIND].cmdf=%x\n", cmds[OLECMDID_FIND-1].cmdf);
2816
2817     IOleCommandTarget_Release(cmdtrg);
2818 }
2819
2820 static void test_OleCommandTarget_fail(IUnknown *unk)
2821 {
2822     IOleCommandTarget *cmdtrg;
2823     int i;
2824     HRESULT hres;
2825
2826     OLECMD cmd[2] = {
2827         {OLECMDID_OPEN, 0xf0f0},
2828         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
2829     };
2830
2831     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2832     ok(hres == S_OK, "QueryInterface(IIDIOleCommandTarget failed: %08x\n", hres);
2833     if(FAILED(hres))
2834         return;
2835
2836     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
2837     ok(hres == S_OK, "QueryStatus failed: %08x\n", hres);
2838
2839     SET_EXPECT(QueryStatus_OPEN);
2840     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
2841     CHECK_CALLED(QueryStatus_OPEN);
2842
2843     ok(hres == OLECMDERR_E_NOTSUPPORTED,
2844             "QueryStatus failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
2845     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
2846             "cmd[0].cmdID=%d, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
2847     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%x, expected 0\n", cmd[0].cmdf);
2848     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
2849             "cmd[1].cmdf=%x, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
2850
2851     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
2852     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
2853             "QueryStatus failed: %08x, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
2854
2855     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
2856         if(!expect_cmds[i]) {
2857             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
2858                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2859             ok(hres == OLECMDERR_E_NOTSUPPORTED,
2860                     "Exec failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
2861         }
2862     }
2863
2864     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
2865             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2866     ok(hres == OLECMDERR_E_NOTSUPPORTED,
2867             "Exec failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
2868
2869     IOleCommandTarget_Release(cmdtrg);
2870 }
2871
2872 static void test_exec_onunload(IUnknown *unk)
2873 {
2874     IOleCommandTarget *cmdtrg;
2875     VARIANT var;
2876     HRESULT hres;
2877
2878     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2879     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
2880     if(FAILED(hres))
2881         return;
2882
2883     memset(&var, 0x0a, sizeof(var));
2884     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
2885             OLECMDEXECOPT_DODEFAULT, NULL, &var);
2886     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08x\n", hres);
2887     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
2888     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
2889
2890     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
2891             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2892     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08x\n", hres);
2893
2894     IOleCommandTarget_Release(cmdtrg);
2895 }
2896
2897 static void test_exec_editmode(IUnknown *unk)
2898 {
2899     IOleCommandTarget *cmdtrg;
2900     HRESULT hres;
2901
2902     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2903     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
2904     if(FAILED(hres))
2905         return;
2906
2907     editmode = TRUE;
2908
2909     SET_EXPECT(SetStatusText);
2910     SET_EXPECT(Exec_ShellDocView_37);
2911     SET_EXPECT(GetHostInfo);
2912     SET_EXPECT(Invoke_AMBIENT_SILENT);
2913     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2914     SET_EXPECT(OnChanged_READYSTATE);
2915     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
2916     SET_EXPECT(HideUI);
2917     SET_EXPECT(ShowUI);
2918     SET_EXPECT(InPlaceFrame_SetBorderSpace);
2919     expect_status_text = NULL;
2920     readystate_set_loading = TRUE;
2921
2922     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_EDITMODE,
2923             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2924     ok(hres == S_OK, "Exec failed: %08x\n", hres);
2925
2926     CHECK_CALLED(SetStatusText);
2927     CHECK_CALLED(Exec_ShellDocView_37);
2928     CHECK_CALLED(GetHostInfo);
2929     CHECK_CALLED(Invoke_AMBIENT_SILENT);
2930     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
2931     CHECK_CALLED(OnChanged_READYSTATE);
2932     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
2933     CHECK_CALLED(HideUI);
2934     CHECK_CALLED(ShowUI);
2935     CHECK_CALLED(InPlaceFrame_SetBorderSpace);
2936
2937     test_timer(EXPECT_UPDATEUI|EXPECT_SETTITLE);
2938
2939     IOleCommandTarget_Release(cmdtrg);
2940
2941     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_EDITMODE,
2942             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2943     ok(hres == S_OK, "Exec failed: %08x\n", hres);
2944 }
2945
2946 static void test_exec_fontname(IUnknown *unk, LPCWSTR name, LPCWSTR exname)
2947 {
2948    IOleCommandTarget *cmdtrg;
2949    VARIANT *in = NULL, _in, *out = NULL, _out;
2950    HRESULT hres;
2951
2952    hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2953    ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08x\n", hres);
2954    if(FAILED(hres))
2955        return;
2956
2957    if(name) {
2958        in = &_in;
2959        V_VT(in) = VT_BSTR;
2960        V_BSTR(in) = SysAllocString(name);
2961    }
2962
2963    if(exname) {
2964        out = &_out;
2965        V_VT(out) = VT_I4;
2966        V_I4(out) = 0xdeadbeef;
2967    }
2968
2969    hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_FONTNAME, 0, in, out);
2970    if(!nogecko)
2971        ok(hres == S_OK, "Exec(IDM_FONTNAME) failed: %08x\n", hres);
2972
2973    if(in)
2974        VariantClear(in);
2975
2976    if(out && !nogecko) {
2977        ok(V_VT(out) == VT_BSTR, "V_VT(out) = %x\n", V_VT(out));
2978        if(V_VT(out) == VT_BSTR)
2979            ok(!lstrcmpW(V_BSTR(out), name ? name : exname), "unexpected fontname\n");
2980        VariantClear(out);
2981    }
2982
2983    IOleCommandTarget_Release(cmdtrg);
2984 }
2985
2986 static void test_exec_noargs(IUnknown *unk, DWORD cmdid)
2987 {
2988     IOleCommandTarget *cmdtrg;
2989     HRESULT hres;
2990
2991     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
2992     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
2993     if(FAILED(hres))
2994         return;
2995
2996     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, cmdid,
2997             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
2998     ok(hres == S_OK, "Exec failed: %08x\n", hres);
2999
3000     IOleCommandTarget_Release(cmdtrg);
3001 }
3002
3003 static void test_IsDirty(IUnknown *unk, HRESULT exhres)
3004 {
3005     IPersistStreamInit *perinit;
3006     IPersistMoniker *permon;
3007     IPersistFile *perfile;
3008     HRESULT hres;
3009
3010     hres = IUnknown_QueryInterface(unk, &IID_IPersistStreamInit, (void**)&perinit);
3011     ok(hres == S_OK, "QueryInterface(IID_IPersistStreamInit failed: %08x\n", hres);
3012     if(SUCCEEDED(hres)) {
3013         hres = IPersistStreamInit_IsDirty(perinit);
3014         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
3015         IPersistStreamInit_Release(perinit);
3016     }
3017
3018     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&permon);
3019     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker failed: %08x\n", hres);
3020     if(SUCCEEDED(hres)) {
3021         hres = IPersistMoniker_IsDirty(permon);
3022         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
3023         IPersistMoniker_Release(permon);
3024     }
3025
3026     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&perfile);
3027     ok(hres == S_OK, "QueryInterface(IID_IPersistFile failed: %08x\n", hres);
3028     if(SUCCEEDED(hres)) {
3029         hres = IPersistFile_IsDirty(perfile);
3030         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
3031         IPersistFile_Release(perfile);
3032     }
3033 }
3034
3035 static HWND create_container_window(void)
3036 {
3037     static const WCHAR wszHTMLDocumentTest[] =
3038         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
3039     static WNDCLASSEXW wndclass = {
3040         sizeof(WNDCLASSEXW),
3041         0,
3042         wnd_proc,
3043         0, 0, NULL, NULL, NULL, NULL, NULL,
3044         wszHTMLDocumentTest,
3045         NULL
3046     };
3047
3048     RegisterClassExW(&wndclass);
3049     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
3050             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
3051             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
3052 }
3053
3054 static HRESULT test_DoVerb(IOleObject *oleobj)
3055 {
3056     RECT rect = {0,0,500,500};
3057     HRESULT hres;
3058
3059     if(!container_locked) {
3060         SET_EXPECT(GetContainer);
3061         SET_EXPECT(LockContainer);
3062     }
3063     SET_EXPECT(ActivateMe);
3064     expect_LockContainer_fLock = TRUE;
3065
3066     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
3067     if(FAILED(hres))
3068         return hres;
3069     ok(hres == S_OK, "DoVerb failed: %08x\n", hres);
3070
3071     if(!container_locked) {
3072         CHECK_CALLED(GetContainer);
3073         CHECK_CALLED(LockContainer);
3074         container_locked = TRUE;
3075     }
3076     CHECK_CALLED(ActivateMe);
3077
3078     return hres;
3079 }
3080
3081 #define CLIENTSITE_EXPECTPATH 0x00000001
3082 #define CLIENTSITE_SETNULL    0x00000002
3083 #define CLIENTSITE_DONTSET    0x00000004
3084
3085 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
3086 {
3087     IOleClientSite *clientsite;
3088     HRESULT hres;
3089
3090     if(flags & CLIENTSITE_SETNULL) {
3091         hres = IOleObject_GetClientSite(oleobj, &clientsite);
3092         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
3093
3094         hres = IOleObject_SetClientSite(oleobj, NULL);
3095         ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
3096
3097         set_clientsite = FALSE;
3098     }
3099
3100     if(flags & CLIENTSITE_DONTSET)
3101         return;
3102
3103     hres = IOleObject_GetClientSite(oleobj, &clientsite);
3104     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
3105     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
3106             clientsite, set_clientsite ? &ClientSite : NULL);
3107
3108     if(!set_clientsite) {
3109         SET_EXPECT(GetHostInfo);
3110         if(flags & CLIENTSITE_EXPECTPATH) {
3111             SET_EXPECT(GetOptionKeyPath);
3112             SET_EXPECT(GetOverrideKeyPath);
3113         }
3114         SET_EXPECT(GetWindow);
3115         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
3116         SET_EXPECT(Exec_SETPROGRESSMAX);
3117         SET_EXPECT(Exec_SETPROGRESSPOS);
3118         SET_EXPECT(Invoke_AMBIENT_USERMODE);
3119         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
3120         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3121         SET_EXPECT(Invoke_AMBIENT_SILENT);
3122         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
3123         SET_EXPECT(Invoke_AMBIENT_PALETTE);
3124
3125         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
3126         ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
3127
3128         CHECK_CALLED(GetHostInfo);
3129         if(flags & CLIENTSITE_EXPECTPATH) {
3130             CHECK_CALLED(GetOptionKeyPath);
3131             CHECK_CALLED(GetOverrideKeyPath);
3132         }
3133         CHECK_CALLED(GetWindow);
3134         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
3135         CHECK_CALLED(Exec_SETPROGRESSMAX);
3136         CHECK_CALLED(Exec_SETPROGRESSPOS);
3137         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
3138         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
3139         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3140         CHECK_CALLED(Invoke_AMBIENT_SILENT);
3141         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
3142         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
3143
3144         set_clientsite = TRUE;
3145     }
3146
3147     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
3148     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
3149
3150     hres = IOleObject_GetClientSite(oleobj, &clientsite);
3151     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
3152     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
3153 }
3154
3155 static void test_OnAmbientPropertyChange(IUnknown *unk)
3156 {
3157     IOleControl *control = NULL;
3158     HRESULT hres;
3159
3160     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
3161     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08x\n", hres);
3162     if(FAILED(hres))
3163         return;
3164
3165     SET_EXPECT(Invoke_AMBIENT_USERMODE);
3166     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
3167     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3168     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
3169
3170     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
3171     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
3172     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3173     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
3174
3175     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
3176     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3177     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
3178     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3179     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
3180     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3181
3182     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
3183     SET_EXPECT(Invoke_AMBIENT_SILENT);
3184     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
3185     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3186     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
3187     CHECK_CALLED(Invoke_AMBIENT_SILENT);
3188
3189     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
3190     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
3191     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3192     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
3193
3194     SET_EXPECT(Invoke_AMBIENT_PALETTE);
3195     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
3196     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
3197     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
3198
3199     IOleControl_Release(control);
3200 }
3201
3202
3203
3204 static void test_OnAmbientPropertyChange2(IUnknown *unk)
3205 {
3206     IOleControl *control = NULL;
3207     HRESULT hres;
3208
3209     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
3210     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08x\n", hres);
3211     if(FAILED(hres))
3212         return;
3213
3214     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
3215     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08x\n", hres);
3216
3217     IOleControl_Release(control);
3218 }
3219
3220 static void test_Close(IUnknown *unk, BOOL set_client)
3221 {
3222     IOleObject *oleobj = NULL;
3223     HRESULT hres;
3224
3225     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
3226     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
3227     if(FAILED(hres))
3228         return;
3229
3230     SET_EXPECT(GetContainer);
3231     SET_EXPECT(LockContainer);
3232     expect_LockContainer_fLock = FALSE;
3233     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
3234     ok(hres == S_OK, "Close failed: %08x\n", hres);
3235     CHECK_CALLED(GetContainer);
3236     CHECK_CALLED(LockContainer);
3237     container_locked = FALSE;
3238
3239     if(set_client)
3240         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
3241
3242     IOleObject_Release(oleobj);
3243 }
3244
3245 static void test_OnFrameWindowActivate(IUnknown *unk)
3246 {
3247     IOleInPlaceActiveObject *inplaceact;
3248     HRESULT hres;
3249
3250     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceActiveObject, (void**)&inplaceact);
3251     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceActiveObject) failed: %08x\n", hres);
3252     if(FAILED(hres))
3253         return;
3254
3255     if(set_clientsite) {
3256         expect_OnFrameWindowActivate_fActivate = TRUE;
3257         SET_EXPECT(OnFrameWindowActivate);
3258         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
3259         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3260         CHECK_CALLED(OnFrameWindowActivate);
3261
3262         SET_EXPECT(OnFrameWindowActivate);
3263         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
3264         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3265         CHECK_CALLED(OnFrameWindowActivate);
3266
3267         expect_OnFrameWindowActivate_fActivate = FALSE;
3268         SET_EXPECT(OnFrameWindowActivate);
3269         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
3270         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3271         CHECK_CALLED(OnFrameWindowActivate);
3272
3273         expect_OnFrameWindowActivate_fActivate = TRUE;
3274         SET_EXPECT(OnFrameWindowActivate);
3275         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
3276         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3277         CHECK_CALLED(OnFrameWindowActivate);
3278     }else {
3279         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
3280         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3281
3282         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
3283         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
3284     }
3285
3286     IOleInPlaceActiveObject_Release(inplaceact);
3287 }
3288
3289 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
3290 {
3291     IOleInPlaceObjectWindowless *windowlessobj = NULL;
3292     HRESULT hres;
3293
3294     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
3295             (void**)&windowlessobj);
3296     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08x\n", hres);
3297     if(FAILED(hres))
3298         return;
3299
3300     if(expect_call) {
3301         SET_EXPECT(OnFocus_FALSE);
3302         if(ipsex)
3303             SET_EXPECT(OnInPlaceDeactivateEx);
3304         else
3305             SET_EXPECT(OnInPlaceDeactivate);
3306     }
3307     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
3308     ok(hres == S_OK, "InPlaceDeactivate failed: %08x\n", hres);
3309     if(expect_call) {
3310         CHECK_CALLED(OnFocus_FALSE);
3311         if(ipsex)
3312             CHECK_CALLED(OnInPlaceDeactivateEx);
3313         else
3314             CHECK_CALLED(OnInPlaceDeactivate);
3315     }
3316
3317     IOleInPlaceObjectWindowless_Release(windowlessobj);
3318 }
3319
3320 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
3321 {
3322     IOleObject *oleobj = NULL;
3323     IOleDocumentView *docview;
3324     GUID guid;
3325     HRESULT hres;
3326
3327     last_hwnd = hwnd;
3328
3329     if(view)
3330         IOleDocumentView_Release(view);
3331     view = NULL;
3332
3333     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
3334     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
3335     if(FAILED(hres))
3336         return hres;
3337
3338     hres = IOleObject_GetUserClassID(oleobj, NULL);
3339     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08x, expected E_INVALIDARG\n", hres);
3340
3341     hres = IOleObject_GetUserClassID(oleobj, &guid);
3342     ok(hres == S_OK, "GetUserClassID failed: %08x\n", hres);
3343     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
3344
3345     test_OnFrameWindowActivate(unk);
3346
3347     test_ClientSite(oleobj, flags);
3348     test_InPlaceDeactivate(unk, FALSE);
3349
3350     hres = test_DoVerb(oleobj);
3351
3352     if(call_UIActivate == CallUIActivate_AfterShow) {
3353         hres = IOleObject_QueryInterface(oleobj, &IID_IOleDocumentView, (void **)&docview);
3354         ok(hres == S_OK, "IOleObject_QueryInterface failed with error 0x%08x\n", hres);
3355
3356         SET_EXPECT(OnFocus_TRUE);
3357         SET_EXPECT(SetActiveObject);
3358         SET_EXPECT(ShowUI);
3359         SET_EXPECT(InPlaceUIWindow_SetActiveObject);
3360         SET_EXPECT(InPlaceFrame_SetBorderSpace);
3361         expect_SetActiveObject_active = TRUE;
3362         expect_status_text = NULL;
3363
3364         hres = IOleDocumentView_UIActivate(docview, TRUE);
3365         ok(hres == S_OK, "IOleDocumentView_UIActivate failed with error 0x%08x\n", hres);
3366
3367         CHECK_CALLED(OnFocus_TRUE);
3368         CHECK_CALLED(SetActiveObject);
3369         CHECK_CALLED(ShowUI);
3370         CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
3371         CHECK_CALLED(InPlaceFrame_SetBorderSpace);
3372
3373         IOleDocumentView_Release(docview);
3374     }
3375
3376     IOleObject_Release(oleobj);
3377
3378     test_OnFrameWindowActivate(unk);
3379
3380     return hres;
3381 }
3382
3383 static void test_Window(IUnknown *unk, BOOL expect_success)
3384 {
3385     IOleInPlaceActiveObject *activeobject = NULL;
3386     HWND tmp_hwnd;
3387     HRESULT hres;
3388
3389     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
3390     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08x\n", hres);
3391     if(FAILED(hres))
3392         return;
3393
3394     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
3395
3396     if(expect_success) {
3397         ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
3398         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
3399     }else {
3400         ok(hres == E_FAIL, "GetWindow returned %08x, expected E_FAIL\n", hres);
3401         ok(IsWindow(hwnd), "hwnd is destroyed\n");
3402     }
3403
3404     IOleInPlaceActiveObject_Release(activeobject);
3405 }
3406
3407 static void test_CloseView(void)
3408 {
3409     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
3410     HRESULT hres;
3411
3412     if(!view)
3413         return;
3414
3415     hres = IOleDocumentView_Show(view, FALSE);
3416     ok(hres == S_OK, "Show failed: %08x\n", hres);
3417
3418     hres = IOleDocumentView_CloseView(view, 0);
3419     ok(hres == S_OK, "CloseView failed: %08x\n", hres);
3420
3421     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
3422     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
3423
3424     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
3425     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
3426     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
3427 }
3428
3429 static void test_UIDeactivate(void)
3430 {
3431     HRESULT hres;
3432
3433     if(call_UIActivate == CallUIActivate_AfterShow) {
3434         SET_EXPECT(InPlaceUIWindow_SetActiveObject);
3435     }
3436     if(call_UIActivate != CallUIActivate_None) {
3437         SET_EXPECT(SetActiveObject);
3438         SET_EXPECT(HideUI);
3439         SET_EXPECT(OnUIDeactivate);
3440     }
3441
3442     expect_SetActiveObject_active = FALSE;
3443     hres = IOleDocumentView_UIActivate(view, FALSE);
3444     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
3445
3446     if(call_UIActivate != CallUIActivate_None) {
3447         CHECK_CALLED(SetActiveObject);
3448         CHECK_CALLED(HideUI);
3449         CHECK_CALLED(OnUIDeactivate);
3450     }
3451     if(call_UIActivate == CallUIActivate_AfterShow) {
3452         CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
3453     }
3454 }
3455
3456 static void test_Hide(void)
3457 {
3458     HRESULT hres;
3459
3460     if(!view)
3461         return;
3462
3463     hres = IOleDocumentView_Show(view, FALSE);
3464     ok(hres == S_OK, "Show failed: %08x\n", hres);
3465 }
3466
3467 static HRESULT create_document(IUnknown **unk)
3468 {
3469     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
3470             &IID_IUnknown, (void**)unk);
3471     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
3472     return hres;
3473 }
3474
3475 static void test_Navigate(IUnknown *unk)
3476 {
3477     IHlinkTarget *hlink;
3478     HRESULT hres;
3479
3480     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
3481     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08x\n", hres);
3482
3483     SET_EXPECT(ActivateMe);
3484     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
3485     ok(hres == S_OK, "Navigate failed: %08x\n", hres);
3486     CHECK_CALLED(ActivateMe);
3487
3488     IHlinkTarget_Release(hlink);
3489 }
3490
3491 static void test_external(IUnknown *unk, BOOL initialized)
3492 {
3493     IDispatch *external;
3494     IHTMLDocument2 *doc;
3495     IHTMLWindow2 *htmlwin;
3496     HRESULT hres;
3497
3498     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&doc);
3499     ok(hres == S_OK, "QueryInterface(IID_IHTMLWindow2) failed: %08x\n", hres);
3500
3501     hres = IHTMLDocument2_get_parentWindow(doc, &htmlwin);
3502     IHTMLDocument2_Release(doc);
3503     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
3504
3505     if(initialized)
3506         SET_EXPECT(GetExternal);
3507     external = (void*)0xdeadbeef;
3508     hres = IHTMLWindow2_get_external(htmlwin, &external);
3509     if(initialized) {
3510         ok(hres == S_FALSE || hres == S_OK, "get_external failed: %08x\n", hres);
3511         CHECK_CALLED(GetExternal);
3512         ok(external != NULL, "external == NULL\n");
3513     }else {
3514         ok(hres == S_OK, "get_external failed: %08x\n", hres);
3515         ok(external == NULL, "external != NULL\n");
3516     }
3517
3518     IHTMLWindow2_Release(htmlwin);
3519 }
3520
3521 static void test_StreamLoad(IUnknown *unk)
3522 {
3523     IPersistStreamInit *init;
3524     HRESULT hres;
3525
3526     hres = IUnknown_QueryInterface(unk, &IID_IPersistStreamInit, (void**)&init);
3527     ok(hres == S_OK, "QueryInterface(IID_IPersistStreamInit) failed: %08x\n", hres);
3528     if(FAILED(hres))
3529         return;
3530
3531     SET_EXPECT(Invoke_AMBIENT_SILENT);
3532     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3533     SET_EXPECT(Exec_ShellDocView_37);
3534     SET_EXPECT(OnChanged_READYSTATE);
3535     SET_EXPECT(Read);
3536     readystate_set_loading = TRUE;
3537
3538     hres = IPersistStreamInit_Load(init, &Stream);
3539     ok(hres == S_OK, "Load failed: %08x\n", hres);
3540
3541     CHECK_CALLED(Invoke_AMBIENT_SILENT);
3542     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3543     CHECK_CALLED(Exec_ShellDocView_37);
3544     CHECK_CALLED(OnChanged_READYSTATE);
3545     CHECK_CALLED(Read);
3546
3547     test_timer(EXPECT_SETTITLE);
3548     test_GetCurMoniker(unk, NULL, about_blank_url);
3549
3550     IPersistStreamInit_Release(init);
3551 }
3552
3553 static void test_QueryInterface(IUnknown *unk)
3554 {
3555     IUnknown *qi;
3556     HRESULT hres;
3557
3558     qi = (void*)0xdeadbeef;
3559     hres = IUnknown_QueryInterface(unk, &IID_IRunnableObject, (void**)&qi);
3560     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
3561     ok(qi == NULL, "runnable=%p, ezpected NULL\n", qi);
3562
3563     qi = (void*)0xdeadbeef;
3564     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDOMNode, (void**)&qi);
3565     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
3566     ok(qi == NULL, "runnable=%p, ezpected NULL\n", qi);
3567
3568     qi = (void*)0xdeadbeef;
3569     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDOMNode2, (void**)&qi);
3570     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
3571     ok(qi == NULL, "runnable=%p, ezpected NULL\n", qi);
3572 }
3573
3574 static void init_test(enum load_state_t ls) {
3575     doc_unk = NULL;
3576     hwnd = last_hwnd = NULL;
3577     set_clientsite = FALSE;
3578     load_from_stream = FALSE;
3579     call_UIActivate = CallUIActivate_None;
3580     load_state = ls;
3581     editmode = FALSE;
3582     stream_read = 0;
3583     protocol_read = 0;
3584     ipsex = FALSE;
3585 }
3586
3587 static void test_HTMLDocument(enum load_state_t ls)
3588 {
3589     IUnknown *unk;
3590     HRESULT hres;
3591     ULONG ref;
3592
3593     trace("Testing HTMLDocument (%s)...\n", (ls == LD_DOLOAD ? " load" : "no load"));
3594
3595     init_test(ls);
3596
3597     hres = create_document(&unk);
3598     if(FAILED(hres))
3599         return;
3600     doc_unk = unk;
3601
3602     test_QueryInterface(unk);
3603     test_IsDirty(unk, S_FALSE);
3604     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3605     test_external(unk, FALSE);
3606     test_ConnectionPointContainer(unk);
3607     test_GetCurMoniker(unk, NULL, NULL);
3608     test_Persist(unk);
3609     if(load_state == LD_NO)
3610         test_OnAmbientPropertyChange2(unk);
3611
3612     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
3613     if(FAILED(hres)) {
3614         IUnknown_Release(unk);
3615         return;
3616     }
3617
3618     if(load_state == LD_LOADING) {
3619         test_download(FALSE, TRUE);
3620         test_GetCurMoniker(unk, &Moniker, NULL);
3621     }
3622
3623     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3624     test_OleCommandTarget_fail(unk);
3625     test_OleCommandTarget(unk);
3626     test_OnAmbientPropertyChange(unk);
3627     test_Window(unk, TRUE);
3628     test_external(unk, TRUE);
3629
3630     test_UIDeactivate();
3631     test_OleCommandTarget(unk);
3632     test_Window(unk, TRUE);
3633     test_InPlaceDeactivate(unk, TRUE);
3634
3635     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
3636      * MSHTML. It doesn't with Wine. */
3637
3638     test_Window(unk, FALSE);
3639     test_Hide();
3640     test_InPlaceDeactivate(unk, FALSE);
3641     test_CloseView();
3642     test_Close(unk, FALSE);
3643
3644     /* Activate HTMLDocument again */
3645     test_Activate(unk, CLIENTSITE_SETNULL);
3646     test_Window(unk, TRUE);
3647     test_OleCommandTarget(unk);
3648     test_UIDeactivate();
3649     test_InPlaceDeactivate(unk, TRUE);
3650     test_Close(unk, FALSE);
3651
3652     /* Activate HTMLDocument again, this time without UIActivate */
3653     call_UIActivate = CallUIActivate_None;
3654     test_Activate(unk, CLIENTSITE_SETNULL);
3655     test_Window(unk, TRUE);
3656     test_UIDeactivate();
3657     test_InPlaceDeactivate(unk, TRUE);
3658     test_CloseView();
3659     test_CloseView();
3660     test_Close(unk, TRUE);
3661     test_OnAmbientPropertyChange2(unk);
3662     test_GetCurMoniker(unk, load_state == LD_NO ? NULL : &Moniker, NULL);
3663
3664     if(ls != LD_DOLOAD) {
3665         /* Activate HTMLDocument again, calling UIActivate after showing the window */
3666         call_UIActivate = CallUIActivate_AfterShow;
3667         test_Activate(unk, 0);
3668         test_Window(unk, TRUE);
3669         test_OleCommandTarget(unk);
3670         test_UIDeactivate();
3671         test_InPlaceDeactivate(unk, TRUE);
3672         test_Close(unk, FALSE);
3673         call_UIActivate = CallUIActivate_None;
3674     }
3675
3676     if(view)
3677         IOleDocumentView_Release(view);
3678     view = NULL;
3679
3680     ok(IsWindow(hwnd), "hwnd is destroyed\n");
3681
3682     ref = IUnknown_Release(unk);
3683     ok(ref == 0, "ref=%d, expected 0\n", ref);
3684
3685     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
3686 }
3687
3688 static void test_HTMLDocument_hlink(void)
3689 {
3690     IUnknown *unk;
3691     HRESULT hres;
3692     ULONG ref;
3693
3694     trace("Testing HTMLDocument (hlink)...\n");
3695
3696     init_test(LD_DOLOAD);
3697     ipsex = TRUE;
3698
3699     hres = create_document(&unk);
3700     if(FAILED(hres))
3701         return;
3702     doc_unk = unk;
3703
3704     test_ConnectionPointContainer(unk);
3705     test_GetCurMoniker(unk, NULL, NULL);
3706     test_Persist(unk);
3707     test_Navigate(unk);
3708
3709     test_download(FALSE, TRUE);
3710
3711     test_IsDirty(unk, S_FALSE);
3712     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3713     test_exec_onunload(unk);
3714     test_Window(unk, TRUE);
3715     test_InPlaceDeactivate(unk, TRUE);
3716     test_Close(unk, FALSE);
3717     test_IsDirty(unk, S_FALSE);
3718     test_GetCurMoniker(unk, &Moniker, NULL);
3719
3720     if(view)
3721         IOleDocumentView_Release(view);
3722     view = NULL;
3723
3724     ref = IUnknown_Release(unk);
3725     ok(ref == 0, "ref=%d, expected 0\n", ref);
3726 }
3727
3728 static void test_HTMLDocument_StreamLoad(void)
3729 {
3730     IOleObject *oleobj;
3731     IUnknown *unk;
3732     HRESULT hres;
3733     ULONG ref;
3734
3735     trace("Testing HTMLDocument (IPersistStreamInit)...\n");
3736
3737     init_test(LD_DOLOAD);
3738     load_from_stream = TRUE;
3739
3740     hres = create_document(&unk);
3741     if(FAILED(hres))
3742         return;
3743     doc_unk = unk;
3744
3745     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
3746     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
3747
3748     test_readyState(unk);
3749     test_IsDirty(unk, S_FALSE);
3750     test_ConnectionPointContainer(unk);
3751     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
3752     test_DoVerb(oleobj);
3753     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3754
3755     IOleObject_Release(oleobj);
3756
3757     test_GetCurMoniker(unk, NULL, NULL);
3758     test_StreamLoad(unk);
3759     test_download(TRUE, FALSE);
3760
3761     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3762     test_UIDeactivate();
3763     test_InPlaceDeactivate(unk, TRUE);
3764     test_Close(unk, FALSE);
3765     test_IsDirty(unk, S_FALSE);
3766
3767     if(view) {
3768         IOleDocumentView_Release(view);
3769         view = NULL;
3770     }
3771
3772
3773     ref = IUnknown_Release(unk);
3774     ok(ref == 0, "ref=%d, expected 0\n", ref);
3775 }
3776
3777 static void test_edit_uiactivate(IOleObject *oleobj)
3778 {
3779     IOleDocumentView *docview;
3780     HRESULT hres;
3781
3782     hres = IOleObject_QueryInterface(oleobj, &IID_IOleDocumentView, (void **)&docview);
3783     ok(hres == S_OK, "IOleObject_QueryInterface failed with error 0x%08x\n", hres);
3784
3785     SET_EXPECT(OnFocus_TRUE);
3786     SET_EXPECT(SetActiveObject);
3787     SET_EXPECT(ShowUI);
3788     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
3789     SET_EXPECT(InPlaceFrame_SetBorderSpace);
3790     expect_SetActiveObject_active = TRUE;
3791     expect_status_text = NULL;
3792
3793     hres = IOleDocumentView_UIActivate(docview, TRUE);
3794     ok(hres == S_OK, "IOleDocumentView_UIActivate failed with error 0x%08x\n", hres);
3795
3796     CHECK_CALLED(OnFocus_TRUE);
3797     CHECK_CALLED(SetActiveObject);
3798     CHECK_CALLED(ShowUI);
3799     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
3800     CHECK_CALLED(InPlaceFrame_SetBorderSpace);
3801
3802     IOleDocumentView_Release(docview);
3803 }
3804
3805 static void test_editing_mode(void)
3806 {
3807     IUnknown *unk;
3808     IOleObject *oleobj;
3809     HRESULT hres;
3810     ULONG ref;
3811
3812     trace("Testing HTMLDocument (edit)...\n");
3813
3814     init_test(LD_DOLOAD);
3815     call_UIActivate = CallUIActivate_AfterShow;
3816
3817     hres = create_document(&unk);
3818     if(FAILED(hres))
3819         return;
3820     doc_unk = unk;
3821
3822     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
3823     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
3824
3825     test_readyState(unk);
3826     test_ConnectionPointContainer(unk);
3827     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
3828     test_DoVerb(oleobj);
3829     test_edit_uiactivate(oleobj);
3830
3831     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3832
3833     test_exec_editmode(unk);
3834     test_UIDeactivate();
3835     call_UIActivate = CallUIActivate_None;
3836     IOleObject_Release(oleobj);
3837
3838     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED);
3839     test_download(TRUE, FALSE);
3840     test_timer(EXPECT_UPDATEUI);
3841     test_MSHTML_QueryStatus(unk, OLECMDF_SUPPORTED|OLECMDF_ENABLED);
3842
3843     test_exec_fontname(unk, NULL, wszTimesNewRoman);
3844     test_exec_fontname(unk, wszArial, wszTimesNewRoman);
3845     test_timer(EXPECT_UPDATEUI);
3846     test_exec_fontname(unk, NULL, wszArial);
3847
3848     test_exec_noargs(unk, IDM_JUSTIFYRIGHT);
3849     test_timer(EXPECT_UPDATEUI);
3850     if(!nogecko)
3851         test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT,
3852                          OLECMDF_SUPPORTED|OLECMDF_ENABLED|OLECMDF_LATCHED);
3853
3854     test_exec_noargs(unk, IDM_JUSTIFYCENTER);
3855     test_timer(EXPECT_UPDATEUI);
3856     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT,
3857                      OLECMDF_SUPPORTED|OLECMDF_ENABLED);
3858     if(!nogecko)
3859         test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYCENTER,
3860                          OLECMDF_SUPPORTED|OLECMDF_ENABLED|OLECMDF_LATCHED);
3861
3862     test_exec_noargs(unk, IDM_HORIZONTALLINE);
3863     test_timer(EXPECT_UPDATEUI);
3864     test_QueryStatus(unk, &CGID_MSHTML, IDM_HORIZONTALLINE,
3865                      OLECMDF_SUPPORTED|OLECMDF_ENABLED);
3866
3867     test_UIDeactivate();
3868     test_InPlaceDeactivate(unk, TRUE);
3869     test_Close(unk, FALSE);
3870
3871     if(view) {
3872         IOleDocumentView_Release(view);
3873         view = NULL;
3874     }
3875
3876     ref = IUnknown_Release(unk);
3877     ok(ref == 0, "ref=%d, expected 0\n", ref);
3878 }
3879
3880 static void register_protocol(void)
3881 {
3882     IInternetSession *session;
3883     HRESULT hres;
3884
3885     static const WCHAR wsz_winetest[] = {'w','i','n','e','t','e','s','t',0};
3886
3887     hres = CoInternetGetSession(0, &session, 0);
3888     ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3889
3890     hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL,
3891             wsz_winetest, 0, NULL, 0);
3892     ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3893
3894     IInternetSession_Release(session);
3895 }
3896
3897 static void gecko_installer_workaround(BOOL disable)
3898 {
3899     HKEY hkey;
3900     DWORD res;
3901
3902     static BOOL has_url = FALSE;
3903     static char url[2048];
3904
3905     if(!disable && !has_url)
3906         return;
3907
3908     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
3909     if(res != ERROR_SUCCESS)
3910         return;
3911
3912     if(disable) {
3913         DWORD type, size = sizeof(url);
3914
3915         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
3916         if(res == ERROR_SUCCESS && type == REG_SZ)
3917             has_url = TRUE;
3918
3919         RegDeleteValue(hkey, "GeckoUrl");
3920     }else {
3921         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
3922     }
3923
3924     RegCloseKey(hkey);
3925 }
3926
3927 START_TEST(htmldoc)
3928 {
3929     gecko_installer_workaround(TRUE);
3930
3931     CoInitialize(NULL);
3932     container_hwnd = create_container_window();
3933     register_protocol();
3934
3935     test_HTMLDocument(LD_NO);
3936     test_HTMLDocument(LD_DOLOAD);
3937     test_HTMLDocument_hlink();
3938     test_HTMLDocument_StreamLoad();
3939     test_editing_mode();
3940
3941     DestroyWindow(container_hwnd);
3942     CoUninitialize();
3943
3944     gecko_installer_workaround(FALSE);
3945 }