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