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