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

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