dlls/mshtml/tests/events.c

   1 /*
   2  * Copyright 2008-2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "mshtml.h"
  30 #include "mshtmdid.h"
  31 #include "docobj.h"
  32 #include "hlink.h"
  33 #include "dispex.h"
  34
  35 #define DEFINE_EXPECT(func) \
  36     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  37
  38 #define SET_EXPECT(func) \
  39     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  40
  41 #define CHECK_EXPECT2(func) \
  42     do { \
  43     trace(#func "\n"); \
  44         ok(expect_ ##func, "unexpected call " #func "\n"); \
  45         called_ ## func = TRUE; \
  46     }while(0)
  47
  48 #define CHECK_EXPECT(func) \
  49     do { \
  50         CHECK_EXPECT2(func); \
  51         expect_ ## func = FALSE; \
  52     }while(0)
  53
  54 #define CHECK_CALLED(func) \
  55     do { \
  56         ok(called_ ## func, "expected " #func "\n"); \
  57         expect_ ## func = called_ ## func = FALSE; \
  58     }while(0)
  59
  60 DEFINE_EXPECT(document_onclick);
  61 DEFINE_EXPECT(body_onclick);
  62 DEFINE_EXPECT(doc_onclick_attached);
  63 DEFINE_EXPECT(div_onclick);
  64 DEFINE_EXPECT(div_onclick_attached);
  65 DEFINE_EXPECT(timeout);
  66 DEFINE_EXPECT(doccp_onclick);
  67 DEFINE_EXPECT(doccp_onclick_cancel);
  68 DEFINE_EXPECT(div_onclick_disp);
  69 DEFINE_EXPECT(invoke_onclick);
  70 DEFINE_EXPECT(iframe_onreadystatechange_loading);
  71 DEFINE_EXPECT(iframe_onreadystatechange_interactive);
  72 DEFINE_EXPECT(iframe_onreadystatechange_complete);
  73 DEFINE_EXPECT(iframedoc_onreadystatechange);
  74 DEFINE_EXPECT(img_onload);
  75 DEFINE_EXPECT(img_onerror);
  76 DEFINE_EXPECT(link_onload);
  77 DEFINE_EXPECT(input_onfocus);
  78 DEFINE_EXPECT(input_onblur);
  79 DEFINE_EXPECT(div_onfocusin);
  80 DEFINE_EXPECT(div_onfocusout);
  81 DEFINE_EXPECT(form_onsubmit);
  82 DEFINE_EXPECT(form_onclick);
  83 DEFINE_EXPECT(submit_onclick);
  84 DEFINE_EXPECT(submit_onclick_cancel);
  85 DEFINE_EXPECT(submit_onclick_attached);
  86 DEFINE_EXPECT(submit_onclick_attached_check_cancel);
  87 DEFINE_EXPECT(submit_onclick_setret);
  88 DEFINE_EXPECT(elem2_cp_onclick);
  89 DEFINE_EXPECT(iframe_onload);
  90
  91 static HWND container_hwnd = NULL;
  92 static IHTMLWindow2 *window;
  93 static IOleDocumentView *view;
  94 static BOOL is_ie9plus;
  95 static int document_mode;
  96
  97 typedef struct {
  98     LONG x;
  99     LONG y;
 100     LONG offset_x;
 101     LONG offset_y;
 102 } xy_test_t;
 103
 104 static const xy_test_t no_xy = {-10,-10,-10,-10};
 105
 106 static const char empty_doc_str[] =
 107     "<html></html>";
 108
 109 static const char empty_doc_ie9_str[] =
 110     "<html>"
 111     "<head><meta http-equiv=\"x-ua-compatible\" content=\"IE=9\" /></head>"
 112     "</html>";
 113
 114 static const char readystate_doc_str[] =
 115     "<html><body><iframe id=\"iframe\"></iframe></body></html>";
 116
 117 static const char readystate_doc_ie9_str[] =
 118     "<html>"
 119     "<head><meta http-equiv=\"x-ua-compatible\" content=\"IE=9\" /></head>"
 120     "<body><iframe id=\"iframe\"></iframe></body></html>";
 121
 122 static const char img_doc_str[] =
 123     "<html><body><img id=\"imgid\"></img></body></html>";
 124
 125 static const char link_doc_str[] =
 126     "<html><body><link id=\"linkid\" rel=\"stylesheet\" type=\"text/css\"></link></body></html>";
 127
 128 static const char input_doc_str[] =
 129     "<html><body><div id=\"divid\"><input id=\"inputid\"></input></div></body></html>";
 130
 131 static const char iframe_doc_str[] =
 132     "<html><body><iframe id=\"ifr\">Testing</iframe></body></html>";
 133
 134 static int strcmp_wa(LPCWSTR strw, const char *stra)
 135 {
 136     CHAR buf[512];
 137     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 138     return lstrcmpA(stra, buf);
 139 }
 140
 141 static BSTR a2bstr(const char *str)
 142 {
 143     BSTR ret;
 144     int len;
 145
 146     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 147     ret = SysAllocStringLen(NULL, len-1);
 148     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 149
 150     return ret;
 151 }
 152
 153 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 154 {
 155     IUnknown *unk1, *unk2;
 156
 157     if(iface1 == iface2)
 158         return TRUE;
 159
 160     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 161     IUnknown_Release(unk1);
 162     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 163     IUnknown_Release(unk2);
 164
 165     return unk1 == unk2;
 166 }
 167
 168 #define test_disp(u,id) _test_disp(__LINE__,u,id)
 169 static void _test_disp(unsigned line, IUnknown *unk, const IID *diid)
 170 {
 171     IDispatchEx *dispex;
 172     ITypeInfo *typeinfo;
 173     UINT ticnt;
 174     HRESULT hres;
 175
 176     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
 177     ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres);
 178     if(FAILED(hres))
 179         return;
 180
 181     ticnt = 0xdeadbeef;
 182     hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
 183     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres);
 184     ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt);
 185
 186     hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo);
 187     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x\n", hres);
 188
 189     if(SUCCEEDED(hres)) {
 190         TYPEATTR *type_attr;
 191
 192         hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr);
 193         ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x\n", hres);
 194         if(diid)
 195             ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid), "unexpected guid %s\n",
 196                                 wine_dbgstr_guid(&type_attr->guid));
 197
 198         ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr);
 199         ITypeInfo_Release(typeinfo);
 200     }
 201
 202     IDispatchEx_Release(dispex);
 203 }
 204
 205 #define get_doc3_iface(u) _get_doc3_iface(__LINE__,u)
 206 static IHTMLDocument3 *_get_doc3_iface(unsigned line, IUnknown *unk)
 207 {
 208     IHTMLDocument3 *doc3;
 209     HRESULT hres;
 210
 211     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument3, (void**)&doc3);
 212     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
 213
 214     return doc3;
 215 }
 216
 217 #define get_elem_iface(u) _get_elem_iface(__LINE__,u)
 218 static IHTMLElement *_get_elem_iface(unsigned line, IUnknown *unk)
 219 {
 220     IHTMLElement *elem;
 221     HRESULT hres;
 222
 223     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement, (void**)&elem);
 224     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement iface: %08x\n", hres);
 225
 226     return elem;
 227 }
 228
 229 #define get_elem2_iface(u) _get_elem2_iface(__LINE__,u)
 230 static IHTMLElement2 *_get_elem2_iface(unsigned line, IUnknown *unk)
 231 {
 232     IHTMLElement2 *elem2;
 233     HRESULT hres;
 234
 235     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement2, (void**)&elem2);
 236     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
 237
 238     return elem2;
 239 }
 240
 241 #define get_elem3_iface(u) _get_elem3_iface(__LINE__,u)
 242 static IHTMLElement3 *_get_elem3_iface(unsigned line, IUnknown *unk)
 243 {
 244     IHTMLElement3 *elem3;
 245     HRESULT hres;
 246
 247     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement3, (void**)&elem3);
 248     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
 249
 250     return elem3;
 251 }
 252
 253 #define get_elem4_iface(u) _get_elem4_iface(__LINE__,u)
 254 static IHTMLElement4 *_get_elem4_iface(unsigned line, IUnknown *unk)
 255 {
 256     IHTMLElement4 *elem4;
 257     HRESULT hres;
 258
 259     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement4, (void**)&elem4);
 260     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement4 iface: %08x\n", hres);
 261
 262     return elem4;
 263 }
 264
 265 #define get_iframe_iface(u) _get_iframe_iface(__LINE__,u)
 266 static IHTMLIFrameElement *_get_iframe_iface(unsigned line, IUnknown *unk)
 267 {
 268     IHTMLIFrameElement *iframe;
 269     HRESULT hres;
 270
 271     hres = IUnknown_QueryInterface(unk, &IID_IHTMLIFrameElement, (void**)&iframe);
 272     ok_(__FILE__,line)(hres == S_OK, "QueryInterface(IID_IHTMLIFrameElement) failed: %08x\n", hres);
 273
 274     return iframe;
 275 }
 276
 277 #define doc_get_body(d) _doc_get_body(__LINE__,d)
 278 static IHTMLElement *_doc_get_body(unsigned line, IHTMLDocument2 *doc)
 279 {
 280     IHTMLElement *body = NULL;
 281     HRESULT hres;
 282
 283     hres = IHTMLDocument2_get_body(doc, &body);
 284     ok_(__FILE__,line) (hres == S_OK, "get_body failed: %08x\n", hres);
 285     ok_(__FILE__,line) (body != NULL, "body == NULL\n");
 286
 287     return body;
 288 }
 289
 290 #define get_elem_id(d,i) _get_elem_id(__LINE__,d,i)
 291 static IHTMLElement *_get_elem_id(unsigned line, IHTMLDocument2 *doc, const char *id)
 292 {
 293     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 294     IHTMLElement *elem;
 295     BSTR str;
 296     HRESULT hres;
 297
 298     str = a2bstr(id);
 299     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
 300     SysFreeString(str);
 301     IHTMLDocument3_Release(doc3);
 302     ok_(__FILE__,line) (hres == S_OK, "getElementById failed: %08x\n", hres);
 303     ok_(__FILE__,line) (elem != NULL, "elem == NULL\n");
 304
 305     return elem;
 306 }
 307
 308 #define test_elem_tag(u,n) _test_elem_tag(__LINE__,u,n)
 309 static void _test_elem_tag(unsigned line, IUnknown *unk, const char *extag)
 310 {
 311     IHTMLElement *elem = _get_elem_iface(line, unk);
 312     BSTR tag;
 313     HRESULT hres;
 314
 315     hres = IHTMLElement_get_tagName(elem, &tag);
 316     IHTMLElement_Release(elem);
 317     ok_(__FILE__, line) (hres == S_OK, "get_tagName failed: %08x\n", hres);
 318     ok_(__FILE__, line) (!strcmp_wa(tag, extag), "got tag: %s, expected %s\n", wine_dbgstr_w(tag), extag);
 319
 320     SysFreeString(tag);
 321 }
 322
 323 #define get_event_obj() _get_event_obj(__LINE__)
 324 static IHTMLEventObj *_get_event_obj(unsigned line)
 325 {
 326     IHTMLEventObj *event = NULL;
 327     HRESULT hres;
 328
 329     hres = IHTMLWindow2_get_event(window, &event);
 330     ok_(__FILE__,line) (hres == S_OK, "get_event failed: %08x\n", hres);
 331     ok_(__FILE__,line) (event != NULL, "event = NULL\n");
 332
 333     /* Native IE uses an undocumented DIID in IE9+ mode */
 334     _test_disp(line, (IUnknown*)event, document_mode < 9 ? &DIID_DispCEventObj : NULL);
 335
 336     return event;
 337 }
 338
 339 #define set_elem_innerhtml(e,t) _set_elem_innerhtml(__LINE__,e,t)
 340 static void _set_elem_innerhtml(unsigned line, IHTMLElement *elem, const char *inner_html)
 341 {
 342     BSTR html;
 343     HRESULT hres;
 344
 345     html = a2bstr(inner_html);
 346     hres = IHTMLElement_put_innerHTML(elem, html);
 347     ok_(__FILE__,line)(hres == S_OK, "put_innerHTML failed: %08x\n", hres);
 348     SysFreeString(html);
 349 }
 350
 351 #define elem_fire_event(a,b,c) _elem_fire_event(__LINE__,a,b,c)
 352 static void _elem_fire_event(unsigned line, IUnknown *unk, const char *event, VARIANT *evobj)
 353 {
 354     IHTMLElement3 *elem3 = _get_elem3_iface(line, unk);
 355     VARIANT_BOOL b;
 356     BSTR str;
 357     HRESULT hres;
 358
 359     b = 100;
 360     str = a2bstr(event);
 361     hres = IHTMLElement3_fireEvent(elem3, str, evobj, &b);
 362     SysFreeString(str);
 363     ok_(__FILE__,line)(hres == S_OK, "fireEvent failed: %08x\n", hres);
 364     ok_(__FILE__,line)(b == VARIANT_TRUE, "fireEvent returned %x\n", b);
 365 }
 366
 367 #define test_event_args(a,b,c,d,e,f,g) _test_event_args(__LINE__,a,b,c,d,e,f,g)
 368 static void _test_event_args(unsigned line, const IID *dispiid, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 369         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 370 {
 371     ok_(__FILE__,line) (id == DISPID_VALUE, "id = %d\n", id);
 372     ok_(__FILE__,line) (wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 373     ok_(__FILE__,line) (pdp != NULL, "pdp == NULL\n");
 374     todo_wine_if(document_mode >= 9)
 375     ok_(__FILE__,line) (pdp->cArgs == (document_mode < 9 ? 1 : 2), "pdp->cArgs = %d\n", pdp->cArgs);
 376     ok_(__FILE__,line) (pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 377     ok_(__FILE__,line) (pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n",
 378                         pdp->rgdispidNamedArgs[0]);
 379     ok_(__FILE__,line) (V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 380     if(pdp->cArgs > 1)
 381         ok_(__FILE__,line) (V_VT(pdp->rgvarg+1) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 382     ok_(__FILE__,line) (pvarRes != NULL, "pvarRes == NULL\n");
 383     ok_(__FILE__,line) (pei != NULL, "pei == NULL");
 384     ok_(__FILE__,line) (!pspCaller, "pspCaller != NULL\n");
 385
 386     if(dispiid)
 387         _test_disp(line, (IUnknown*)V_DISPATCH(pdp->rgvarg), dispiid);
 388 }
 389
 390 #define test_attached_event_args(a,b,c,d,e) _test_attached_event_args(__LINE__,a,b,c,d,e)
 391 static void _test_attached_event_args(unsigned line, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 392         VARIANT *pvarRes, EXCEPINFO *pei)
 393 {
 394     IHTMLEventObj *event;
 395
 396     ok(id == DISPID_VALUE, "id = %d\n", id);
 397     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 398     ok(pdp != NULL, "pDispParams == NULL\n");
 399     ok(pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 400     ok(!pdp->cNamedArgs, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 401     ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pdp->rgdispidNamedArgs);
 402     ok(pdp->rgvarg != NULL, "rgvarg = NULL\n");
 403     ok(pvarRes != NULL, "pvarRes = NULL\n");
 404     ok(pei != NULL, "pei = NULL\n");
 405     ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pVarRes) = %d\n", V_VT(pvarRes));
 406     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(pdp->rgvarg) = %d\n", V_VT(pdp->rgvarg));
 407     ok(V_DISPATCH(pdp->rgvarg) != NULL, "V_DISPATCH(pdp->rgvarg) = %p\n", V_DISPATCH(pdp->rgvarg));
 408
 409     event = _get_event_obj(line);
 410     todo_wine
 411     ok(!iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(pdp->rgvarg)), "event != arg0\n");
 412     IHTMLEventObj_Release(event);
 413 }
 414
 415 #define get_event_src() _get_event_src(__LINE__)
 416 static IHTMLElement *_get_event_src(unsigned line)
 417 {
 418     IHTMLEventObj *event = _get_event_obj(line);
 419     IHTMLElement *src_elem = NULL;
 420     HRESULT hres;
 421
 422     hres = IHTMLEventObj_get_srcElement(event, &src_elem);
 423     IHTMLEventObj_Release(event);
 424     ok_(__FILE__,line) (hres == S_OK, "get_srcElement failed: %08x\n", hres);
 425
 426     return src_elem;
 427 }
 428
 429 #define test_event_src(t) _test_event_src(__LINE__,t)
 430 static void _test_event_src(unsigned line, const char *src_tag)
 431 {
 432     IHTMLElement *src_elem = _get_event_src(line);
 433
 434     if(src_tag) {
 435         ok_(__FILE__,line) (src_elem != NULL, "src_elem = NULL\n");
 436         _test_elem_tag(line, (IUnknown*)src_elem, src_tag);
 437         IHTMLElement_Release(src_elem);
 438     }else {
 439         ok_(__FILE__,line) (!src_elem, "src_elem != NULL\n");
 440     }
 441 }
 442
 443 static void _test_event_altkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 444 {
 445     VARIANT_BOOL b;
 446     HRESULT hres;
 447
 448     hres = IHTMLEventObj_get_altKey(event, &b);
 449     ok_(__FILE__,line)(hres == S_OK, "get_altKey failed: %08x\n", hres);
 450     ok_(__FILE__,line)(b == exval, "altKey = %x, expected %x\n", b, exval);
 451 }
 452
 453 static void _test_event_ctrlkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 454 {
 455     VARIANT_BOOL b;
 456     HRESULT hres;
 457
 458     hres = IHTMLEventObj_get_ctrlKey(event, &b);
 459     ok_(__FILE__,line)(hres == S_OK, "get_ctrlKey failed: %08x\n", hres);
 460     ok_(__FILE__,line)(b == exval, "ctrlKey = %x, expected %x\n", b, exval);
 461 }
 462
 463 static void _test_event_shiftkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 464 {
 465     VARIANT_BOOL b;
 466     HRESULT hres;
 467
 468     hres = IHTMLEventObj_get_shiftKey(event, &b);
 469     ok_(__FILE__,line)(hres == S_OK, "get_shiftKey failed: %08x\n", hres);
 470     ok_(__FILE__,line)(b == exval, "shiftKey = %x, expected %x\n", b, exval);
 471 }
 472
 473 #define test_event_cancelbubble(a,b) _test_event_cancelbubble(__LINE__,a,b)
 474 static void _test_event_cancelbubble(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 475 {
 476     VARIANT_BOOL b;
 477     HRESULT hres;
 478
 479     hres = IHTMLEventObj_get_cancelBubble(event, &b);
 480     ok_(__FILE__,line)(hres == S_OK, "get_cancelBubble failed: %08x\n", hres);
 481     ok_(__FILE__,line)(b == exval, "cancelBubble = %x, expected %x\n", b, exval);
 482 }
 483
 484 static void _test_event_fromelem(unsigned line, IHTMLEventObj *event, const char *from_tag)
 485 {
 486     IHTMLElement *elem;
 487     HRESULT hres;
 488
 489     hres = IHTMLEventObj_get_fromElement(event, &elem);
 490     ok_(__FILE__,line)(hres == S_OK, "get_fromElement failed: %08x\n", hres);
 491     if(from_tag)
 492         _test_elem_tag(line, (IUnknown*)elem, from_tag);
 493     else
 494         ok_(__FILE__,line)(elem == NULL, "fromElement != NULL\n");
 495     if(elem)
 496         IHTMLElement_Release(elem);
 497 }
 498
 499 static void _test_event_toelem(unsigned line, IHTMLEventObj *event, const char *to_tag)
 500 {
 501     IHTMLElement *elem;
 502     HRESULT hres;
 503
 504     hres = IHTMLEventObj_get_toElement(event, &elem);
 505     ok_(__FILE__,line)(hres == S_OK, "get_toElement failed: %08x\n", hres);
 506     if(to_tag)
 507         _test_elem_tag(line, (IUnknown*)elem, to_tag);
 508     else
 509         ok_(__FILE__,line)(elem == NULL, "toElement != NULL\n");
 510     if(elem)
 511         IHTMLElement_Release(elem);
 512 }
 513
 514 static void _test_event_keycode(unsigned line, IHTMLEventObj *event, LONG exl)
 515 {
 516     LONG l;
 517     HRESULT hres;
 518
 519     hres = IHTMLEventObj_get_keyCode(event, &l);
 520     ok_(__FILE__,line)(hres == S_OK, "get_keyCode failed: %08x\n", hres);
 521     ok_(__FILE__,line)(l == exl, "keyCode = %x, expected %x\n", l, exl);
 522 }
 523
 524 static void _test_event_button(unsigned line, IHTMLEventObj *event, LONG exl)
 525 {
 526     LONG l;
 527     HRESULT hres;
 528
 529     hres = IHTMLEventObj_get_button(event, &l);
 530     ok_(__FILE__,line)(hres == S_OK, "get_button failed: %08x\n", hres);
 531     ok_(__FILE__,line)(l == exl, "button = %x, expected %x\n", l, exl);
 532 }
 533
 534 static void _test_event_reason(unsigned line, IHTMLEventObj *event, LONG exl)
 535 {
 536     LONG l;
 537     HRESULT hres;
 538
 539     hres = IHTMLEventObj_get_reason(event, &l);
 540     ok_(__FILE__,line)(hres == S_OK, "get_reason failed: %08x\n", hres);
 541     ok_(__FILE__,line)(l == exl, "reason = %x, expected %x\n", l, exl);
 542 }
 543
 544 static void _test_event_x(unsigned line, IHTMLEventObj *event, LONG exl)
 545 {
 546     LONG l;
 547     HRESULT hres;
 548
 549     hres = IHTMLEventObj_get_x(event, &l);
 550     ok_(__FILE__,line)(hres == S_OK, "get_x failed: %08x\n", hres);
 551     if(exl != -10) /* don't test the exact value */
 552         ok_(__FILE__,line)(l == exl, "x = %d, expected %d\n", l, exl);
 553 }
 554
 555 static void _test_event_y(unsigned line, IHTMLEventObj *event, LONG exl)
 556 {
 557     LONG l;
 558     HRESULT hres;
 559
 560     hres = IHTMLEventObj_get_y(event, &l);
 561     ok_(__FILE__,line)(hres == S_OK, "get_y failed: %08x\n", hres);
 562     if(exl != -10) /* don't test the exact value */
 563         ok_(__FILE__,line)(l == exl, "y = %d, expected %d\n", l, exl);
 564 }
 565
 566 static void _test_event_clientx(unsigned line, IHTMLEventObj *event, LONG exl)
 567 {
 568     LONG l;
 569     HRESULT hres;
 570
 571     hres = IHTMLEventObj_get_clientX(event, &l);
 572     ok_(__FILE__,line)(hres == S_OK, "get_clientX failed: %08x\n", hres);
 573     if(exl != -10) /* don't test the exact value */
 574         ok_(__FILE__,line)(l == exl, "clientX = %d, expected %d\n", l, exl);
 575 }
 576
 577 static void _test_event_clienty(unsigned line, IHTMLEventObj *event, LONG exl)
 578 {
 579     LONG l;
 580     HRESULT hres;
 581
 582     hres = IHTMLEventObj_get_clientY(event, &l);
 583     ok_(__FILE__,line)(hres == S_OK, "get_clientY failed: %08x\n", hres);
 584     if(exl != -10) /* don't test the exact value */
 585         ok_(__FILE__,line)(l == exl, "clientY = %d, expected %d\n", l, exl);
 586 }
 587
 588 static void _test_event_offsetx(unsigned line, IHTMLEventObj *event, LONG exl)
 589 {
 590     LONG l;
 591     HRESULT hres;
 592
 593     hres = IHTMLEventObj_get_offsetX(event, &l);
 594     ok_(__FILE__,line)(hres == S_OK, "get_offsetX failed: %08x\n", hres);
 595     if(exl != -10) /* don't test the exact value */
 596         ok_(__FILE__,line)(l == exl, "offsetX = %d, expected %d\n", l, exl);
 597 }
 598
 599 static void _test_event_offsety(unsigned line, IHTMLEventObj *event, LONG exl)
 600 {
 601     LONG l;
 602     HRESULT hres;
 603
 604     hres = IHTMLEventObj_get_offsetY(event, &l);
 605     ok_(__FILE__,line)(hres == S_OK, "get_offsetY failed: %08x\n", hres);
 606     if(exl != -10) /* don't test the exact value */
 607         ok_(__FILE__,line)(l == exl, "offsetY = %d, expected %d\n", l, exl);
 608 }
 609
 610 static void _test_event_screenx(unsigned line, IHTMLEventObj *event, LONG exl)
 611 {
 612     LONG l;
 613     HRESULT hres;
 614
 615     hres = IHTMLEventObj_get_screenX(event, &l);
 616     ok_(__FILE__,line)(hres == S_OK, "get_screenX failed: %08x\n", hres);
 617     if(exl != -10) /* don't test the exact value */
 618         ok_(__FILE__,line)(l == exl, "screenX = %d, expected %d\n", l, exl);
 619 }
 620
 621 static void _test_event_screeny(unsigned line, IHTMLEventObj *event, LONG exl)
 622 {
 623     LONG l;
 624     HRESULT hres;
 625
 626     hres = IHTMLEventObj_get_screenY(event, &l);
 627     ok_(__FILE__,line)(hres == S_OK, "get_screenY failed: %08x\n", hres);
 628     if(exl != -10) /* don't test the exact value for -10 */
 629         ok_(__FILE__,line)(l == exl, "screenY = %d, expected %d\n", l, exl);
 630 }
 631
 632 static void _test_event_type(unsigned line, IHTMLEventObj *event, const char *exstr)
 633 {
 634     BSTR str;
 635     HRESULT hres;
 636
 637     hres = IHTMLEventObj_get_type(event, &str);
 638     ok_(__FILE__,line)(hres == S_OK, "get_type failed: %08x\n", hres);
 639     ok_(__FILE__,line)(!strcmp_wa(str, exstr), "type = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 640 }
 641
 642 static void _test_event_qualifier(unsigned line, IHTMLEventObj *event, const char *exstr)
 643 {
 644     BSTR str;
 645     HRESULT hres;
 646
 647     hres = IHTMLEventObj_get_qualifier(event, &str);
 648     ok_(__FILE__,line)(hres == S_OK, "get_qualifier failed: %08x\n", hres);
 649     if(exstr)
 650         ok_(__FILE__,line)(!strcmp_wa(str, exstr), "qualifier = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 651     else
 652         ok_(__FILE__,line)(!str, "qualifier != NULL\n");
 653 }
 654
 655 static void _test_event_srcfilter(unsigned line, IHTMLEventObj *event)
 656 {
 657     IDispatch *disp;
 658     HRESULT hres;
 659
 660     hres = IHTMLEventObj_get_srcFilter(event, &disp);
 661     ok_(__FILE__,line)(hres == S_OK, "get_srcFilter failed: %08x\n", hres);
 662     ok_(__FILE__,line)(!disp, "srcFilter != NULL\n");
 663 }
 664
 665 #define test_event_obj(t,x) _test_event_obj(__LINE__,t,x)
 666 static void _test_event_obj(unsigned line, const char *type, const xy_test_t *xy)
 667 {
 668     IHTMLEventObj *event = _get_event_obj(line);
 669     VARIANT v;
 670     HRESULT hres;
 671
 672     _test_event_altkey(line, event, VARIANT_FALSE);
 673     _test_event_ctrlkey(line, event, VARIANT_FALSE);
 674     _test_event_shiftkey(line, event, VARIANT_FALSE);
 675     _test_event_cancelbubble(line, event, VARIANT_FALSE);
 676     _test_event_fromelem(line, event, NULL);
 677     _test_event_toelem(line, event, NULL);
 678     _test_event_keycode(line, event, 0);
 679     _test_event_button(line, event, 0);
 680     _test_event_type(line, event, type);
 681     _test_event_qualifier(line, event, NULL);
 682     _test_event_reason(line, event, 0);
 683     _test_event_srcfilter(line, event);
 684     _test_event_x(line, event, xy->x);
 685     _test_event_y(line, event, xy->y);
 686     _test_event_clientx(line, event, -10);
 687     _test_event_clienty(line, event, -10);
 688     _test_event_offsetx(line, event, xy->offset_x);
 689     _test_event_offsety(line, event, xy->offset_y);
 690     _test_event_screenx(line, event, -10);
 691     _test_event_screeny(line, event, -10);
 692
 693     V_VT(&v) = VT_NULL;
 694     hres = IHTMLEventObj_get_returnValue(event, &v);
 695     ok_(__FILE__,line)(hres == S_OK, "get_returnValue failed: %08x\n", hres);
 696     /* Depending on source of event, returnValue may be true bool in IE9+ mode */
 697     ok_(__FILE__,line)(V_VT(&v) == VT_EMPTY || (document_mode >= 9 && V_VT(&v) == VT_BOOL),
 698                        "V_VT(returnValue) = %d\n", V_VT(&v));
 699     if(V_VT(&v) == VT_BOOL)
 700         ok_(__FILE__,line)(V_BOOL(&v) == VARIANT_TRUE, "V_BOOL(returnValue) = %x\n", V_BOOL(&v));
 701
 702     IHTMLEventObj_Release(event);
 703 }
 704
 705 #define elem_attach_event(a,b,c) _elem_attach_event(__LINE__,a,b,c)
 706 static void _elem_attach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 707 {
 708     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 709     VARIANT_BOOL res;
 710     BSTR name;
 711     HRESULT hres;
 712
 713     name = a2bstr(namea);
 714     hres = IHTMLElement2_attachEvent(elem, name, disp, &res);
 715     IHTMLElement2_Release(elem);
 716     SysFreeString(name);
 717     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 718     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 719 }
 720
 721 #define elem_detach_event(a,b,c) _elem_detach_event(__LINE__,a,b,c)
 722 static void _elem_detach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 723 {
 724     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 725     BSTR name;
 726     HRESULT hres;
 727
 728     name = a2bstr(namea);
 729     hres = IHTMLElement2_detachEvent(elem, name, disp);
 730     IHTMLElement2_Release(elem);
 731     SysFreeString(name);
 732     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 733 }
 734
 735 #define doc_attach_event(a,b,c) _doc_attach_event(__LINE__,a,b,c)
 736 static void _doc_attach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 737 {
 738     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 739     VARIANT_BOOL res;
 740     BSTR name;
 741     HRESULT hres;
 742
 743     name = a2bstr(namea);
 744     hres = IHTMLDocument3_attachEvent(doc3, name, disp, &res);
 745     IHTMLDocument3_Release(doc3);
 746     SysFreeString(name);
 747     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 748     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 749 }
 750
 751 #define doc_detach_event(a,b,c) _doc_detach_event(__LINE__,a,b,c)
 752 static void _doc_detach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 753 {
 754     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 755     BSTR name;
 756     HRESULT hres;
 757
 758     name = a2bstr(namea);
 759     hres = IHTMLDocument3_detachEvent(doc3, name, disp);
 760     IHTMLDocument3_Release(doc3);
 761     SysFreeString(name);
 762     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 763 }
 764
 765 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 766 {
 767     if(IsEqualGUID(riid, &IID_IUnknown)
 768        || IsEqualGUID(riid, &IID_IDispatch)
 769        || IsEqualGUID(riid, &IID_IDispatchEx))
 770         *ppv = iface;
 771     else {
 772         *ppv = NULL;
 773         return E_NOINTERFACE;
 774     }
 775
 776     return S_OK;
 777 }
 778
 779 static HRESULT WINAPI Dispatch_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 780 {
 781      if(IsEqualGUID(riid, &IID_IUnknown)
 782        || IsEqualGUID(riid, &IID_IDispatch)) {
 783         *ppv = iface;
 784     }else {
 785         *ppv = NULL;
 786         return E_NOINTERFACE;
 787     }
 788
 789     return S_OK;
 790 }
 791
 792 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 793 {
 794     return 2;
 795 }
 796
 797 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 798 {
 799     return 1;
 800 }
 801
 802 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 803 {
 804     ok(0, "unexpected call\n");
 805     return E_NOTIMPL;
 806 }
 807
 808 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 809                                               LCID lcid, ITypeInfo **ppTInfo)
 810 {
 811     ok(0, "unexpected call\n");
 812     return E_NOTIMPL;
 813 }
 814
 815 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 816                                                 LPOLESTR *rgszNames, UINT cNames,
 817                                                 LCID lcid, DISPID *rgDispId)
 818 {
 819     ok(0, "unexpected call\n");
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 824                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 825                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 826 {
 827     ok(0, "unexpected call\n");
 828     return E_NOTIMPL;
 829 }
 830
 831 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 832 {
 833     ok(0, "unexpected call\n");
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 838         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 839 {
 840     ok(0, "unexpected call\n");
 841     return E_NOTIMPL;
 842 }
 843
 844 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 845 {
 846     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 847     return E_NOTIMPL;
 848 }
 849
 850 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 851 {
 852     ok(0, "unexpected call\n");
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 857 {
 858     ok(0, "unexpected call\n");
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 863 {
 864     ok(0, "unexpected call\n");
 865     return E_NOTIMPL;
 866 }
 867
 868 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 869 {
 870     ok(0, "unexpected call\n");
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 875 {
 876     ok(0, "unexpected call\n");
 877     return E_NOTIMPL;
 878 }
 879
 880 #define EVENT_HANDLER_FUNC_OBJ(event) \
 881     static IDispatchExVtbl event ## FuncVtbl = { \
 882         DispatchEx_QueryInterface, \
 883         DispatchEx_AddRef, \
 884         DispatchEx_Release, \
 885         DispatchEx_GetTypeInfoCount, \
 886         DispatchEx_GetTypeInfo, \
 887         DispatchEx_GetIDsOfNames, \
 888         DispatchEx_Invoke, \
 889         DispatchEx_GetDispID, \
 890         event, \
 891         DispatchEx_DeleteMemberByName, \
 892         DispatchEx_DeleteMemberByDispID, \
 893         DispatchEx_GetMemberProperties, \
 894         DispatchEx_GetMemberName, \
 895         DispatchEx_GetNextDispID, \
 896         DispatchEx_GetNameSpaceParent \
 897     }; \
 898     static IDispatchEx event ## _obj = { &event ## FuncVtbl };
 899
 900 static HRESULT WINAPI document_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 901         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 902 {
 903     IHTMLDocument3 *doc3;
 904     CHECK_EXPECT(document_onclick);
 905     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 906     doc3 = get_doc3_iface((IUnknown*)V_DISPATCH(pdp->rgvarg));
 907     IHTMLDocument3_Release(doc3);
 908     test_event_src("DIV");
 909     test_event_obj("click", &no_xy);
 910     return S_OK;
 911 }
 912
 913 EVENT_HANDLER_FUNC_OBJ(document_onclick);
 914
 915 static HRESULT WINAPI div_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 916         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 917 {
 918     CHECK_EXPECT(div_onclick);
 919     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 920     test_event_src("DIV");
 921     test_event_obj("click", &no_xy);
 922     return S_OK;
 923 }
 924
 925 EVENT_HANDLER_FUNC_OBJ(div_onclick);
 926
 927 static HRESULT WINAPI div_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 928         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 929 {
 930     CHECK_EXPECT(div_onclick_attached);
 931
 932     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 933     test_event_src("DIV");
 934     return S_OK;
 935 }
 936
 937 EVENT_HANDLER_FUNC_OBJ(div_onclick_attached);
 938
 939 static HRESULT WINAPI doc_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 940         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 941 {
 942     CHECK_EXPECT(doc_onclick_attached);
 943
 944     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 945     test_event_src("DIV");
 946     return S_OK;
 947 }
 948
 949 EVENT_HANDLER_FUNC_OBJ(doc_onclick_attached);
 950
 951 static HRESULT WINAPI body_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 952         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 953 {
 954     CHECK_EXPECT(body_onclick);
 955     /* Native IE returns undocumented DIID in IE9+ mode */
 956     test_event_args(document_mode < 9 ? &DIID_DispHTMLBody : NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 957     test_event_src("DIV");
 958     return S_OK;
 959 }
 960
 961 EVENT_HANDLER_FUNC_OBJ(body_onclick);
 962
 963 static HRESULT WINAPI img_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 964         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 965 {
 966     CHECK_EXPECT(img_onload);
 967     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 968     test_event_src("IMG");
 969     return S_OK;
 970 }
 971
 972 EVENT_HANDLER_FUNC_OBJ(img_onload);
 973
 974 static HRESULT WINAPI link_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 975         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 976 {
 977     CHECK_EXPECT(link_onload);
 978     test_event_args(&DIID_DispHTMLLinkElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
 979     test_event_src("LINK");
 980     return S_OK;
 981 }
 982
 983 EVENT_HANDLER_FUNC_OBJ(link_onload);
 984
 985 static HRESULT WINAPI unattached_img_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 986         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 987 {
 988     IHTMLElement *event_src;
 989
 990     CHECK_EXPECT(img_onload);
 991
 992     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 993     event_src = get_event_src();
 994     todo_wine
 995         ok(!event_src, "event_src != NULL\n");
 996     if(event_src)
 997         IHTMLElement_Release(event_src);
 998     return S_OK;
 999 }
1000
1001 EVENT_HANDLER_FUNC_OBJ(unattached_img_onload);
1002
1003 static HRESULT WINAPI img_onerror(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1004         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1005 {
1006     CHECK_EXPECT(img_onerror);
1007     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
1008     test_event_src("IMG");
1009     return S_OK;
1010 }
1011
1012 EVENT_HANDLER_FUNC_OBJ(img_onerror);
1013
1014 static HRESULT WINAPI input_onfocus(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1015         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1016 {
1017     CHECK_EXPECT(input_onfocus);
1018     test_event_args(&DIID_DispHTMLInputElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
1019     test_event_src("INPUT");
1020     return S_OK;
1021 }
1022
1023 EVENT_HANDLER_FUNC_OBJ(input_onfocus);
1024
1025 static HRESULT WINAPI div_onfocusin(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1026         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1027 {
1028     CHECK_EXPECT(div_onfocusin);
1029     test_event_args(NULL /* FIXME: &DIID_DispHTMLDivElement */, id, wFlags, pdp, pvarRes, pei, pspCaller);
1030     test_event_src("INPUT");
1031     return S_OK;
1032 }
1033
1034 EVENT_HANDLER_FUNC_OBJ(div_onfocusin);
1035
1036 static HRESULT WINAPI div_onfocusout(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1037         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1038 {
1039     CHECK_EXPECT(div_onfocusout);
1040     test_event_args(NULL /* FIXME: &DIID_DispHTMLDivElement */, id, wFlags, pdp, pvarRes, pei, pspCaller);
1041     test_event_src("INPUT");
1042     return S_OK;
1043 }
1044
1045 EVENT_HANDLER_FUNC_OBJ(div_onfocusout);
1046
1047 static HRESULT WINAPI input_onblur(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1048         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1049 {
1050     CHECK_EXPECT(input_onblur);
1051     test_event_args(&DIID_DispHTMLInputElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
1052     test_event_src("INPUT");
1053     return S_OK;
1054 }
1055
1056 EVENT_HANDLER_FUNC_OBJ(input_onblur);
1057
1058 static HRESULT WINAPI form_onsubmit(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1059         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1060 {
1061     CHECK_EXPECT(form_onsubmit);
1062     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1063     test_event_src("FORM");
1064
1065     V_VT(pvarRes) = VT_BOOL;
1066     V_BOOL(pvarRes) = VARIANT_FALSE;
1067     return S_OK;
1068 }
1069
1070 EVENT_HANDLER_FUNC_OBJ(form_onsubmit);
1071
1072 static HRESULT WINAPI form_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1073         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1074 {
1075     CHECK_EXPECT(form_onclick);
1076     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1077
1078     return S_OK;
1079 }
1080
1081 EVENT_HANDLER_FUNC_OBJ(form_onclick);
1082
1083 static HRESULT WINAPI submit_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1084         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1085 {
1086     CHECK_EXPECT(submit_onclick);
1087     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1088     test_event_src("INPUT");
1089
1090     V_VT(pvarRes) = VT_BOOL;
1091     V_BOOL(pvarRes) = VARIANT_FALSE;
1092     return S_OK;
1093 }
1094
1095 EVENT_HANDLER_FUNC_OBJ(submit_onclick);
1096
1097 static HRESULT WINAPI iframe_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1098         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1099 {
1100     CHECK_EXPECT(iframe_onload);
1101     test_event_args(&DIID_DispHTMLIFrame, id, wFlags, pdp, pvarRes, pei, pspCaller);
1102     test_event_src("IFRAME");
1103     return S_OK;
1104 }
1105
1106 EVENT_HANDLER_FUNC_OBJ(iframe_onload);
1107
1108 static HRESULT WINAPI submit_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1109         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1110 {
1111     CHECK_EXPECT(submit_onclick_attached);
1112     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1113     test_event_src("INPUT");
1114
1115     V_VT(pvarRes) = VT_BOOL;
1116     V_BOOL(pvarRes) = VARIANT_FALSE;
1117     return S_OK;
1118 }
1119
1120 EVENT_HANDLER_FUNC_OBJ(submit_onclick_attached);
1121
1122 static HRESULT WINAPI submit_onclick_attached_check_cancel(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1123         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1124 {
1125     IHTMLEventObj *event;
1126     HRESULT hres;
1127
1128     CHECK_EXPECT(submit_onclick_attached_check_cancel);
1129     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1130     test_event_src("INPUT");
1131
1132     event = NULL;
1133     hres = IHTMLWindow2_get_event(window, &event);
1134     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1135     ok(event != NULL, "event == NULL\n");
1136
1137     test_event_cancelbubble(event, VARIANT_TRUE);
1138     return S_OK;
1139 }
1140
1141 EVENT_HANDLER_FUNC_OBJ(submit_onclick_attached_check_cancel);
1142
1143 static VARIANT onclick_retval, onclick_event_retval;
1144
1145 static HRESULT WINAPI submit_onclick_setret(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1146         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1147 {
1148     IHTMLEventObj *event;
1149     VARIANT v;
1150     HRESULT hres;
1151
1152     CHECK_EXPECT(submit_onclick_setret);
1153     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1154     test_event_src("INPUT");
1155
1156     event = NULL;
1157     hres = IHTMLWindow2_get_event(window, &event);
1158     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1159     ok(event != NULL, "event == NULL\n");
1160
1161     V_VT(&v) = VT_ERROR;
1162     hres = IHTMLEventObj_get_returnValue(event, &v);
1163     ok(hres == S_OK, "get_returnValue failed: %08x\n", hres);
1164     if(document_mode < 9) {
1165         ok(V_VT(&v) == VT_EMPTY, "V_VT(returnValue) = %d\n", V_VT(&v));
1166     }else todo_wine {
1167         ok(V_VT(&v) == VT_BOOL, "V_VT(returnValue) = %d\n", V_VT(&v));
1168         ok(V_BOOL(&v) == VARIANT_TRUE, "V_BOOL(returnValue) = %x\n", V_BOOL(&v));
1169     }
1170
1171     hres = IHTMLEventObj_put_returnValue(event, onclick_event_retval);
1172     ok(hres == S_OK, "put_returnValue failed: %08x\n", hres);
1173
1174     V_VT(&v) = VT_ERROR;
1175     hres = IHTMLEventObj_get_returnValue(event, &v);
1176     ok(hres == S_OK, "get_returnValue failed: %08x\n", hres);
1177     ok(VarCmp(&v, &onclick_event_retval, 0, 0) == VARCMP_EQ, "unexpected returnValue\n");
1178
1179     IHTMLEventObj_Release(event);
1180     *pvarRes = onclick_retval;
1181     return S_OK;
1182 }
1183
1184 EVENT_HANDLER_FUNC_OBJ(submit_onclick_setret);
1185
1186 static HRESULT WINAPI submit_onclick_cancel(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1187         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1188 {
1189     IHTMLEventObj *event;
1190     HRESULT hres;
1191
1192     CHECK_EXPECT(submit_onclick_cancel);
1193     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1194     test_event_src("INPUT");
1195
1196     event = NULL;
1197     hres = IHTMLWindow2_get_event(window, &event);
1198     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1199     ok(event != NULL, "event == NULL\n");
1200
1201     test_event_cancelbubble(event, VARIANT_FALSE);
1202
1203     hres = IHTMLEventObj_put_cancelBubble(event, VARIANT_TRUE);
1204     ok(hres == S_OK, "put_returnValue failed: %08x\n", hres);
1205
1206     test_event_cancelbubble(event, VARIANT_TRUE);
1207     IHTMLEventObj_Release(event);
1208     return S_OK;
1209 }
1210
1211 EVENT_HANDLER_FUNC_OBJ(submit_onclick_cancel);
1212
1213 static HRESULT WINAPI iframedoc_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1214         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1215 {
1216     IHTMLEventObj *event = NULL;
1217     HRESULT hres;
1218
1219     CHECK_EXPECT2(iframedoc_onreadystatechange);
1220     test_event_args(document_mode < 9 ? &DIID_DispHTMLDocument : NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1221
1222     event = (void*)0xdeadbeef;
1223     hres = IHTMLWindow2_get_event(window, &event);
1224     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1225     ok(!event, "event = %p\n", event);
1226
1227     return S_OK;
1228 }
1229
1230 EVENT_HANDLER_FUNC_OBJ(iframedoc_onreadystatechange);
1231
1232 static HRESULT WINAPI iframe_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1233         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1234 {
1235     IHTMLWindow2 *iframe_window;
1236     IHTMLDocument2 *iframe_doc;
1237     IHTMLFrameBase2 *iframe;
1238     IHTMLElement2 *elem2;
1239     IHTMLElement *elem;
1240     VARIANT v;
1241     BSTR str, str2;
1242     HRESULT hres;
1243
1244     test_event_args(document_mode < 9 ? &DIID_DispHTMLIFrame : NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1245     test_event_src("IFRAME");
1246
1247     elem = get_event_src();
1248     elem2 = get_elem2_iface((IUnknown*)elem);
1249     IHTMLElement_Release(elem);
1250
1251     V_VT(&v) = VT_EMPTY;
1252     hres = IHTMLElement2_get_readyState(elem2, &v);
1253     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1254     ok(V_VT(&v) == VT_BSTR, "V_VT(readyState) = %d\n", V_VT(&v));
1255
1256     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase2, (void**)&iframe);
1257     IHTMLElement2_Release(elem2);
1258     ok(hres == S_OK, "Could not get IHTMLFrameBase2 iface: %08x\n", hres);
1259
1260     str = NULL;
1261     hres = IHTMLFrameBase2_get_readyState(iframe, &str);
1262     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1263     ok(str != NULL, "readyState == NULL\n");
1264     ok(!lstrcmpW(str, V_BSTR(&v)), "ready states differ\n");
1265     VariantClear(&v);
1266
1267     hres = IHTMLFrameBase2_get_contentWindow(iframe, &iframe_window);
1268     ok(hres == S_OK, "get_contentDocument failed: %08x\n", hres);
1269
1270     hres = IHTMLWindow2_get_document(iframe_window, &iframe_doc);
1271     IHTMLWindow2_Release(iframe_window);
1272     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1273
1274     hres = IHTMLDocument2_get_readyState(iframe_doc, &str2);
1275     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1276     ok(!lstrcmpW(str, str2), "unexpected document readyState %s\n", wine_dbgstr_w(str2));
1277     SysFreeString(str2);
1278
1279     if(!strcmp_wa(str, "loading")) {
1280         CHECK_EXPECT(iframe_onreadystatechange_loading);
1281
1282         V_VT(&v) = VT_DISPATCH;
1283         V_DISPATCH(&v) = (IDispatch*)&iframedoc_onreadystatechange_obj;
1284         hres = IHTMLDocument2_put_onreadystatechange(iframe_doc, v);
1285         ok(hres == S_OK, "put_onreadystatechange: %08x\n", hres);
1286     }else if(!strcmp_wa(str, "interactive"))
1287         CHECK_EXPECT(iframe_onreadystatechange_interactive);
1288     else if(!strcmp_wa(str, "complete"))
1289         CHECK_EXPECT(iframe_onreadystatechange_complete);
1290     else
1291         ok(0, "unexpected state %s\n", wine_dbgstr_w(str));
1292
1293     SysFreeString(str);
1294     IHTMLDocument2_Release(iframe_doc);
1295     IHTMLFrameBase2_Release(iframe);
1296     return S_OK;
1297 }
1298
1299 EVENT_HANDLER_FUNC_OBJ(iframe_onreadystatechange);
1300
1301 static HRESULT WINAPI nocall(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1302         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1303 {
1304     ok(0, "unexpected call\n");
1305     return S_OK;
1306 }
1307
1308 EVENT_HANDLER_FUNC_OBJ(nocall);
1309
1310 #define CONNECTION_POINT_OBJ(cpname, diid) \
1311     static HRESULT WINAPI cpname ## _QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) \
1312     { \
1313         *ppv = NULL; \
1314         if(IsEqualGUID(riid, &IID_IUnknown) \
1315            || IsEqualGUID(riid, &IID_IDispatch) \
1316            || IsEqualGUID(riid, &diid)) \
1317             *ppv = iface; \
1318         else { \
1319             ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid)); \
1320             return E_NOINTERFACE; \
1321         } \
1322         return S_OK; \
1323     } \
1324     static IDispatchExVtbl cpname ## Vtbl = { \
1325         cpname ## _QueryInterface, \
1326         DispatchEx_AddRef,  \
1327         DispatchEx_Release, \
1328         DispatchEx_GetTypeInfoCount, \
1329         DispatchEx_GetTypeInfo, \
1330         DispatchEx_GetIDsOfNames, \
1331         cpname, \
1332         DispatchEx_GetDispID, \
1333         DispatchEx_InvokeEx, \
1334         DispatchEx_DeleteMemberByName, \
1335         DispatchEx_DeleteMemberByDispID, \
1336         DispatchEx_GetMemberProperties, \
1337         DispatchEx_GetMemberName, \
1338         DispatchEx_GetNextDispID, \
1339         DispatchEx_GetNameSpaceParent \
1340     }; \
1341     static IDispatchEx cpname ## _obj = { &cpname ## Vtbl }
1342
1343 #define test_cp_args(a,b,c,d,e,f) _test_cp_args(__LINE__,a,b,c,d,e,f)
1344 static void _test_cp_args(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
1345 {
1346     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1347     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
1348     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
1349     ok_(__FILE__,line)(!dp->cArgs, "dp->cArgs = %d\n", dp->cArgs);
1350     ok_(__FILE__,line)(!dp->rgvarg, "dp->rgvarg = %p\n", dp->rgvarg);
1351     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
1352     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
1353     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
1354     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
1355     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
1356     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
1357 }
1358
1359 #define test_cp_eventarg(a,b,c,d,e,f) _test_cp_eventarg(__LINE__,a,b,c,d,e,f)
1360 static void _test_cp_eventarg(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
1361 {
1362     IHTMLEventObj *event;
1363
1364     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1365     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
1366     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
1367     ok_(__FILE__,line)(dp->cArgs == 1, "dp->cArgs = %d\n", dp->cArgs);
1368     ok_(__FILE__,line)(dp->rgvarg != NULL, "dp->rgvarg = %p\n", dp->rgvarg);
1369     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
1370     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
1371     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
1372     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
1373     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
1374     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
1375
1376     ok(V_VT(dp->rgvarg) == VT_DISPATCH, "V_VT(dp->rgvarg) = %d\n", V_VT(dp->rgvarg));
1377     ok(V_DISPATCH(dp->rgvarg) != NULL, "V_DISPATCH(dp->rgvarg) = %p\n", V_DISPATCH(dp->rgvarg));
1378
1379     event = _get_event_obj(line);
1380     todo_wine
1381     ok(!iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(dp->rgvarg)), "event != arg0\n");
1382     IHTMLEventObj_Release(event);
1383 }
1384
1385 static HRESULT WINAPI doccp(IDispatchEx *iface, DISPID dispIdMember,
1386                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1387                             VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1388 {
1389     switch(dispIdMember) {
1390     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1391         CHECK_EXPECT(doccp_onclick);
1392         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1393         break;
1394     default:
1395         ok(0, "unexpected call %d\n", dispIdMember);
1396         return E_NOTIMPL;
1397     }
1398
1399     return S_OK;
1400 }
1401
1402 CONNECTION_POINT_OBJ(doccp, DIID_HTMLDocumentEvents);
1403
1404 static HRESULT WINAPI doccp_onclick_cancel(IDispatchEx *iface, DISPID dispIdMember,
1405         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1406 {
1407     switch(dispIdMember) {
1408     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1409         CHECK_EXPECT(doccp_onclick_cancel);
1410         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1411         V_VT(pVarResult) = VT_BOOL;
1412         V_BOOL(pVarResult) = VARIANT_FALSE;
1413         break;
1414     default:
1415         ok(0, "unexpected call %d\n", dispIdMember);
1416         return E_NOTIMPL;
1417     }
1418
1419     return S_OK;
1420 }
1421
1422 CONNECTION_POINT_OBJ(doccp_onclick_cancel, DIID_HTMLDocumentEvents);
1423
1424 static HRESULT WINAPI elem2_cp(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1425         WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1426 {
1427     switch(dispIdMember) {
1428     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1429         CHECK_EXPECT(elem2_cp_onclick);
1430         test_cp_eventarg(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1431         break;
1432     default:
1433         ok(0, "unexpected call %d\n", dispIdMember);
1434         return E_NOTIMPL;
1435     }
1436
1437     return S_OK;
1438 }
1439
1440 CONNECTION_POINT_OBJ(elem2_cp, DIID_HTMLElementEvents2);
1441
1442 static HRESULT WINAPI timeoutFunc_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1443                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1444                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1445 {
1446     CHECK_EXPECT(timeout);
1447
1448     ok(dispIdMember == DISPID_VALUE, "dispIdMember = %d\n", dispIdMember);
1449     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1450     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
1451     ok(!lcid, "lcid = %x\n", lcid);
1452     ok(pDispParams != NULL, "pDispParams == NULL\n");
1453     ok(!pDispParams->cArgs, "pdp->cArgs = %d\n", pDispParams->cArgs);
1454     ok(!pDispParams->cNamedArgs, "pdp->cNamedArgs = %d\n", pDispParams->cNamedArgs);
1455     ok(!pDispParams->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
1456     ok(!pDispParams->rgvarg, "rgvarg = %p\n", pDispParams->rgvarg);
1457     ok(pVarResult != NULL, "pVarResult = NULL\n");
1458     ok(pExcepInfo != NULL, "pExcepInfo = NULL\n");
1459     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1460     ok(V_VT(pVarResult) == VT_EMPTY, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1461
1462     return S_OK;
1463 }
1464
1465 static const IDispatchExVtbl timeoutFuncVtbl = {
1466     DispatchEx_QueryInterface,
1467     DispatchEx_AddRef,
1468     DispatchEx_Release,
1469     DispatchEx_GetTypeInfoCount,
1470     DispatchEx_GetTypeInfo,
1471     DispatchEx_GetIDsOfNames,
1472     timeoutFunc_Invoke,
1473     DispatchEx_GetDispID,
1474     DispatchEx_InvokeEx,
1475     DispatchEx_DeleteMemberByName,
1476     DispatchEx_DeleteMemberByDispID,
1477     DispatchEx_GetMemberProperties,
1478     DispatchEx_GetMemberName,
1479     DispatchEx_GetNextDispID,
1480     DispatchEx_GetNameSpaceParent
1481 };
1482
1483 static IDispatchEx timeoutFunc = { &timeoutFuncVtbl };
1484
1485 static HRESULT WINAPI timeoutFunc2_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1486         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1487         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1488 {
1489     ok(0, "unexpected call\n");
1490     return E_FAIL;
1491 }
1492
1493 static const IDispatchExVtbl timeoutFunc2Vtbl = {
1494     DispatchEx_QueryInterface,
1495     DispatchEx_AddRef,
1496     DispatchEx_Release,
1497     DispatchEx_GetTypeInfoCount,
1498     DispatchEx_GetTypeInfo,
1499     DispatchEx_GetIDsOfNames,
1500     timeoutFunc2_Invoke,
1501     DispatchEx_GetDispID,
1502     DispatchEx_InvokeEx,
1503     DispatchEx_DeleteMemberByName,
1504     DispatchEx_DeleteMemberByDispID,
1505     DispatchEx_GetMemberProperties,
1506     DispatchEx_GetMemberName,
1507     DispatchEx_GetNextDispID,
1508     DispatchEx_GetNameSpaceParent
1509 };
1510
1511 static IDispatchEx timeoutFunc2 = { &timeoutFunc2Vtbl };
1512
1513 static HRESULT WINAPI div_onclick_disp_Invoke(IDispatchEx *iface, DISPID id,
1514         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1515         VARIANT *pvarRes, EXCEPINFO *pei, UINT *puArgErr)
1516 {
1517     CHECK_EXPECT(div_onclick_disp);
1518
1519     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1520
1521     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1522     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1523
1524     return S_OK;
1525 }
1526
1527 static const IDispatchExVtbl div_onclick_dispVtbl = {
1528     Dispatch_QueryInterface,
1529     DispatchEx_AddRef,
1530     DispatchEx_Release,
1531     DispatchEx_GetTypeInfoCount,
1532     DispatchEx_GetTypeInfo,
1533     DispatchEx_GetIDsOfNames,
1534     div_onclick_disp_Invoke,
1535 };
1536
1537 static IDispatchEx div_onclick_disp = { &div_onclick_dispVtbl };
1538
1539 static void pump_msgs(BOOL *b)
1540 {
1541     MSG msg;
1542
1543     if(b) {
1544         while(!*b && GetMessageW(&msg, NULL, 0, 0)) {
1545             TranslateMessage(&msg);
1546             DispatchMessageW(&msg);
1547         }
1548     }else {
1549         while(PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) {
1550             TranslateMessage(&msg);
1551             DispatchMessageW(&msg);
1552         }
1553     }
1554 }
1555
1556 static IConnectionPoint *get_cp(IUnknown *unk, REFIID riid)
1557 {
1558     IConnectionPointContainer *cp_container;
1559     IConnectionPoint *cp;
1560     HRESULT hres;
1561
1562     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&cp_container);
1563     ok(hres == S_OK, "Could not get IConnectionPointContainer: %08x\n", hres);
1564
1565     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, riid, &cp);
1566     IConnectionPointContainer_Release(cp_container);
1567     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1568
1569     return cp;
1570 }
1571
1572 static DWORD register_cp(IUnknown *unk, REFIID riid, IUnknown *sink)
1573 {
1574     IConnectionPoint *cp;
1575     DWORD cookie;
1576     HRESULT hres;
1577
1578     cp = get_cp(unk, riid);
1579     hres = IConnectionPoint_Advise(cp, sink, &cookie);
1580     IConnectionPoint_Release(cp);
1581     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1582
1583     return cookie;
1584 }
1585
1586 static void unregister_cp(IUnknown *unk, REFIID riid, DWORD cookie)
1587 {
1588     IConnectionPoint *cp;
1589     HRESULT hres;
1590
1591     cp = get_cp(unk, riid);
1592     hres = IConnectionPoint_Unadvise(cp, cookie);
1593     IConnectionPoint_Release(cp);
1594     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
1595 }
1596
1597 static HRESULT WINAPI EventDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1598 {
1599     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
1600         *ppv = iface;
1601         return S_OK;
1602     }
1603
1604     ok(0, "Unexpected call\n");
1605     return E_NOINTERFACE;
1606 }
1607
1608 static DWORD WINAPI EventDispatch_AddRef(IDispatch *iface)
1609 {
1610     return 2;
1611 }
1612
1613 static DWORD WINAPI EventDispatch_Release(IDispatch *iface)
1614 {
1615     return 1;
1616 }
1617
1618 static HRESULT WINAPI EventDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1619 {
1620     ok(0, "Unexpected call\n");
1621     return E_NOTIMPL;
1622 }
1623
1624 static HRESULT WINAPI EventDispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1625 {
1626     ok(0, "Unexpected call\n");
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI EventDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
1631         UINT cNames, LCID lcid, DISPID *rgDispId)
1632 {
1633     ok(0, "Unexpected call\n");
1634     return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI EventDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1638         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1639         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1640 {
1641     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1642     ok(pDispParams != NULL, "pDispParams == NULL\n");
1643     ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
1644     ok(puArgErr != NULL, "puArgErr == NULL\n");
1645     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1646     ok(wFlags == DISPATCH_METHOD, "wFlags = %d\n", wFlags);
1647
1648     switch(dispIdMember) {
1649     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1650         CHECK_EXPECT2(invoke_onclick);
1651         break;
1652     case DISPID_HTMLDOCUMENTEVENTS2_ONPROPERTYCHANGE:
1653     case DISPID_HTMLDOCUMENTEVENTS2_ONREADYSTATECHANGE:
1654     case 1027:
1655     case 1034:
1656     case 1037:
1657     case 1044:
1658     case 1045:
1659     case 1047:
1660     case 1048:
1661     case 1049:
1662         break; /* TODO */
1663     default:
1664         ok(0, "Unexpected call: %d\n", dispIdMember);
1665     }
1666
1667     return S_OK;
1668 }
1669
1670 static const IDispatchVtbl EventDispatchVtbl = {
1671     EventDispatch_QueryInterface,
1672     EventDispatch_AddRef,
1673     EventDispatch_Release,
1674     EventDispatch_GetTypeInfoCount,
1675     EventDispatch_GetTypeInfo,
1676     EventDispatch_GetIDsOfNames,
1677     EventDispatch_Invoke
1678 };
1679
1680 static IDispatch EventDispatch = { &EventDispatchVtbl };
1681
1682 static void set_body_html(IHTMLDocument2 *doc, const char *html)
1683 {
1684     IHTMLElement *body = doc_get_body(doc);
1685     set_elem_innerhtml(body, html);
1686     IHTMLElement_Release(body);
1687 }
1688
1689 static void test_onclick(IHTMLDocument2 *doc)
1690 {
1691     DWORD cp_cookie, elem2_cp_cookie;
1692     IHTMLElement *div, *body;
1693     VARIANT v;
1694     HRESULT hres;
1695
1696     trace("onclick tests in document mode %d\n", document_mode);
1697
1698     set_body_html(doc, "<div id=\"clickdiv\""
1699                        " style=\"text-align: center; background: red; font-size: 32\">"
1700                        "click here"
1701                        "</div>");
1702
1703     register_cp((IUnknown*)doc, &IID_IDispatch, (IUnknown*)&EventDispatch);
1704
1705     div = get_elem_id(doc, "clickdiv");
1706
1707     elem_attach_event((IUnknown*)div, "abcde", (IDispatch*)&nocall_obj);
1708     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_attached_obj);
1709
1710     V_VT(&v) = VT_EMPTY;
1711     hres = IHTMLElement_get_onclick(div, &v);
1712     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1713     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1714
1715     V_VT(&v) = VT_EMPTY;
1716     hres = IHTMLElement_put_onclick(div, v);
1717     ok(hres == (document_mode < 9 ? E_NOTIMPL : S_OK), "put_onclick failed: %08x\n", hres);
1718
1719     V_VT(&v) = VT_EMPTY;
1720     hres = IHTMLElement_get_onclick(div, &v);
1721     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1722     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1723
1724     V_VT(&v) = VT_BSTR;
1725     V_BSTR(&v) = a2bstr("function();");
1726     hres = IHTMLElement_put_onclick(div, v);
1727     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1728     SysFreeString(V_BSTR(&v));
1729
1730     V_VT(&v) = VT_EMPTY;
1731     hres = IHTMLElement_get_onclick(div, &v);
1732     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1733     if(document_mode < 9) {
1734         ok(V_VT(&v) == VT_BSTR, "V_VT(onclick) = %d\n", V_VT(&v));
1735         ok(!strcmp_wa(V_BSTR(&v), "function();"), "V_BSTR(onclick) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1736     }else {
1737         todo_wine
1738         ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1739     }
1740     VariantClear(&v);
1741
1742     V_VT(&v) = VT_DISPATCH;
1743     V_DISPATCH(&v) = (IDispatch*)&div_onclick_obj;
1744     hres = IHTMLElement_put_onclick(div, v);
1745     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1746
1747     V_VT(&v) = VT_NULL;
1748     hres = IHTMLElement_put_ondblclick(div, v);
1749     ok(hres == S_OK, "put_ondblclick failed: %08x\n", hres);
1750
1751     V_VT(&v) = VT_EMPTY;
1752     hres = IHTMLElement_get_onclick(div, &v);
1753     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1754     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1755     ok(V_DISPATCH(&v) == (IDispatch*)&div_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1756     VariantClear(&v);
1757
1758     V_VT(&v) = VT_EMPTY;
1759     hres = IHTMLDocument2_get_onclick(doc, &v);
1760     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1761     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1762
1763     V_VT(&v) = VT_DISPATCH;
1764     V_DISPATCH(&v) = (IDispatch*)&document_onclick_obj;
1765     hres = IHTMLDocument2_put_onclick(doc, v);
1766     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1767
1768     V_VT(&v) = VT_EMPTY;
1769     hres = IHTMLDocument2_get_onclick(doc, &v);
1770     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1771     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1772     ok(V_DISPATCH(&v) == (IDispatch*)&document_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1773     VariantClear(&v);
1774
1775     body = doc_get_body(doc);
1776
1777     V_VT(&v) = VT_DISPATCH;
1778     V_DISPATCH(&v) = (IDispatch*)&body_onclick_obj;
1779     hres = IHTMLElement_put_onclick(body, v);
1780     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1781
1782     if(winetest_interactive) {
1783         SET_EXPECT(div_onclick);
1784         SET_EXPECT(div_onclick_attached);
1785         SET_EXPECT(body_onclick);
1786         SET_EXPECT(document_onclick);
1787         SET_EXPECT(invoke_onclick);
1788         pump_msgs(&called_document_onclick);
1789         CHECK_CALLED(div_onclick);
1790         CHECK_CALLED(div_onclick_attached);
1791         CHECK_CALLED(body_onclick);
1792         CHECK_CALLED(document_onclick);
1793         CHECK_CALLED(invoke_onclick);
1794     }
1795
1796     SET_EXPECT(div_onclick);
1797     SET_EXPECT(div_onclick_attached);
1798     SET_EXPECT(body_onclick);
1799     SET_EXPECT(document_onclick);
1800     SET_EXPECT(invoke_onclick);
1801
1802     hres = IHTMLElement_click(div);
1803     ok(hres == S_OK, "click failed: %08x\n", hres);
1804
1805     CHECK_CALLED(div_onclick);
1806     CHECK_CALLED(div_onclick_attached);
1807     CHECK_CALLED(body_onclick);
1808     CHECK_CALLED(document_onclick);
1809     CHECK_CALLED(invoke_onclick);
1810
1811     SET_EXPECT(div_onclick);
1812     SET_EXPECT(div_onclick_attached);
1813     SET_EXPECT(body_onclick);
1814     SET_EXPECT(document_onclick);
1815     SET_EXPECT(invoke_onclick);
1816
1817     V_VT(&v) = VT_EMPTY;
1818     elem_fire_event((IUnknown*)div, "onclick", &v);
1819
1820     CHECK_CALLED(div_onclick);
1821     CHECK_CALLED(div_onclick_attached);
1822     CHECK_CALLED(body_onclick);
1823     CHECK_CALLED(document_onclick);
1824     CHECK_CALLED(invoke_onclick);
1825
1826     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_obj);
1827     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1828     doc_attach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1829
1830     SET_EXPECT(div_onclick);
1831     SET_EXPECT(div_onclick_disp);
1832     SET_EXPECT(div_onclick_attached);
1833     SET_EXPECT(body_onclick);
1834     SET_EXPECT(document_onclick);
1835     SET_EXPECT(doc_onclick_attached);
1836     SET_EXPECT(doccp_onclick);
1837     SET_EXPECT(invoke_onclick);
1838
1839     hres = IHTMLElement_click(div);
1840     ok(hres == S_OK, "click failed: %08x\n", hres);
1841
1842     CHECK_CALLED(div_onclick);
1843     CHECK_CALLED(div_onclick_disp);
1844     CHECK_CALLED(div_onclick_attached);
1845     CHECK_CALLED(body_onclick);
1846     CHECK_CALLED(document_onclick);
1847     CHECK_CALLED(doc_onclick_attached);
1848     CHECK_CALLED(doccp_onclick);
1849     CHECK_CALLED(invoke_onclick);
1850
1851     elem2_cp_cookie = register_cp((IUnknown*)div, &DIID_HTMLElementEvents2, (IUnknown*)&elem2_cp_obj);
1852
1853     SET_EXPECT(div_onclick);
1854     SET_EXPECT(div_onclick_disp);
1855     SET_EXPECT(div_onclick_attached);
1856     SET_EXPECT(elem2_cp_onclick);
1857     SET_EXPECT(body_onclick);
1858     SET_EXPECT(document_onclick);
1859     SET_EXPECT(doc_onclick_attached);
1860     SET_EXPECT(doccp_onclick);
1861     SET_EXPECT(invoke_onclick);
1862
1863     trace("click >>>\n");
1864     hres = IHTMLElement_click(div);
1865     ok(hres == S_OK, "click failed: %08x\n", hres);
1866     trace("click <<<\n");
1867
1868     CHECK_CALLED(div_onclick);
1869     CHECK_CALLED(div_onclick_disp);
1870     CHECK_CALLED(div_onclick_attached);
1871     CHECK_CALLED(elem2_cp_onclick);
1872     CHECK_CALLED(body_onclick);
1873     CHECK_CALLED(document_onclick);
1874     CHECK_CALLED(doc_onclick_attached);
1875     CHECK_CALLED(doccp_onclick);
1876     CHECK_CALLED(invoke_onclick);
1877
1878     unregister_cp((IUnknown*)div, &DIID_HTMLElementEvents2, elem2_cp_cookie);
1879     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1880
1881     V_VT(&v) = VT_NULL;
1882     hres = IHTMLElement_put_onclick(div, v);
1883     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1884
1885     hres = IHTMLElement_get_onclick(div, &v);
1886     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1887     ok(V_VT(&v) == VT_NULL, "get_onclick returned vt %d\n", V_VT(&v));
1888
1889     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1890     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1891     elem_detach_event((IUnknown*)div, "test", (IDispatch*)&div_onclick_disp);
1892     doc_detach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1893
1894     SET_EXPECT(div_onclick_attached);
1895     SET_EXPECT(body_onclick);
1896     SET_EXPECT(document_onclick);
1897     SET_EXPECT(invoke_onclick);
1898
1899     hres = IHTMLElement_click(div);
1900     ok(hres == S_OK, "click failed: %08x\n", hres);
1901
1902     CHECK_CALLED(div_onclick_attached);
1903     CHECK_CALLED(body_onclick);
1904     CHECK_CALLED(document_onclick);
1905     CHECK_CALLED(invoke_onclick);
1906
1907     IHTMLElement_Release(div);
1908     IHTMLElement_Release(body);
1909 }
1910
1911 static void test_onreadystatechange(IHTMLDocument2 *doc)
1912 {
1913     IHTMLFrameBase *iframe;
1914     IHTMLElement2 *elem2;
1915     IHTMLElement *elem;
1916     VARIANT v;
1917     BSTR str;
1918     HRESULT hres;
1919
1920     elem = get_elem_id(doc, "iframe");
1921     elem2 = get_elem2_iface((IUnknown*)elem);
1922     IHTMLElement_Release(elem);
1923
1924     V_VT(&v) = VT_EMPTY;
1925     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1926     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1927     ok(V_VT(&v) == VT_NULL, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1928
1929     V_VT(&v) = VT_DISPATCH;
1930     V_DISPATCH(&v) = (IDispatch*)&iframe_onreadystatechange_obj;
1931     hres = IHTMLElement2_put_onreadystatechange(elem2, v);
1932     ok(hres == S_OK, "put_onreadystatechange failed: %08x\n", hres);
1933
1934     V_VT(&v) = VT_EMPTY;
1935     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1936     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1937     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1938     ok(V_DISPATCH(&v) == (IDispatch*)&iframe_onreadystatechange_obj, "unexpected onreadystatechange value\n");
1939
1940     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase, (void**)&iframe);
1941     IHTMLElement2_Release(elem2);
1942     ok(hres == S_OK, "Could not get IHTMLFrameBase iface: %08x\n", hres);
1943
1944     hres = IHTMLFrameBase_put_src(iframe, (str = a2bstr("about:blank")));
1945     SysFreeString(str);
1946     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1947
1948     SET_EXPECT(iframe_onreadystatechange_loading);
1949     SET_EXPECT(iframedoc_onreadystatechange);
1950     SET_EXPECT(iframe_onreadystatechange_interactive);
1951     SET_EXPECT(iframe_onreadystatechange_complete);
1952     pump_msgs(&called_iframe_onreadystatechange_complete);
1953     CHECK_CALLED(iframe_onreadystatechange_loading);
1954     CHECK_CALLED(iframedoc_onreadystatechange);
1955     CHECK_CALLED(iframe_onreadystatechange_interactive);
1956     CHECK_CALLED(iframe_onreadystatechange_complete);
1957
1958     IHTMLFrameBase_Release(iframe);
1959 }
1960
1961 static void test_imgload(IHTMLDocument2 *doc)
1962 {
1963     IHTMLImgElement *img;
1964     IHTMLElement *elem;
1965     VARIANT v;
1966     BSTR str;
1967     HRESULT hres;
1968
1969     elem = get_elem_id(doc, "imgid");
1970     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLImgElement, (void**)&img);
1971     IHTMLElement_Release(elem);
1972     ok(hres == S_OK, "Could not get IHTMLImgElement iface: %08x\n", hres);
1973
1974     V_VT(&v) = VT_EMPTY;
1975     hres = IHTMLImgElement_get_onload(img, &v);
1976     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1977     ok(V_VT(&v) == VT_NULL, "V_VT(onload) = %d\n", V_VT(&v));
1978
1979     V_VT(&v) = VT_DISPATCH;
1980     V_DISPATCH(&v) = (IDispatch*)&img_onload_obj;
1981     hres = IHTMLImgElement_put_onload(img, v);
1982     ok(hres == S_OK, "put_onload failed: %08x\n", hres);
1983
1984     V_VT(&v) = VT_EMPTY;
1985     hres = IHTMLImgElement_get_onload(img, &v);
1986     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1987     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onload) = %d\n", V_VT(&v));
1988     ok(V_DISPATCH(&v) == (IDispatch*)&img_onload_obj, "V_DISPATCH(onload) != onloadkFunc\n");
1989     VariantClear(&v);
1990
1991     V_VT(&v) = VT_DISPATCH;
1992     V_DISPATCH(&v) = (IDispatch*)&img_onerror_obj;
1993     hres = IHTMLImgElement_put_onerror(img, v);
1994     ok(hres == S_OK, "put_onerror failed: %08x\n", hres);
1995
1996     V_VT(&v) = VT_EMPTY;
1997     hres = IHTMLImgElement_get_onerror(img, &v);
1998     ok(hres == S_OK, "get_onerror failed: %08x\n", hres);
1999     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onerror) = %d\n", V_VT(&v));
2000     ok(V_DISPATCH(&v) == (IDispatch*)&img_onerror_obj, "V_DISPATCH(onerror) != onerrorFunc\n");
2001     VariantClear(&v);
2002
2003     str = a2bstr("http://test.winehq.org/tests/winehq_snapshot/index_files/winehq_logo_text.png");
2004     hres = IHTMLImgElement_put_src(img, str);
2005     ok(hres == S_OK, "put_src failed: %08x\n", hres);
2006     SysFreeString(str);
2007
2008     SET_EXPECT(img_onload);
2009     pump_msgs(&called_img_onload);
2010     CHECK_CALLED(img_onload);
2011
2012     SET_EXPECT(img_onerror);
2013
2014     str = a2bstr("about:blank");
2015     hres = IHTMLImgElement_put_src(img, str);
2016     ok(hres == S_OK, "put_src failed: %08x\n", hres);
2017     SysFreeString(str);
2018
2019     pump_msgs(&called_img_onerror); /* FIXME: should not be needed */
2020
2021     CHECK_CALLED(img_onerror);
2022
2023     IHTMLImgElement_Release(img);
2024
2025     /* test onload on unattached image */
2026     hres = IHTMLDocument2_createElement(doc, (str = a2bstr("img")), &elem);
2027     SysFreeString(str);
2028     ok(hres == S_OK, "createElement(img) failed: %08x\n", hres);
2029
2030     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLImgElement, (void**)&img);
2031     IHTMLElement_Release(elem);
2032     ok(hres == S_OK, "Could not get IHTMLImgElement iface: %08x\n", hres);
2033
2034     V_VT(&v) = VT_EMPTY;
2035     hres = IHTMLImgElement_get_onload(img, &v);
2036     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
2037     ok(V_VT(&v) == VT_NULL, "V_VT(onload) = %d\n", V_VT(&v));
2038
2039     V_VT(&v) = VT_DISPATCH;
2040     V_DISPATCH(&v) = (IDispatch*)&unattached_img_onload_obj;
2041     hres = IHTMLImgElement_put_onload(img, v);
2042     ok(hres == S_OK, "put_onload failed: %08x\n", hres);
2043
2044     V_VT(&v) = VT_EMPTY;
2045     hres = IHTMLImgElement_get_onload(img, &v);
2046     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
2047     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onload) = %d\n", V_VT(&v));
2048     ok(V_DISPATCH(&v) == (IDispatch*)&unattached_img_onload_obj, "incorrect V_DISPATCH(onload)\n");
2049     VariantClear(&v);
2050
2051     str = a2bstr("http://test.winehq.org/tests/winehq_snapshot/index_files/winehq_logo_text.png?v=1");
2052     hres = IHTMLImgElement_put_src(img, str);
2053     ok(hres == S_OK, "put_src failed: %08x\n", hres);
2054     SysFreeString(str);
2055
2056     SET_EXPECT(img_onload);
2057     pump_msgs(&called_img_onload);
2058     CHECK_CALLED(img_onload);
2059
2060     IHTMLImgElement_Release(img);
2061 }
2062
2063 static void test_link_load(IHTMLDocument2 *doc)
2064 {
2065     IHTMLLinkElement *link;
2066     IHTMLElement *elem;
2067     VARIANT v;
2068     BSTR str;
2069     HRESULT hres;
2070
2071     elem = get_elem_id(doc, "linkid");
2072     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLLinkElement, (void**)&link);
2073     IHTMLElement_Release(elem);
2074     ok(hres == S_OK, "Could not get IHTMLLinkElement iface: %08x\n", hres);
2075
2076     V_VT(&v) = VT_EMPTY;
2077     hres = IHTMLLinkElement_get_onload(link, &v);
2078     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
2079     ok(V_VT(&v) == VT_NULL, "V_VT(onload) = %d\n", V_VT(&v));
2080
2081     V_VT(&v) = VT_DISPATCH;
2082     V_DISPATCH(&v) = (IDispatch*)&link_onload_obj;
2083     hres = IHTMLLinkElement_put_onload(link, v);
2084     ok(hres == S_OK, "put_onload failed: %08x\n", hres);
2085
2086     V_VT(&v) = VT_EMPTY;
2087     hres = IHTMLLinkElement_get_onload(link, &v);
2088     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
2089     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onload) = %d\n", V_VT(&v));
2090     ok(V_DISPATCH(&v) == (IDispatch*)&link_onload_obj, "V_DISPATCH(onload) != onloadkFunc\n");
2091     VariantClear(&v);
2092
2093     str = a2bstr("http://test.winehq.org/tests/winehq_snapshot/index_files/styles.css");
2094     hres = IHTMLLinkElement_put_href(link, str);
2095     ok(hres == S_OK, "put_src failed: %08x\n", hres);
2096     SysFreeString(str);
2097
2098     SET_EXPECT(link_onload);
2099     pump_msgs(&called_link_onload);
2100     CHECK_CALLED(link_onload);
2101
2102     IHTMLLinkElement_Release(link);
2103 }
2104
2105 static void test_focus(IHTMLDocument2 *doc)
2106 {
2107     IHTMLElement2 *elem2;
2108     IHTMLElement4 *div;
2109     IHTMLElement *elem;
2110     VARIANT v;
2111     HRESULT hres;
2112
2113     elem = get_elem_id(doc, "inputid");
2114     elem2 = get_elem2_iface((IUnknown*)elem);
2115     IHTMLElement_Release(elem);
2116
2117     elem = get_elem_id(doc, "divid");
2118     div = get_elem4_iface((IUnknown*)elem);
2119     IHTMLElement_Release(elem);
2120
2121     V_VT(&v) = VT_EMPTY;
2122     hres = IHTMLElement2_get_onfocus(elem2, &v);
2123     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
2124     ok(V_VT(&v) == VT_NULL, "V_VT(onfocus) = %d\n", V_VT(&v));
2125
2126     V_VT(&v) = VT_DISPATCH;
2127     V_DISPATCH(&v) = (IDispatch*)&input_onfocus_obj;
2128     hres = IHTMLElement2_put_onfocus(elem2, v);
2129     ok(hres == S_OK, "put_onfocus failed: %08x\n", hres);
2130
2131     V_VT(&v) = VT_EMPTY;
2132     hres = IHTMLElement2_get_onfocus(elem2, &v);
2133     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
2134     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onfocus) = %d\n", V_VT(&v));
2135     ok(V_DISPATCH(&v) == (IDispatch*)&input_onfocus_obj, "V_DISPATCH(onfocus) != onfocusFunc\n");
2136     VariantClear(&v);
2137
2138     V_VT(&v) = VT_DISPATCH;
2139     V_DISPATCH(&v) = (IDispatch*)&div_onfocusin_obj;
2140     hres = IHTMLElement4_put_onfocusin(div, v);
2141     ok(hres == S_OK, "put_onfocusin failed: %08x\n", hres);
2142
2143     V_VT(&v) = VT_EMPTY;
2144     hres = IHTMLElement4_get_onfocusin(div, &v);
2145     ok(hres == S_OK, "get_onfocusin failed: %08x\n", hres);
2146     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onfocusin) = %d\n", V_VT(&v));
2147     ok(V_DISPATCH(&v) == (IDispatch*)&div_onfocusin_obj, "V_DISPATCH(onfocus) != onfocusFunc\n");
2148     VariantClear(&v);
2149
2150     V_VT(&v) = VT_EMPTY;
2151     hres = IHTMLElement2_get_onfocus(elem2, &v);
2152     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
2153     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onfocus) = %d\n", V_VT(&v));
2154     ok(V_DISPATCH(&v) == (IDispatch*)&input_onfocus_obj, "V_DISPATCH(onfocus) != onfocusFunc\n");
2155     VariantClear(&v);
2156
2157     if(!winetest_interactive)
2158         ShowWindow(container_hwnd, SW_SHOW);
2159
2160     SetFocus(NULL);
2161     ok(!IsChild(container_hwnd, GetFocus()), "focus belongs to document window\n");
2162
2163     hres = IHTMLWindow2_focus(window);
2164     ok(hres == S_OK, "focus failed: %08x\n", hres);
2165
2166     ok(IsChild(container_hwnd, GetFocus()), "focus does not belong to document window\n");
2167     pump_msgs(NULL);
2168
2169     SET_EXPECT(div_onfocusin);
2170     SET_EXPECT(input_onfocus);
2171     hres = IHTMLElement2_focus(elem2);
2172     ok(hres == S_OK, "focus failed: %08x\n", hres);
2173     pump_msgs(NULL);
2174     CHECK_CALLED(div_onfocusin);
2175     CHECK_CALLED(input_onfocus);
2176
2177     SET_EXPECT(div_onfocusin);
2178     V_VT(&v) = VT_EMPTY;
2179     elem_fire_event((IUnknown*)elem2, "onfocusin", &v);
2180     CHECK_CALLED(div_onfocusin);
2181
2182     V_VT(&v) = VT_DISPATCH;
2183     V_DISPATCH(&v) = (IDispatch*)&input_onblur_obj;
2184     hres = IHTMLElement2_put_onblur(elem2, v);
2185     ok(hres == S_OK, "put_onblur failed: %08x\n", hres);
2186
2187     V_VT(&v) = VT_DISPATCH;
2188     V_DISPATCH(&v) = (IDispatch*)&div_onfocusout_obj;
2189     hres = IHTMLElement4_put_onfocusout(div, v);
2190     ok(hres == S_OK, "put_onfocusout failed: %08x\n", hres);
2191
2192     SET_EXPECT(div_onfocusout);
2193     SET_EXPECT(input_onblur);
2194     hres = IHTMLElement2_blur(elem2);
2195     pump_msgs(NULL);
2196     CHECK_CALLED(input_onblur);
2197     CHECK_CALLED(div_onfocusout);
2198     ok(hres == S_OK, "blur failed: %08x\n", hres);
2199
2200     if(!winetest_interactive)
2201         ShowWindow(container_hwnd, SW_HIDE);
2202
2203     IHTMLElement2_Release(elem2);
2204     IHTMLElement4_Release(div);
2205 }
2206
2207 static void test_submit(IHTMLDocument2 *doc)
2208 {
2209     IHTMLElement *elem, *submit;
2210     IHTMLFormElement *form;
2211     VARIANT v;
2212     DWORD cp_cookie;
2213     HRESULT hres;
2214
2215     set_body_html(doc,
2216                   "<form id=\"formid\" method=\"post\" action=\"about:blank\">"
2217                   "<input type=\"text\" value=\"test\" name=\"i\"/>"
2218                   "<input type=\"submit\" id=\"submitid\" />"
2219                   "</form>");
2220
2221     elem = get_elem_id(doc, "formid");
2222
2223     V_VT(&v) = VT_DISPATCH;
2224     V_DISPATCH(&v) = (IDispatch*)&form_onclick_obj;
2225     hres = IHTMLElement_put_onclick(elem, v);
2226     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2227
2228     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLFormElement, (void**)&form);
2229     IHTMLElement_Release(elem);
2230     ok(hres == S_OK, "Could not get IHTMLFormElement iface: %08x\n", hres);
2231
2232     V_VT(&v) = VT_DISPATCH;
2233     V_DISPATCH(&v) = (IDispatch*)&form_onsubmit_obj;
2234     hres = IHTMLFormElement_put_onsubmit(form, v);
2235     ok(hres == S_OK, "put_onsubmit failed: %08x\n", hres);
2236
2237     IHTMLFormElement_Release(form);
2238
2239     submit = get_elem_id(doc, "submitid");
2240
2241     SET_EXPECT(form_onclick);
2242     SET_EXPECT(form_onsubmit);
2243     hres = IHTMLElement_click(submit);
2244     ok(hres == S_OK, "click failed: %08x\n", hres);
2245     CHECK_CALLED(form_onclick);
2246     CHECK_CALLED(form_onsubmit);
2247
2248     V_VT(&v) = VT_DISPATCH;
2249     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_obj;
2250     hres = IHTMLElement_put_onclick(submit, v);
2251     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2252
2253     SET_EXPECT(form_onclick);
2254     SET_EXPECT(submit_onclick);
2255     hres = IHTMLElement_click(submit);
2256     ok(hres == S_OK, "click failed: %08x\n", hres);
2257     CHECK_CALLED(form_onclick);
2258     CHECK_CALLED(submit_onclick);
2259
2260     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
2261
2262     SET_EXPECT(form_onclick);
2263     SET_EXPECT(submit_onclick);
2264     SET_EXPECT(submit_onclick_attached);
2265     hres = IHTMLElement_click(submit);
2266     ok(hres == S_OK, "click failed: %08x\n", hres);
2267     CHECK_CALLED(form_onclick);
2268     CHECK_CALLED(submit_onclick);
2269     CHECK_CALLED(submit_onclick_attached);
2270
2271     V_VT(&v) = VT_NULL;
2272     hres = IHTMLElement_put_onclick(submit, v);
2273     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2274
2275     SET_EXPECT(form_onclick);
2276     SET_EXPECT(submit_onclick_attached);
2277     hres = IHTMLElement_click(submit);
2278     ok(hres == S_OK, "click failed: %08x\n", hres);
2279     CHECK_CALLED(form_onclick);
2280     CHECK_CALLED(submit_onclick_attached);
2281
2282     elem_detach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
2283
2284     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_onclick_cancel_obj);
2285
2286     SET_EXPECT(form_onclick);
2287     SET_EXPECT(doccp_onclick_cancel);
2288     hres = IHTMLElement_click(submit);
2289     ok(hres == S_OK, "click failed: %08x\n", hres);
2290     CHECK_CALLED(form_onclick);
2291     CHECK_CALLED(doccp_onclick_cancel);
2292
2293     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
2294
2295     V_VT(&v) = VT_DISPATCH;
2296     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_setret_obj;
2297     hres = IHTMLElement_put_onclick(submit, v);
2298     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2299
2300     V_VT(&onclick_retval) = VT_BOOL;
2301     V_BOOL(&onclick_retval) = VARIANT_TRUE;
2302     V_VT(&onclick_event_retval) = VT_BOOL;
2303     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
2304
2305     SET_EXPECT(submit_onclick_setret);
2306     SET_EXPECT(form_onclick);
2307     SET_EXPECT(form_onsubmit);
2308     hres = IHTMLElement_click(submit);
2309     ok(hres == S_OK, "click failed: %08x\n", hres);
2310     CHECK_CALLED(submit_onclick_setret);
2311     CHECK_CALLED(form_onclick);
2312     CHECK_CALLED(form_onsubmit);
2313
2314     V_VT(&onclick_event_retval) = VT_BOOL;
2315     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
2316
2317     SET_EXPECT(submit_onclick_setret);
2318     SET_EXPECT(form_onclick);
2319     hres = IHTMLElement_click(submit);
2320     ok(hres == S_OK, "click failed: %08x\n", hres);
2321     CHECK_CALLED(submit_onclick_setret);
2322     CHECK_CALLED(form_onclick);
2323
2324     V_VT(&onclick_retval) = VT_BOOL;
2325     V_BOOL(&onclick_retval) = VARIANT_FALSE;
2326     V_VT(&onclick_event_retval) = VT_BOOL;
2327     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
2328
2329     SET_EXPECT(submit_onclick_setret);
2330     SET_EXPECT(form_onclick);
2331     hres = IHTMLElement_click(submit);
2332     ok(hres == S_OK, "click failed: %08x\n", hres);
2333     CHECK_CALLED(submit_onclick_setret);
2334     CHECK_CALLED(form_onclick);
2335
2336     V_VT(&onclick_event_retval) = VT_BOOL;
2337     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
2338
2339     SET_EXPECT(submit_onclick_setret);
2340     SET_EXPECT(form_onclick);
2341     hres = IHTMLElement_click(submit);
2342     ok(hres == S_OK, "click failed: %08x\n", hres);
2343     CHECK_CALLED(submit_onclick_setret);
2344     CHECK_CALLED(form_onclick);
2345
2346     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
2347     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_check_cancel_obj);
2348
2349     V_VT(&v) = VT_DISPATCH;
2350     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_cancel_obj;
2351     hres = IHTMLElement_put_onclick(submit, v);
2352     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2353
2354     SET_EXPECT(submit_onclick_cancel);
2355     SET_EXPECT(submit_onclick_attached_check_cancel);
2356     SET_EXPECT(submit_onclick_attached);
2357     hres = IHTMLElement_click(submit);
2358     ok(hres == S_OK, "click failed: %08x\n", hres);
2359     CHECK_CALLED(submit_onclick_cancel);
2360     CHECK_CALLED(submit_onclick_attached_check_cancel);
2361     CHECK_CALLED(submit_onclick_attached);
2362
2363     if(1)pump_msgs(NULL);
2364
2365     IHTMLElement_Release(submit);
2366 }
2367
2368 static void test_timeout(IHTMLDocument2 *doc)
2369 {
2370     IHTMLWindow3 *win3;
2371     VARIANT expr, var;
2372     LONG id;
2373     HRESULT hres;
2374
2375     hres = IHTMLWindow2_QueryInterface(window, &IID_IHTMLWindow3, (void**)&win3);
2376     ok(hres == S_OK, "Could not get IHTMLWindow3 iface: %08x\n", hres);
2377
2378     V_VT(&expr) = VT_DISPATCH;
2379     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc2;
2380     V_VT(&var) = VT_EMPTY;
2381     id = 0;
2382     hres = IHTMLWindow3_setInterval(win3, &expr, 1, &var, &id);
2383     ok(hres == S_OK, "setInterval failed: %08x\n", hres);
2384     ok(id, "id = 0\n");
2385
2386     hres = IHTMLWindow2_clearTimeout(window, id);
2387     ok(hres == S_OK, "clearTimeout failer: %08x\n", hres);
2388
2389     V_VT(&expr) = VT_DISPATCH;
2390     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
2391     V_VT(&var) = VT_EMPTY;
2392     id = 0;
2393     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
2394     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
2395     ok(id, "id = 0\n");
2396
2397     SET_EXPECT(timeout);
2398     pump_msgs(&called_timeout);
2399     CHECK_CALLED(timeout);
2400
2401     V_VT(&expr) = VT_DISPATCH;
2402     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
2403     V_VT(&var) = VT_EMPTY;
2404     id = 0;
2405     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
2406     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
2407     ok(id, "id = 0\n");
2408
2409     hres = IHTMLWindow2_clearTimeout(window, id);
2410     ok(hres == S_OK, "clearTimeout failed: %08x\n", hres);
2411
2412     V_VT(&expr) = VT_DISPATCH;
2413     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
2414     V_VT(&var) = VT_EMPTY;
2415     id = 0;
2416     hres = IHTMLWindow3_setInterval(win3, &expr, 1, &var, &id);
2417     ok(hres == S_OK, "setInterval failed: %08x\n", hres);
2418     ok(id, "id = 0\n");
2419
2420     SET_EXPECT(timeout);
2421     pump_msgs(&called_timeout);
2422     CHECK_CALLED(timeout);
2423
2424     SET_EXPECT(timeout);
2425     pump_msgs(&called_timeout);
2426     CHECK_CALLED(timeout);
2427
2428     hres = IHTMLWindow2_clearInterval(window, id);
2429     ok(hres == S_OK, "clearTimeout failer: %08x\n", hres);
2430
2431     IHTMLWindow3_Release(win3);
2432 }
2433
2434 static IHTMLWindow2 *get_iframe_window(IHTMLIFrameElement *iframe)
2435 {
2436     IHTMLWindow2 *window;
2437     IHTMLFrameBase2 *base;
2438     HRESULT hres;
2439
2440     hres = IHTMLIFrameElement_QueryInterface(iframe, &IID_IHTMLFrameBase2, (void**)&base);
2441     ok(hres == S_OK, "QueryInterface(IID_IHTMLFrameBase2) failed: %08x\n", hres);
2442
2443     hres = IHTMLFrameBase2_get_contentWindow(base, &window);
2444     ok(hres == S_OK, "get_contentWindow failed: %08x\n", hres);
2445     ok(window != NULL, "window == NULL\n");
2446
2447     if(base) IHTMLFrameBase2_Release(base);
2448     return window;
2449 }
2450
2451 static IHTMLDocument2 *get_iframe_doc(IHTMLIFrameElement *iframe)
2452 {
2453     IHTMLDocument2 *result = NULL;
2454     IHTMLWindow2 *window;
2455     HRESULT hres;
2456
2457     window = get_iframe_window(iframe);
2458
2459     hres = IHTMLWindow2_get_document(window, &result);
2460     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2461     ok(result != NULL, "result == NULL\n");
2462
2463     IHTMLWindow2_Release(window);
2464     return result;
2465 }
2466
2467 static void test_iframe_connections(IHTMLDocument2 *doc)
2468 {
2469     IHTMLIFrameElement *iframe;
2470     IHTMLDocument2 *iframes_doc;
2471     DWORD cookie;
2472     IConnectionPoint *cp;
2473     IHTMLElement *element;
2474     BSTR str;
2475     HRESULT hres;
2476
2477     trace("iframe tests...\n");
2478
2479     element = get_elem_id(doc, "ifr");
2480     iframe = get_iframe_iface((IUnknown*)element);
2481     IHTMLElement_Release(element);
2482
2483     iframes_doc = get_iframe_doc(iframe);
2484     IHTMLIFrameElement_Release(iframe);
2485
2486     cookie = register_cp((IUnknown*)iframes_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
2487
2488     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
2489     hres = IConnectionPoint_Unadvise(cp, cookie);
2490     IConnectionPoint_Release(cp);
2491     ok(hres == CONNECT_E_NOCONNECTION, "Unadvise returned %08x, expected CONNECT_E_NOCONNECTION\n", hres);
2492
2493     unregister_cp((IUnknown*)iframes_doc, &IID_IDispatch, cookie);
2494
2495     if(is_ie9plus) {
2496         IHTMLFrameBase2 *frame_base2;
2497         VARIANT v;
2498
2499         hres = IHTMLIFrameElement_QueryInterface(iframe, &IID_IHTMLFrameBase2, (void**)&frame_base2);
2500         ok(hres == S_OK, "Could not get IHTMLFrameBase2 iface: %08x\n", hres);
2501
2502         V_VT(&v) = VT_DISPATCH;
2503         V_DISPATCH(&v) = (IDispatch*)&iframe_onload_obj;
2504         hres = IHTMLFrameBase2_put_onload(frame_base2, v);
2505         ok(hres == S_OK, "put_onload failed: %08x\n", hres);
2506
2507         IHTMLFrameBase2_Release(frame_base2);
2508
2509         str = a2bstr("about:blank");
2510         hres = IHTMLDocument2_put_URL(iframes_doc, str);
2511         ok(hres == S_OK, "put_URL failed: %08x\n", hres);
2512         SysFreeString(str);
2513
2514         SET_EXPECT(iframe_onload);
2515         pump_msgs(&called_iframe_onload);
2516         CHECK_CALLED(iframe_onload);
2517
2518         str = a2bstr("about:test");
2519         hres = IHTMLDocument2_put_URL(iframes_doc, str);
2520         ok(hres == S_OK, "put_URL failed: %08x\n", hres);
2521         SysFreeString(str);
2522
2523         SET_EXPECT(iframe_onload);
2524         pump_msgs(&called_iframe_onload);
2525         CHECK_CALLED(iframe_onload);
2526     }else {
2527         win_skip("Skipping iframe onload tests on IE older than 9.\n");
2528     }
2529
2530     IHTMLDocument2_Release(iframes_doc);
2531 }
2532
2533 static void test_create_event(IHTMLDocument2 *doc)
2534 {
2535     IDocumentEvent *doc_event;
2536     IDOMEvent *event;
2537     USHORT phase;
2538     BSTR str;
2539     HRESULT hres;
2540
2541     trace("createEvent tests...\n");
2542
2543     hres = IHTMLDocument2_QueryInterface(doc, &IID_IDocumentEvent, (void**)&doc_event);
2544     ok(hres == S_OK, "Could not get IDocumentEvent iface: %08x\n", hres);
2545
2546     str = a2bstr("Event");
2547     hres = IDocumentEvent_createEvent(doc_event, str, &event);
2548     SysFreeString(str);
2549     ok(hres == S_OK, "createEvent failed: %08x\n", hres);
2550
2551     phase = 0xdead;
2552     hres = IDOMEvent_get_eventPhase(event, &phase);
2553     ok(hres == S_OK, "get_eventPhase failed: %08x\n", hres);
2554     ok(!phase, "phase = %u\n", phase);
2555
2556     hres = IDOMEvent_preventDefault(event);
2557     ok(hres == S_OK, "preventDefault failed: %08x\n", hres);
2558
2559     hres = IDOMEvent_stopPropagation(event);
2560     ok(hres == S_OK, "stopPropagation failed: %08x\n", hres);
2561
2562     IDOMEvent_Release(event);
2563
2564     IDocumentEvent_Release(doc_event);
2565 }
2566
2567 static HRESULT QueryInterface(REFIID,void**);
2568
2569 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
2570 {
2571     return E_NOINTERFACE;
2572 }
2573
2574 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
2575 {
2576     return 2;
2577 }
2578
2579 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
2580 {
2581     return 1;
2582 }
2583
2584 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
2585 {
2586     return E_NOTIMPL;
2587 }
2588
2589 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
2590 {
2591     return E_NOTIMPL;
2592 }
2593
2594 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
2595 {
2596     return E_NOTIMPL;
2597 }
2598
2599 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
2600         LPCBORDERWIDTHS pborderwidths)
2601 {
2602     return E_NOTIMPL;
2603 }
2604
2605 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
2606         LPCBORDERWIDTHS pborderwidths)
2607 {
2608     return S_OK;
2609 }
2610
2611 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
2612         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2613 {
2614     return S_OK;
2615 }
2616
2617 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
2618         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2619 {
2620     return S_OK;
2621 }
2622
2623 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
2624         LPOLEMENUGROUPWIDTHS lpMenuWidths)
2625 {
2626     return E_NOTIMPL;
2627 }
2628
2629 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
2630         HOLEMENU holemenu, HWND hwndActiveObject)
2631 {
2632     ok(0, "unexpected call\n");
2633     return E_NOTIMPL;
2634 }
2635
2636 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
2637 {
2638     ok(0, "unexpected call\n");
2639     return E_NOTIMPL;
2640 }
2641
2642 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
2643 {
2644     return S_OK;
2645 }
2646
2647 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
2648 {
2649     return E_NOTIMPL;
2650 }
2651
2652 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
2653 {
2654     ok(0, "unexpected call\n");
2655     return E_NOTIMPL;
2656 }
2657
2658 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
2659     InPlaceFrame_QueryInterface,
2660     InPlaceFrame_AddRef,
2661     InPlaceFrame_Release,
2662     InPlaceFrame_GetWindow,
2663     InPlaceFrame_ContextSensitiveHelp,
2664     InPlaceFrame_GetBorder,
2665     InPlaceFrame_RequestBorderSpace,
2666     InPlaceFrame_SetBorderSpace,
2667     InPlaceFrame_SetActiveObject,
2668     InPlaceFrame_InsertMenus,
2669     InPlaceFrame_SetMenu,
2670     InPlaceFrame_RemoveMenus,
2671     InPlaceFrame_SetStatusText,
2672     InPlaceFrame_EnableModeless,
2673     InPlaceFrame_TranslateAccelerator
2674 };
2675
2676 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
2677
2678 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
2679     InPlaceFrame_QueryInterface,
2680     InPlaceFrame_AddRef,
2681     InPlaceFrame_Release,
2682     InPlaceFrame_GetWindow,
2683     InPlaceFrame_ContextSensitiveHelp,
2684     InPlaceFrame_GetBorder,
2685     InPlaceFrame_RequestBorderSpace,
2686     InPlaceFrame_SetBorderSpace,
2687     InPlaceUIWindow_SetActiveObject,
2688 };
2689
2690 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
2691
2692 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
2693 {
2694     return QueryInterface(riid, ppv);
2695 }
2696
2697 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
2698 {
2699     return 2;
2700 }
2701
2702 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
2703 {
2704     return 1;
2705 }
2706
2707 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
2708 {
2709     *phwnd = container_hwnd;
2710     return S_OK;
2711 }
2712
2713 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
2714 {
2715     ok(0, "unexpected call\n");
2716     return E_NOTIMPL;
2717 }
2718
2719 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
2720 {
2721     return S_OK;
2722 }
2723
2724 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
2725 {
2726     return S_OK;
2727 }
2728
2729 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
2730 {
2731     return S_OK;
2732 }
2733
2734 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
2735         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
2736         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
2737 {
2738     static const RECT rect = {0,0,300,300};
2739
2740     *ppFrame = &InPlaceFrame;
2741     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
2742     *lprcPosRect = rect;
2743     *lprcClipRect = rect;
2744
2745     ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
2746     lpFrameInfo->fMDIApp = FALSE;
2747     lpFrameInfo->hwndFrame = container_hwnd;
2748     lpFrameInfo->haccel = NULL;
2749     lpFrameInfo->cAccelEntries = 0;
2750
2751     return S_OK;
2752 }
2753
2754 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
2755 {
2756     return E_NOTIMPL;
2757 }
2758
2759 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
2760 {
2761     return S_OK;
2762 }
2763
2764 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
2765 {
2766     return S_OK;
2767 }
2768
2769 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
2770 {
2771     return E_NOTIMPL;
2772 }
2773
2774 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
2775 {
2776     return E_NOTIMPL;
2777 }
2778
2779 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
2780 {
2781     return E_NOTIMPL;
2782 }
2783
2784 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
2785     InPlaceSite_QueryInterface,
2786     InPlaceSite_AddRef,
2787     InPlaceSite_Release,
2788     InPlaceSite_GetWindow,
2789     InPlaceSite_ContextSensitiveHelp,
2790     InPlaceSite_CanInPlaceActivate,
2791     InPlaceSite_OnInPlaceActivate,
2792     InPlaceSite_OnUIActivate,
2793     InPlaceSite_GetWindowContext,
2794     InPlaceSite_Scroll,
2795     InPlaceSite_OnUIDeactivate,
2796     InPlaceSite_OnInPlaceDeactivate,
2797     InPlaceSite_DiscardUndoState,
2798     InPlaceSite_DeactivateAndUndo,
2799     InPlaceSite_OnPosRectChange,
2800 };
2801
2802 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
2803
2804 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
2805 {
2806     return QueryInterface(riid, ppv);
2807 }
2808
2809 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
2810 {
2811     return 2;
2812 }
2813
2814 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
2815 {
2816     return 1;
2817 }
2818
2819 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
2820 {
2821     ok(0, "unexpected call\n");
2822     return E_NOTIMPL;
2823 }
2824
2825 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
2826         IMoniker **ppmon)
2827 {
2828     ok(0, "unexpected call\n");
2829     return E_NOTIMPL;
2830 }
2831
2832 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
2833 {
2834     return E_NOTIMPL;
2835 }
2836
2837 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
2838 {
2839     ok(0, "unexpected call\n");
2840     return E_NOTIMPL;
2841 }
2842
2843 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
2844 {
2845     ok(0, "unexpected call\n");
2846     return E_NOTIMPL;
2847 }
2848
2849 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
2850 {
2851     ok(0, "unexpected call\n");
2852     return E_NOTIMPL;
2853 }
2854
2855 static const IOleClientSiteVtbl ClientSiteVtbl = {
2856     ClientSite_QueryInterface,
2857     ClientSite_AddRef,
2858     ClientSite_Release,
2859     ClientSite_SaveObject,
2860     ClientSite_GetMoniker,
2861     ClientSite_GetContainer,
2862     ClientSite_ShowObject,
2863     ClientSite_OnShowWindow,
2864     ClientSite_RequestNewObjectLayout
2865 };
2866
2867 static IOleClientSite ClientSite = { &ClientSiteVtbl };
2868
2869 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2870 {
2871     return QueryInterface(riid, ppv);
2872 }
2873
2874 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2875 {
2876     return 2;
2877 }
2878
2879 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2880 {
2881     return 1;
2882 }
2883
2884 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2885 {
2886     RECT rect = {0,0,300,300};
2887     IOleDocument *document;
2888     HRESULT hres;
2889
2890     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2891     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2892
2893     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
2894     IOleDocument_Release(document);
2895     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2896
2897     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
2898     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2899
2900     hres = IOleDocumentView_UIActivate(view, TRUE);
2901     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2902
2903     hres = IOleDocumentView_SetRect(view, &rect);
2904     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2905
2906     hres = IOleDocumentView_Show(view, TRUE);
2907     ok(hres == S_OK, "Show failed: %08x\n", hres);
2908
2909     return S_OK;
2910 }
2911
2912 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2913     DocumentSite_QueryInterface,
2914     DocumentSite_AddRef,
2915     DocumentSite_Release,
2916     DocumentSite_ActivateMe
2917 };
2918
2919 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2920
2921 static HRESULT QueryInterface(REFIID riid, void **ppv)
2922 {
2923     *ppv = NULL;
2924
2925     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2926         *ppv = &ClientSite;
2927     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2928         *ppv = &DocumentSite;
2929     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2930         *ppv = &InPlaceSite;
2931
2932     return *ppv ? S_OK : E_NOINTERFACE;
2933 }
2934
2935 static IHTMLDocument2 *notif_doc;
2936 static BOOL doc_complete;
2937
2938 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
2939         REFIID riid, void**ppv)
2940 {
2941     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2942         *ppv = iface;
2943         return S_OK;
2944     }
2945
2946     ok(0, "unexpected call\n");
2947     return E_NOINTERFACE;
2948 }
2949
2950 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
2951 {
2952     return 2;
2953 }
2954
2955 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
2956 {
2957     return 1;
2958 }
2959
2960 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
2961 {
2962     if(dispID == DISPID_READYSTATE){
2963         BSTR state;
2964         HRESULT hres;
2965
2966         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
2967         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
2968
2969         if(!strcmp_wa(state, "complete"))
2970             doc_complete = TRUE;
2971
2972         SysFreeString(state);
2973     }
2974
2975     return S_OK;
2976 }
2977
2978 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
2979 {
2980     ok(0, "unexpected call\n");
2981     return E_NOTIMPL;
2982 }
2983
2984 static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2985     PropertyNotifySink_QueryInterface,
2986     PropertyNotifySink_AddRef,
2987     PropertyNotifySink_Release,
2988     PropertyNotifySink_OnChanged,
2989     PropertyNotifySink_OnRequestEdit
2990 };
2991
2992 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2993
2994 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2995 {
2996     IPersistStreamInit *init;
2997     IStream *stream;
2998     HGLOBAL mem;
2999     SIZE_T len;
3000
3001     notif_doc = doc;
3002
3003     doc_complete = FALSE;
3004     len = strlen(str);
3005     mem = GlobalAlloc(0, len);
3006     memcpy(mem, str, len);
3007     CreateStreamOnHGlobal(mem, TRUE, &stream);
3008
3009     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
3010
3011     IPersistStreamInit_Load(init, stream);
3012     IPersistStreamInit_Release(init);
3013     IStream_Release(stream);
3014 }
3015
3016 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
3017 {
3018     IConnectionPointContainer *container;
3019     IConnectionPoint *cp;
3020     DWORD cookie;
3021     HRESULT hres;
3022
3023     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
3024     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
3025
3026     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
3027     IConnectionPointContainer_Release(container);
3028     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
3029
3030     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
3031     IConnectionPoint_Release(cp);
3032     ok(hres == S_OK, "Advise failed: %08x\n", hres);
3033 }
3034
3035 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
3036 {
3037     IOleObject *oleobj;
3038     HRESULT hres;
3039
3040     if(!set && view) {
3041         IOleDocumentView_Show(view, FALSE);
3042         IOleDocumentView_CloseView(view, 0);
3043         IOleDocumentView_SetInPlaceSite(view, NULL);
3044         IOleDocumentView_Release(view);
3045         view = NULL;
3046     }
3047
3048     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
3049     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
3050
3051     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
3052     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
3053
3054     if(set) {
3055         IHlinkTarget *hlink;
3056
3057         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
3058         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
3059
3060         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
3061         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
3062
3063         IHlinkTarget_Release(hlink);
3064     }
3065
3066     IOleObject_Release(oleobj);
3067 }
3068 static IHTMLDocument2 *create_document(void)
3069 {
3070     IHTMLDocument2 *doc;
3071     HRESULT hres;
3072
3073     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
3074             &IID_IHTMLDocument2, (void**)&doc);
3075     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
3076     return SUCCEEDED(hres) ? doc : NULL;
3077 }
3078
3079
3080 typedef void (*testfunc_t)(IHTMLDocument2*);
3081
3082 static void run_test(const char *str, testfunc_t test)
3083 {
3084     IHTMLDocument2 *doc;
3085     IHTMLElement *body = NULL;
3086     MSG msg;
3087     HRESULT hres;
3088
3089     doc = create_document();
3090     if (!doc)
3091         return;
3092     set_client_site(doc, TRUE);
3093     doc_load_string(doc, str);
3094     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
3095
3096     while(!doc_complete && GetMessageA(&msg, NULL, 0, 0)) {
3097         TranslateMessage(&msg);
3098         DispatchMessageA(&msg);
3099     }
3100
3101     hres = IHTMLDocument2_get_body(doc, &body);
3102     ok(hres == S_OK, "get_body failed: %08x\n", hres);
3103
3104     if(body) {
3105         IHTMLDocument6 *doc6;
3106
3107         IHTMLElement_Release(body);
3108
3109         hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument6, (void**)&doc6);
3110         if(SUCCEEDED(hres)) {
3111             VARIANT v;
3112             hres = IHTMLDocument6_get_documentMode(doc6, &v);
3113             ok(hres == S_OK, "get_documentMode failed: %08x\n", hres);
3114             ok(V_VT(&v) == VT_R4, "V_VT(documentMode) = %u\n", V_VT(&v));
3115             document_mode = V_R4(&v);
3116             IHTMLDocument6_Release(doc6);
3117         }else {
3118             document_mode = 0;
3119         }
3120
3121         hres = IHTMLDocument2_get_parentWindow(doc, &window);
3122         ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
3123         ok(window != NULL, "window == NULL\n");
3124
3125         test(doc);
3126
3127         IHTMLWindow2_Release(window);
3128         window = NULL;
3129     }else {
3130         skip("Could not get document body. Assuming no Gecko installed.\n");
3131     }
3132
3133     set_client_site(doc, FALSE);
3134     IHTMLDocument2_Release(doc);
3135 }
3136
3137 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
3138 {
3139     return DefWindowProcA(hwnd, msg, wParam, lParam);
3140 }
3141
3142 static HWND create_container_window(void)
3143 {
3144     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
3145     static WNDCLASSEXA wndclass = {
3146         sizeof(WNDCLASSEXA),
3147         0,
3148         wnd_proc,
3149         0, 0, NULL, NULL, NULL, NULL, NULL,
3150         szHTMLDocumentTest,
3151         NULL
3152     };
3153
3154     RegisterClassExA(&wndclass);
3155     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
3156             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
3157             300, 300, NULL, NULL, NULL, NULL);
3158 }
3159
3160 static void test_empty_document(void)
3161 {
3162     HRESULT hres;
3163     IHTMLWindow2 *window;
3164     IHTMLDocument2 *windows_doc, *doc;
3165     IConnectionPoint *cp;
3166     DWORD cookie;
3167
3168     doc = create_document();
3169     if(!doc)
3170         return;
3171
3172     hres = IHTMLDocument2_get_parentWindow(doc, &window);
3173     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
3174
3175     hres = IHTMLWindow2_get_document(window, &windows_doc);
3176     IHTMLWindow2_Release(window);
3177     ok(hres == S_OK, "get_document failed: %08x\n", hres);
3178
3179     cookie = register_cp((IUnknown*)windows_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
3180
3181     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
3182     hres = IConnectionPoint_Unadvise(cp, cookie);
3183     IConnectionPoint_Release(cp);
3184     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
3185
3186     IHTMLDocument2_Release(windows_doc);
3187     IHTMLDocument2_Release(doc);
3188 }
3189
3190 static BOOL check_ie(void)
3191 {
3192     IHTMLDocument2 *doc;
3193     IHTMLDocument5 *doc5;
3194     IHTMLDocument7 *doc7;
3195     HRESULT hres;
3196
3197     doc = create_document();
3198     if(!doc)
3199         return FALSE;
3200
3201     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument7, (void**)&doc7);
3202     if(SUCCEEDED(hres)) {
3203         is_ie9plus = TRUE;
3204         IHTMLDocument7_Release(doc7);
3205     }
3206
3207     trace("is_ie9plus %x\n", is_ie9plus);
3208
3209     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
3210     if(SUCCEEDED(hres))
3211         IHTMLDocument5_Release(doc5);
3212
3213     IHTMLDocument2_Release(doc);
3214     return SUCCEEDED(hres);
3215 }
3216
3217 START_TEST(events)
3218 {
3219     CoInitialize(NULL);
3220
3221     if(check_ie()) {
3222         container_hwnd = create_container_window();
3223
3224         if(winetest_interactive)
3225             ShowWindow(container_hwnd, SW_SHOW);
3226
3227         run_test(empty_doc_str, test_timeout);
3228         run_test(empty_doc_str, test_onclick);
3229         run_test(empty_doc_ie9_str, test_onclick);
3230         run_test(readystate_doc_str, test_onreadystatechange);
3231         run_test(readystate_doc_ie9_str, test_onreadystatechange);
3232         run_test(img_doc_str, test_imgload);
3233         run_test(link_doc_str, test_link_load);
3234         run_test(input_doc_str, test_focus);
3235         run_test(empty_doc_str, test_submit);
3236         run_test(empty_doc_ie9_str, test_submit);
3237         run_test(iframe_doc_str, test_iframe_connections);
3238         if(is_ie9plus)
3239             run_test(empty_doc_ie9_str, test_create_event);
3240
3241         test_empty_document();
3242
3243         DestroyWindow(container_hwnd);
3244     }else {
3245         win_skip("Too old IE\n");
3246     }
3247
3248     CoUninitialize();
3249 }