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