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

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