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(input_onfocus);
  77 DEFINE_EXPECT(form_onsubmit);
  78 DEFINE_EXPECT(form_onclick);
  79 DEFINE_EXPECT(submit_onclick);
  80 DEFINE_EXPECT(submit_onclick_attached);
  81 DEFINE_EXPECT(submit_onclick_setret);
  82
  83 static HWND container_hwnd = NULL;
  84 static IHTMLWindow2 *window;
  85 static IOleDocumentView *view;
  86 static BOOL xy_todo;
  87
  88 typedef struct {
  89     LONG x;
  90     LONG y;
  91     LONG offset_x;
  92     LONG offset_y;
  93 } xy_test_t;
  94
  95 static const xy_test_t no_xy = {-10,-10,-10,-10};
  96 static const xy_test_t zero_xy = {0,0,0,0};
  97
  98 static const char empty_doc_str[] =
  99     "<html></html>";
 100
 101 static const char click_doc_str[] =
 102     "<html><body>"
 103     "<div id=\"clickdiv\" style=\"text-align: center; background: red; font-size: 32\">click here</div>"
 104     "</body></html>";
 105
 106 static const char readystate_doc_str[] =
 107     "<html><body><iframe id=\"iframe\"></iframe></body></html>";
 108
 109 static const char img_doc_str[] =
 110     "<html><body><img id=\"imgid\"></img></body></html>";
 111
 112 static const char input_doc_str[] =
 113     "<html><body><input id=\"inputid\"></input></body></html>";
 114
 115 static const char iframe_doc_str[] =
 116     "<html><body><iframe id=\"ifr\">Testing</iframe></body></html>";
 117
 118 static const char form_doc_str[] =
 119     "<html><body><form id=\"formid\" method=\"post\" action=\"about:blank\">"
 120     "<input type=\"text\" value=\"test\" name=\"i\"/>"
 121     "<input type=\"submit\" id=\"submitid\" />"
 122     "</form></body></html>";
 123
 124 static const char *debugstr_guid(REFIID riid)
 125 {
 126     static char buf[50];
 127
 128     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 129             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 130             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 131             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 132
 133     return buf;
 134 }
 135
 136 static int strcmp_wa(LPCWSTR strw, const char *stra)
 137 {
 138     CHAR buf[512];
 139     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 140     return lstrcmpA(stra, buf);
 141 }
 142
 143 static BSTR a2bstr(const char *str)
 144 {
 145     BSTR ret;
 146     int len;
 147
 148     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 149     ret = SysAllocStringLen(NULL, len-1);
 150     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 151
 152     return ret;
 153 }
 154
 155 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 156 {
 157     IUnknown *unk1, *unk2;
 158
 159     if(iface1 == iface2)
 160         return TRUE;
 161
 162     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 163     IUnknown_Release(unk1);
 164     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk2);
 165     IUnknown_Release(unk2);
 166
 167     return unk1 == unk2;
 168 }
 169
 170 #define test_disp(u,id) _test_disp(__LINE__,u,id)
 171 static void _test_disp(unsigned line, IUnknown *unk, const IID *diid)
 172 {
 173     IDispatchEx *dispex;
 174     ITypeInfo *typeinfo;
 175     UINT ticnt;
 176     HRESULT hres;
 177
 178     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
 179     ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres);
 180     if(FAILED(hres))
 181         return;
 182
 183     ticnt = 0xdeadbeef;
 184     hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
 185     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres);
 186     ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt);
 187
 188     hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo);
 189     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x\n", hres);
 190
 191     if(SUCCEEDED(hres)) {
 192         TYPEATTR *type_attr;
 193
 194         hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr);
 195         ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x\n", hres);
 196         ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid), "unexpected guid %s\n",
 197                             debugstr_guid(&type_attr->guid));
 198
 199         ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr);
 200         ITypeInfo_Release(typeinfo);
 201     }
 202
 203     IDispatchEx_Release(dispex);
 204 }
 205
 206 #define get_doc3_iface(u) _get_doc3_iface(__LINE__,u)
 207 static IHTMLDocument3 *_get_doc3_iface(unsigned line, IUnknown *unk)
 208 {
 209     IHTMLDocument3 *doc3;
 210     HRESULT hres;
 211
 212     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument3, (void**)&doc3);
 213     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
 214
 215     return doc3;
 216 }
 217
 218 #define get_elem_iface(u) _get_elem_iface(__LINE__,u)
 219 static IHTMLElement *_get_elem_iface(unsigned line, IUnknown *unk)
 220 {
 221     IHTMLElement *elem;
 222     HRESULT hres;
 223
 224     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement, (void**)&elem);
 225     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement iface: %08x\n", hres);
 226
 227     return elem;
 228 }
 229
 230 #define get_elem2_iface(u) _get_elem2_iface(__LINE__,u)
 231 static IHTMLElement2 *_get_elem2_iface(unsigned line, IUnknown *unk)
 232 {
 233     IHTMLElement2 *elem2;
 234     HRESULT hres;
 235
 236     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement2, (void**)&elem2);
 237     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
 238
 239     return elem2;
 240 }
 241
 242 #define get_elem3_iface(u) _get_elem3_iface(__LINE__,u)
 243 static IHTMLElement3 *_get_elem3_iface(unsigned line, IUnknown *unk)
 244 {
 245     IHTMLElement3 *elem3;
 246     HRESULT hres;
 247
 248     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement3, (void**)&elem3);
 249     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
 250
 251     return elem3;
 252 }
 253
 254 #define doc_get_body(d) _doc_get_body(__LINE__,d)
 255 static IHTMLElement *_doc_get_body(unsigned line, IHTMLDocument2 *doc)
 256 {
 257     IHTMLElement *body = NULL;
 258     HRESULT hres;
 259
 260     hres = IHTMLDocument2_get_body(doc, &body);
 261     ok_(__FILE__,line) (hres == S_OK, "get_body failed: %08x\n", hres);
 262     ok_(__FILE__,line) (body != NULL, "body == NULL\n");
 263
 264     return body;
 265 }
 266
 267 #define get_elem_id(d,i) _get_elem_id(__LINE__,d,i)
 268 static IHTMLElement *_get_elem_id(unsigned line, IHTMLDocument2 *doc, const char *id)
 269 {
 270     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 271     IHTMLElement *elem;
 272     BSTR str;
 273     HRESULT hres;
 274
 275     str = a2bstr(id);
 276     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
 277     SysFreeString(str);
 278     IHTMLDocument3_Release(doc3);
 279     ok_(__FILE__,line) (hres == S_OK, "getElementById failed: %08x\n", hres);
 280
 281     return elem;
 282 }
 283
 284 #define test_elem_tag(u,n) _test_elem_tag(__LINE__,u,n)
 285 static void _test_elem_tag(unsigned line, IUnknown *unk, const char *extag)
 286 {
 287     IHTMLElement *elem = _get_elem_iface(line, unk);
 288     BSTR tag;
 289     HRESULT hres;
 290
 291     hres = IHTMLElement_get_tagName(elem, &tag);
 292     IHTMLElement_Release(elem);
 293     ok_(__FILE__, line) (hres == S_OK, "get_tagName failed: %08x\n", hres);
 294     ok_(__FILE__, line) (!strcmp_wa(tag, extag), "got tag: %s, expected %s\n", wine_dbgstr_w(tag), extag);
 295
 296     SysFreeString(tag);
 297 }
 298
 299 #define get_event_obj() _get_event_obj(__LINE__)
 300 static IHTMLEventObj *_get_event_obj(unsigned line)
 301 {
 302     IHTMLEventObj *event = NULL;
 303     HRESULT hres;
 304
 305     hres = IHTMLWindow2_get_event(window, &event);
 306     ok_(__FILE__,line) (hres == S_OK, "get_event failed: %08x\n", hres);
 307     ok_(__FILE__,line) (event != NULL, "event = NULL\n");
 308     _test_disp(line, (IUnknown*)event, &DIID_DispCEventObj);
 309
 310     return event;
 311 }
 312
 313 #define elem_fire_event(a,b,c) _elem_fire_event(__LINE__,a,b,c)
 314 static void _elem_fire_event(unsigned line, IUnknown *unk, const char *event, VARIANT *evobj)
 315 {
 316     IHTMLElement3 *elem3 = _get_elem3_iface(line, unk);
 317     VARIANT_BOOL b;
 318     BSTR str;
 319     HRESULT hres;
 320
 321     b = 100;
 322     str = a2bstr(event);
 323     hres = IHTMLElement3_fireEvent(elem3, str, evobj, &b);
 324     SysFreeString(str);
 325     ok_(__FILE__,line)(hres == S_OK, "fireEvent failed: %08x\n", hres);
 326     ok_(__FILE__,line)(b == VARIANT_TRUE, "fireEvent returned %x\n", b);
 327 }
 328
 329 #define test_event_args(a,b,c,d,e,f,g) _test_event_args(__LINE__,a,b,c,d,e,f,g)
 330 static void _test_event_args(unsigned line, const IID *dispiid, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 331         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 332 {
 333     ok_(__FILE__,line) (id == DISPID_VALUE, "id = %d\n", id);
 334     ok_(__FILE__,line) (wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 335     ok_(__FILE__,line) (pdp != NULL, "pdp == NULL\n");
 336     ok_(__FILE__,line) (pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 337     ok_(__FILE__,line) (pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 338     ok_(__FILE__,line) (pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n",
 339                         pdp->rgdispidNamedArgs[0]);
 340     ok_(__FILE__,line) (V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 341     ok_(__FILE__,line) (pvarRes != NULL, "pvarRes == NULL\n");
 342     ok_(__FILE__,line) (pei != NULL, "pei == NULL");
 343     ok_(__FILE__,line) (!pspCaller, "pspCaller != NULL\n");
 344
 345     if(dispiid)
 346         _test_disp(line, (IUnknown*)V_DISPATCH(pdp->rgvarg), dispiid);
 347 }
 348
 349 #define test_attached_event_args(a,b,c,d,e) _test_attached_event_args(__LINE__,a,b,c,d,e)
 350 static void _test_attached_event_args(unsigned line, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 351         VARIANT *pvarRes, EXCEPINFO *pei)
 352 {
 353     IHTMLEventObj *event;
 354
 355     ok(id == DISPID_VALUE, "id = %d\n", id);
 356     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 357     ok(pdp != NULL, "pDispParams == NULL\n");
 358     ok(pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 359     ok(!pdp->cNamedArgs, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 360     ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pdp->rgdispidNamedArgs);
 361     ok(pdp->rgvarg != NULL, "rgvarg = NULL\n");
 362     ok(pvarRes != NULL, "pvarRes = NULL\n");
 363     ok(pei != NULL, "pei = NULL\n");
 364     ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pVarRes) = %d\n", V_VT(pvarRes));
 365     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(pdp->rgvarg) = %d\n", V_VT(pdp->rgvarg));
 366     ok(V_DISPATCH(pdp->rgvarg) != NULL, "V_DISPATCH(pdp->rgvarg) = %p\n", V_DISPATCH(pdp->rgvarg));
 367
 368     event = _get_event_obj(line);
 369     ok(iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(pdp->rgvarg)), "event != arg0\n");
 370     IHTMLEventObj_Release(event);
 371 }
 372
 373 #define get_event_src() _get_event_src(__LINE__)
 374 static IHTMLElement *_get_event_src(unsigned line)
 375 {
 376     IHTMLEventObj *event = _get_event_obj(line);
 377     IHTMLElement *src_elem = NULL;
 378     HRESULT hres;
 379
 380     hres = IHTMLEventObj_get_srcElement(event, &src_elem);
 381     IHTMLEventObj_Release(event);
 382     ok_(__FILE__,line) (hres == S_OK, "get_srcElement failed: %08x\n", hres);
 383
 384     return src_elem;
 385 }
 386
 387 #define test_event_src(t) _test_event_src(__LINE__,t)
 388 static void _test_event_src(unsigned line, const char *src_tag)
 389 {
 390     IHTMLElement *src_elem = _get_event_src(line);
 391
 392     if(src_tag) {
 393         ok_(__FILE__,line) (src_elem != NULL, "src_elem = NULL\n");
 394         _test_elem_tag(line, (IUnknown*)src_elem, src_tag);
 395         IHTMLElement_Release(src_elem);
 396     }else {
 397         ok_(__FILE__,line) (!src_elem, "src_elem != NULL\n");
 398     }
 399 }
 400
 401 static void _test_event_altkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 402 {
 403     VARIANT_BOOL b;
 404     HRESULT hres;
 405
 406     hres = IHTMLEventObj_get_altKey(event, &b);
 407     ok_(__FILE__,line)(hres == S_OK, "get_altKey failed: %08x\n", hres);
 408     ok_(__FILE__,line)(b == exval, "altKey = %x, expected %x\n", b, exval);
 409 }
 410
 411 static void _test_event_ctrlkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 412 {
 413     VARIANT_BOOL b;
 414     HRESULT hres;
 415
 416     hres = IHTMLEventObj_get_ctrlKey(event, &b);
 417     ok_(__FILE__,line)(hres == S_OK, "get_ctrlKey failed: %08x\n", hres);
 418     ok_(__FILE__,line)(b == exval, "ctrlKey = %x, expected %x\n", b, exval);
 419 }
 420
 421 static void _test_event_shiftkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 422 {
 423     VARIANT_BOOL b;
 424     HRESULT hres;
 425
 426     hres = IHTMLEventObj_get_shiftKey(event, &b);
 427     ok_(__FILE__,line)(hres == S_OK, "get_shiftKey failed: %08x\n", hres);
 428     ok_(__FILE__,line)(b == exval, "shiftKey = %x, expected %x\n", b, exval);
 429 }
 430
 431 static void _test_event_cancelbubble(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 432 {
 433     VARIANT_BOOL b;
 434     HRESULT hres;
 435
 436     hres = IHTMLEventObj_get_cancelBubble(event, &b);
 437     ok_(__FILE__,line)(hres == S_OK, "get_cancelBubble failed: %08x\n", hres);
 438     ok_(__FILE__,line)(b == exval, "cancelBubble = %x, expected %x\n", b, exval);
 439 }
 440
 441 static void _test_event_fromelem(unsigned line, IHTMLEventObj *event, const char *from_tag)
 442 {
 443     IHTMLElement *elem;
 444     HRESULT hres;
 445
 446     hres = IHTMLEventObj_get_fromElement(event, &elem);
 447     ok_(__FILE__,line)(hres == S_OK, "get_fromElement failed: %08x\n", hres);
 448     if(from_tag)
 449         _test_elem_tag(line, (IUnknown*)elem, from_tag);
 450     else
 451         ok_(__FILE__,line)(elem == NULL, "fromElement != NULL\n");
 452     if(elem)
 453         IHTMLElement_Release(elem);
 454 }
 455
 456 static void _test_event_toelem(unsigned line, IHTMLEventObj *event, const char *to_tag)
 457 {
 458     IHTMLElement *elem;
 459     HRESULT hres;
 460
 461     hres = IHTMLEventObj_get_toElement(event, &elem);
 462     ok_(__FILE__,line)(hres == S_OK, "get_toElement failed: %08x\n", hres);
 463     if(to_tag)
 464         _test_elem_tag(line, (IUnknown*)elem, to_tag);
 465     else
 466         ok_(__FILE__,line)(elem == NULL, "toElement != NULL\n");
 467     if(elem)
 468         IHTMLElement_Release(elem);
 469 }
 470
 471 static void _test_event_keycode(unsigned line, IHTMLEventObj *event, LONG exl)
 472 {
 473     LONG l;
 474     HRESULT hres;
 475
 476     hres = IHTMLEventObj_get_keyCode(event, &l);
 477     ok_(__FILE__,line)(hres == S_OK, "get_keyCode failed: %08x\n", hres);
 478     ok_(__FILE__,line)(l == exl, "keyCode = %x, expected %x\n", l, exl);
 479 }
 480
 481 static void _test_event_button(unsigned line, IHTMLEventObj *event, LONG exl)
 482 {
 483     LONG l;
 484     HRESULT hres;
 485
 486     hres = IHTMLEventObj_get_button(event, &l);
 487     ok_(__FILE__,line)(hres == S_OK, "get_button failed: %08x\n", hres);
 488     ok_(__FILE__,line)(l == exl, "button = %x, expected %x\n", l, exl);
 489 }
 490
 491 static void _test_event_reason(unsigned line, IHTMLEventObj *event, LONG exl)
 492 {
 493     LONG l;
 494     HRESULT hres;
 495
 496     hres = IHTMLEventObj_get_reason(event, &l);
 497     ok_(__FILE__,line)(hres == S_OK, "get_reason failed: %08x\n", hres);
 498     ok_(__FILE__,line)(l == exl, "reason = %x, expected %x\n", l, exl);
 499 }
 500
 501 static void _test_event_x(unsigned line, IHTMLEventObj *event, LONG exl)
 502 {
 503     LONG l;
 504     HRESULT hres;
 505
 506     hres = IHTMLEventObj_get_x(event, &l);
 507     ok_(__FILE__,line)(hres == S_OK, "get_x failed: %08x\n", hres);
 508     if(exl != -10) /* don't test the exact value */
 509         ok_(__FILE__,line)(l == exl, "x = %d, expected %d\n", l, exl);
 510 }
 511
 512 static void _test_event_y(unsigned line, IHTMLEventObj *event, LONG exl)
 513 {
 514     LONG l;
 515     HRESULT hres;
 516
 517     hres = IHTMLEventObj_get_y(event, &l);
 518     ok_(__FILE__,line)(hres == S_OK, "get_y failed: %08x\n", hres);
 519     if(exl != -10) /* don't test the exact value */
 520         ok_(__FILE__,line)(l == exl, "y = %d, expected %d\n", l, exl);
 521 }
 522
 523 static void _test_event_clientx(unsigned line, IHTMLEventObj *event, LONG exl)
 524 {
 525     LONG l;
 526     HRESULT hres;
 527
 528     hres = IHTMLEventObj_get_clientX(event, &l);
 529     ok_(__FILE__,line)(hres == S_OK, "get_clientX failed: %08x\n", hres);
 530     if(exl != -10) /* don't test the exact value */
 531         ok_(__FILE__,line)(l == exl, "clientX = %d, expected %d\n", l, exl);
 532 }
 533
 534 static void _test_event_clienty(unsigned line, IHTMLEventObj *event, LONG exl)
 535 {
 536     LONG l;
 537     HRESULT hres;
 538
 539     hres = IHTMLEventObj_get_clientY(event, &l);
 540     ok_(__FILE__,line)(hres == S_OK, "get_clientY failed: %08x\n", hres);
 541     if(exl != -10) /* don't test the exact value */
 542         ok_(__FILE__,line)(l == exl, "clientY = %d, expected %d\n", l, exl);
 543 }
 544
 545 static void _test_event_offsetx(unsigned line, IHTMLEventObj *event, LONG exl)
 546 {
 547     LONG l;
 548     HRESULT hres;
 549
 550     hres = IHTMLEventObj_get_offsetX(event, &l);
 551     ok_(__FILE__,line)(hres == S_OK, "get_offsetX failed: %08x\n", hres);
 552     if(exl != -10) /* don't test the exact value */
 553         ok_(__FILE__,line)(l == exl, "offsetX = %d, expected %d\n", l, exl);
 554 }
 555
 556 static void _test_event_offsety(unsigned line, IHTMLEventObj *event, LONG exl)
 557 {
 558     LONG l;
 559     HRESULT hres;
 560
 561     hres = IHTMLEventObj_get_offsetY(event, &l);
 562     ok_(__FILE__,line)(hres == S_OK, "get_offsetY failed: %08x\n", hres);
 563     if(exl != -10) /* don't test the exact value */
 564         ok_(__FILE__,line)(l == exl, "offsetY = %d, expected %d\n", l, exl);
 565 }
 566
 567 static void _test_event_screenx(unsigned line, IHTMLEventObj *event, LONG exl)
 568 {
 569     LONG l;
 570     HRESULT hres;
 571
 572     hres = IHTMLEventObj_get_screenX(event, &l);
 573     ok_(__FILE__,line)(hres == S_OK, "get_screenX failed: %08x\n", hres);
 574     if(exl != -10) /* don't test the exact value */
 575         ok_(__FILE__,line)(l == exl, "screenX = %d, expected %d\n", l, exl);
 576 }
 577
 578 static void _test_event_screeny(unsigned line, IHTMLEventObj *event, LONG exl)
 579 {
 580     LONG l;
 581     HRESULT hres;
 582
 583     hres = IHTMLEventObj_get_screenY(event, &l);
 584     ok_(__FILE__,line)(hres == S_OK, "get_screenY failed: %08x\n", hres);
 585     if(exl != -10) /* don't test the exact value for -10 */
 586         ok_(__FILE__,line)(l == exl, "screenY = %d, expected %d\n", l, exl);
 587 }
 588
 589 static void _test_event_type(unsigned line, IHTMLEventObj *event, const char *exstr)
 590 {
 591     BSTR str;
 592     HRESULT hres;
 593
 594     hres = IHTMLEventObj_get_type(event, &str);
 595     ok_(__FILE__,line)(hres == S_OK, "get_type failed: %08x\n", hres);
 596     ok_(__FILE__,line)(!strcmp_wa(str, exstr), "type = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 597 }
 598
 599 static void _test_event_qualifier(unsigned line, IHTMLEventObj *event, const char *exstr)
 600 {
 601     BSTR str;
 602     HRESULT hres;
 603
 604     hres = IHTMLEventObj_get_qualifier(event, &str);
 605     ok_(__FILE__,line)(hres == S_OK, "get_qualifier failed: %08x\n", hres);
 606     if(exstr)
 607         ok_(__FILE__,line)(!strcmp_wa(str, exstr), "qualifier = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 608     else
 609         ok_(__FILE__,line)(!str, "qualifier != NULL\n");
 610 }
 611
 612 static void _test_event_srcfilter(unsigned line, IHTMLEventObj *event)
 613 {
 614     IDispatch *disp;
 615     HRESULT hres;
 616
 617     hres = IHTMLEventObj_get_srcFilter(event, &disp);
 618     ok_(__FILE__,line)(hres == S_OK, "get_srcFilter failed: %08x\n", hres);
 619     ok_(__FILE__,line)(!disp, "srcFilter != NULL\n");
 620 }
 621
 622 #define test_event_obj(t,x) _test_event_obj(__LINE__,t,x)
 623 static void _test_event_obj(unsigned line, const char *type, const xy_test_t *xy)
 624 {
 625     IHTMLEventObj *event = _get_event_obj(line);
 626     VARIANT v;
 627     HRESULT hres;
 628
 629     _test_event_altkey(line, event, VARIANT_FALSE);
 630     _test_event_ctrlkey(line, event, VARIANT_FALSE);
 631     _test_event_shiftkey(line, event, VARIANT_FALSE);
 632     _test_event_cancelbubble(line, event, VARIANT_FALSE);
 633     _test_event_fromelem(line, event, NULL);
 634     _test_event_toelem(line, event, NULL);
 635     _test_event_keycode(line, event, 0);
 636     _test_event_button(line, event, 0);
 637     _test_event_type(line, event, type);
 638     _test_event_qualifier(line, event, NULL);
 639     _test_event_reason(line, event, 0);
 640     _test_event_srcfilter(line, event);
 641     _test_event_x(line, event, xy->x);
 642     _test_event_y(line, event, xy->y);
 643     _test_event_clientx(line, event, -10);
 644     _test_event_clienty(line, event, -10);
 645     _test_event_offsetx(line, event, xy->offset_x);
 646     _test_event_offsety(line, event, xy->offset_y);
 647     _test_event_screenx(line, event, -10);
 648     _test_event_screeny(line, event, -10);
 649
 650     V_VT(&v) = VT_NULL;
 651     hres = IHTMLEventObj_get_returnValue(event, &v);
 652     ok_(__FILE__,line)(hres == S_OK, "get_returnValue failed: %08x\n", hres);
 653     ok_(__FILE__,line)(V_VT(&v) == VT_EMPTY, "V_VT(returnValue) = %d\n", V_VT(&v));
 654
 655     IHTMLEventObj_Release(event);
 656 }
 657
 658 #define elem_attach_event(a,b,c) _elem_attach_event(__LINE__,a,b,c)
 659 static void _elem_attach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 660 {
 661     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 662     VARIANT_BOOL res;
 663     BSTR name;
 664     HRESULT hres;
 665
 666     name = a2bstr(namea);
 667     hres = IHTMLElement2_attachEvent(elem, name, disp, &res);
 668     IHTMLElement2_Release(elem);
 669     SysFreeString(name);
 670     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 671     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 672 }
 673
 674 #define elem_detach_event(a,b,c) _elem_detach_event(__LINE__,a,b,c)
 675 static void _elem_detach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 676 {
 677     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 678     BSTR name;
 679     HRESULT hres;
 680
 681     name = a2bstr(namea);
 682     hres = IHTMLElement2_detachEvent(elem, name, disp);
 683     IHTMLElement2_Release(elem);
 684     SysFreeString(name);
 685     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 686 }
 687
 688 #define doc_attach_event(a,b,c) _doc_attach_event(__LINE__,a,b,c)
 689 static void _doc_attach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 690 {
 691     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 692     VARIANT_BOOL res;
 693     BSTR name;
 694     HRESULT hres;
 695
 696     name = a2bstr(namea);
 697     hres = IHTMLDocument3_attachEvent(doc3, name, disp, &res);
 698     IHTMLDocument3_Release(doc3);
 699     SysFreeString(name);
 700     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 701     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 702 }
 703
 704 #define doc_detach_event(a,b,c) _doc_detach_event(__LINE__,a,b,c)
 705 static void _doc_detach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 706 {
 707     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 708     BSTR name;
 709     HRESULT hres;
 710
 711     name = a2bstr(namea);
 712     hres = IHTMLDocument3_detachEvent(doc3, name, disp);
 713     IHTMLDocument3_Release(doc3);
 714     SysFreeString(name);
 715     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 716 }
 717
 718 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 719 {
 720     *ppv = NULL;
 721
 722     if(IsEqualGUID(riid, &IID_IUnknown)
 723        || IsEqualGUID(riid, &IID_IDispatch)
 724        || IsEqualGUID(riid, &IID_IDispatchEx))
 725         *ppv = iface;
 726     else {
 727         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 728         return E_NOINTERFACE;
 729     }
 730
 731     return S_OK;
 732 }
 733
 734 static HRESULT WINAPI Dispatch_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 735 {
 736     *ppv = NULL;
 737
 738     if(IsEqualGUID(riid, &IID_IUnknown)
 739        || IsEqualGUID(riid, &IID_IDispatch)) {
 740         *ppv = iface;
 741     }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
 742         return E_NOINTERFACE;
 743     }else {
 744         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 745         return E_NOINTERFACE;
 746     }
 747
 748     return S_OK;
 749 }
 750
 751 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 752 {
 753     return 2;
 754 }
 755
 756 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 757 {
 758     return 1;
 759 }
 760
 761 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 762 {
 763     ok(0, "unexpected call\n");
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 768                                               LCID lcid, ITypeInfo **ppTInfo)
 769 {
 770     ok(0, "unexpected call\n");
 771     return E_NOTIMPL;
 772 }
 773
 774 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 775                                                 LPOLESTR *rgszNames, UINT cNames,
 776                                                 LCID lcid, DISPID *rgDispId)
 777 {
 778     ok(0, "unexpected call\n");
 779     return E_NOTIMPL;
 780 }
 781
 782 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 783                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 784                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 785 {
 786     ok(0, "unexpected call\n");
 787     return E_NOTIMPL;
 788 }
 789
 790 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 791 {
 792     ok(0, "unexpected call\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 797         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 798 {
 799     ok(0, "unexpected call\n");
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 804 {
 805     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 810 {
 811     ok(0, "unexpected call\n");
 812     return E_NOTIMPL;
 813 }
 814
 815 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 816 {
 817     ok(0, "unexpected call\n");
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 822 {
 823     ok(0, "unexpected call\n");
 824     return E_NOTIMPL;
 825 }
 826
 827 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 828 {
 829     ok(0, "unexpected call\n");
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 834 {
 835     ok(0, "unexpected call\n");
 836     return E_NOTIMPL;
 837 }
 838
 839 #define EVENT_HANDLER_FUNC_OBJ(event) \
 840     static IDispatchExVtbl event ## FuncVtbl = { \
 841         DispatchEx_QueryInterface, \
 842         DispatchEx_AddRef, \
 843         DispatchEx_Release, \
 844         DispatchEx_GetTypeInfoCount, \
 845         DispatchEx_GetTypeInfo, \
 846         DispatchEx_GetIDsOfNames, \
 847         DispatchEx_Invoke, \
 848         DispatchEx_GetDispID, \
 849         event, \
 850         DispatchEx_DeleteMemberByName, \
 851         DispatchEx_DeleteMemberByDispID, \
 852         DispatchEx_GetMemberProperties, \
 853         DispatchEx_GetMemberName, \
 854         DispatchEx_GetNextDispID, \
 855         DispatchEx_GetNameSpaceParent \
 856     }; \
 857     static IDispatchEx event ## _obj = { &event ## FuncVtbl };
 858
 859 static HRESULT WINAPI document_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 860         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 861 {
 862     IHTMLDocument3 *doc3;
 863     CHECK_EXPECT(document_onclick);
 864     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 865     doc3 = get_doc3_iface((IUnknown*)V_DISPATCH(pdp->rgvarg));
 866     IHTMLDocument3_Release(doc3);
 867     test_event_src("DIV");
 868     test_event_obj("click", &no_xy);
 869     return S_OK;
 870 }
 871
 872 EVENT_HANDLER_FUNC_OBJ(document_onclick);
 873
 874 static HRESULT WINAPI div_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 875         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 876 {
 877     CHECK_EXPECT(div_onclick);
 878     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 879     test_event_src("DIV");
 880     return S_OK;
 881 }
 882
 883 EVENT_HANDLER_FUNC_OBJ(div_onclick);
 884
 885 static HRESULT WINAPI div_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 886         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 887 {
 888     CHECK_EXPECT(div_onclick_attached);
 889
 890     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 891     test_event_src("DIV");
 892     return S_OK;
 893 }
 894
 895 EVENT_HANDLER_FUNC_OBJ(div_onclick_attached);
 896
 897 static HRESULT WINAPI doc_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 898         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 899 {
 900     CHECK_EXPECT(doc_onclick_attached);
 901
 902     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 903     test_event_src("DIV");
 904     return S_OK;
 905 }
 906
 907 EVENT_HANDLER_FUNC_OBJ(doc_onclick_attached);
 908
 909 static HRESULT WINAPI body_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 910         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 911 {
 912     CHECK_EXPECT(body_onclick);
 913     test_event_args(&DIID_DispHTMLBody, id, wFlags, pdp, pvarRes, pei, pspCaller);
 914     test_event_src("DIV");
 915     return S_OK;
 916 }
 917
 918 EVENT_HANDLER_FUNC_OBJ(body_onclick);
 919
 920 static HRESULT WINAPI img_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 921         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 922 {
 923     CHECK_EXPECT(img_onload);
 924     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 925     test_event_src("IMG");
 926     return S_OK;
 927 }
 928
 929 EVENT_HANDLER_FUNC_OBJ(img_onload);
 930
 931 static HRESULT WINAPI img_onerror(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 932         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 933 {
 934     CHECK_EXPECT(img_onerror);
 935     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 936     test_event_src("IMG");
 937     return S_OK;
 938 }
 939
 940 EVENT_HANDLER_FUNC_OBJ(img_onerror);
 941
 942 static HRESULT WINAPI input_onfocus(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 943         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 944 {
 945     CHECK_EXPECT(input_onfocus);
 946     test_event_args(&DIID_DispHTMLInputElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
 947     test_event_src("INPUT");
 948     return S_OK;
 949 }
 950
 951 EVENT_HANDLER_FUNC_OBJ(input_onfocus);
 952
 953 static HRESULT WINAPI form_onsubmit(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 954         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 955 {
 956     CHECK_EXPECT(form_onsubmit);
 957     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 958     test_event_src("FORM");
 959
 960     V_VT(pvarRes) = VT_BOOL;
 961     V_BOOL(pvarRes) = VARIANT_FALSE;
 962     return S_OK;
 963 }
 964
 965 EVENT_HANDLER_FUNC_OBJ(form_onsubmit);
 966
 967 static HRESULT WINAPI form_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 968         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 969 {
 970     CHECK_EXPECT(form_onclick);
 971     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 972
 973     return S_OK;
 974 }
 975
 976 EVENT_HANDLER_FUNC_OBJ(form_onclick);
 977
 978 static HRESULT WINAPI submit_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 979         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 980 {
 981     CHECK_EXPECT(submit_onclick);
 982     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 983     test_event_src("INPUT");
 984
 985     V_VT(pvarRes) = VT_BOOL;
 986     V_BOOL(pvarRes) = VARIANT_FALSE;
 987     return S_OK;
 988 }
 989
 990 EVENT_HANDLER_FUNC_OBJ(submit_onclick);
 991
 992 static HRESULT WINAPI submit_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 993         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 994 {
 995     CHECK_EXPECT(submit_onclick_attached);
 996     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 997     test_event_src("INPUT");
 998
 999     V_VT(pvarRes) = VT_BOOL;
1000     V_BOOL(pvarRes) = VARIANT_FALSE;
1001     return S_OK;
1002 }
1003
1004 EVENT_HANDLER_FUNC_OBJ(submit_onclick_attached);
1005
1006 static VARIANT onclick_retval, onclick_event_retval;
1007
1008 static HRESULT WINAPI submit_onclick_setret(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1009         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1010 {
1011     IHTMLEventObj *event;
1012     HRESULT hres;
1013
1014     CHECK_EXPECT(submit_onclick_setret);
1015     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1016     test_event_src("INPUT");
1017
1018     event = NULL;
1019     hres = IHTMLWindow2_get_event(window, &event);
1020     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1021     ok(event != NULL, "event == NULL\n");
1022
1023     hres = IHTMLEventObj_put_returnValue(event, onclick_event_retval);
1024     ok(hres == S_OK, "put_returnValue failed: %08x\n", hres);
1025     IHTMLEventObj_Release(event);
1026
1027     *pvarRes = onclick_retval;
1028     return S_OK;
1029 }
1030
1031 EVENT_HANDLER_FUNC_OBJ(submit_onclick_setret);
1032
1033 static HRESULT WINAPI iframedoc_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1034         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1035 {
1036     IHTMLEventObj *event = NULL;
1037     HRESULT hres;
1038
1039     CHECK_EXPECT2(iframedoc_onreadystatechange);
1040     test_event_args(&DIID_DispHTMLDocument, id, wFlags, pdp, pvarRes, pei, pspCaller);
1041
1042     event = (void*)0xdeadbeef;
1043     hres = IHTMLWindow2_get_event(window, &event);
1044     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1045     ok(!event, "event = %p\n", event);
1046
1047     return S_OK;
1048 }
1049
1050 EVENT_HANDLER_FUNC_OBJ(iframedoc_onreadystatechange);
1051
1052 static HRESULT WINAPI iframe_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1053         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1054 {
1055     IHTMLWindow2 *iframe_window;
1056     IHTMLDocument2 *iframe_doc;
1057     IHTMLFrameBase2 *iframe;
1058     IHTMLElement2 *elem2;
1059     IHTMLElement *elem;
1060     VARIANT v;
1061     BSTR str, str2;
1062     HRESULT hres;
1063
1064     test_event_args(&DIID_DispHTMLIFrame, id, wFlags, pdp, pvarRes, pei, pspCaller);
1065     test_event_src("IFRAME");
1066
1067     elem = get_event_src();
1068     elem2 = get_elem2_iface((IUnknown*)elem);
1069     IHTMLElement_Release(elem);
1070
1071     V_VT(&v) = VT_EMPTY;
1072     hres = IHTMLElement2_get_readyState(elem2, &v);
1073     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1074     ok(V_VT(&v) == VT_BSTR, "V_VT(readyState) = %d\n", V_VT(&v));
1075
1076     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase2, (void**)&iframe);
1077     IHTMLElement2_Release(elem2);
1078     ok(hres == S_OK, "Could not get IHTMLFrameBase2 iface: %08x\n", hres);
1079
1080     str = NULL;
1081     hres = IHTMLFrameBase2_get_readyState(iframe, &str);
1082     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1083     ok(str != NULL, "readyState == NULL\n");
1084     ok(!lstrcmpW(str, V_BSTR(&v)), "ready states differ\n");
1085     VariantClear(&v);
1086
1087     hres = IHTMLFrameBase2_get_contentWindow(iframe, &iframe_window);
1088     ok(hres == S_OK, "get_contentDocument failed: %08x\n", hres);
1089
1090     hres = IHTMLWindow2_get_document(iframe_window, &iframe_doc);
1091     IHTMLWindow2_Release(iframe_window);
1092     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1093
1094     hres = IHTMLDocument2_get_readyState(iframe_doc, &str2);
1095     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1096     ok(!lstrcmpW(str, str2), "unexpected document readyState %s\n", wine_dbgstr_w(str2));
1097     SysFreeString(str2);
1098
1099     if(!strcmp_wa(str, "loading")) {
1100         CHECK_EXPECT(iframe_onreadystatechange_loading);
1101
1102         V_VT(&v) = VT_DISPATCH;
1103         V_DISPATCH(&v) = (IDispatch*)&iframedoc_onreadystatechange_obj;
1104         hres = IHTMLDocument2_put_onreadystatechange(iframe_doc, v);
1105         ok(hres == S_OK, "put_onreadystatechange: %08x\n", hres);
1106     }else if(!strcmp_wa(str, "interactive"))
1107         CHECK_EXPECT(iframe_onreadystatechange_interactive);
1108     else if(!strcmp_wa(str, "complete"))
1109         CHECK_EXPECT(iframe_onreadystatechange_complete);
1110     else
1111         ok(0, "unexpected state %s\n", wine_dbgstr_w(str));
1112
1113     SysFreeString(str);
1114     IHTMLDocument2_Release(iframe_doc);
1115     IHTMLFrameBase2_Release(iframe);
1116     return S_OK;
1117 }
1118
1119 EVENT_HANDLER_FUNC_OBJ(iframe_onreadystatechange);
1120
1121 static HRESULT WINAPI nocall(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1122         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1123 {
1124     ok(0, "unexpected call\n");
1125     return S_OK;
1126 }
1127
1128 EVENT_HANDLER_FUNC_OBJ(nocall);
1129
1130 #define CONNECTION_POINT_OBJ(cpname, diid) \
1131     static HRESULT WINAPI cpname ## _QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) \
1132     { \
1133         *ppv = NULL; \
1134         if(IsEqualGUID(riid, &IID_IUnknown) \
1135            || IsEqualGUID(riid, &IID_IDispatch) \
1136            || IsEqualGUID(riid, &diid)) \
1137             *ppv = iface; \
1138         else { \
1139             ok(0, "unexpected riid %s\n", debugstr_guid(riid)); \
1140             return E_NOINTERFACE; \
1141         } \
1142         return S_OK; \
1143     } \
1144     static IDispatchExVtbl cpname ## Vtbl = { \
1145         cpname ## _QueryInterface, \
1146         DispatchEx_AddRef,  \
1147         DispatchEx_Release, \
1148         DispatchEx_GetTypeInfoCount, \
1149         DispatchEx_GetTypeInfo, \
1150         DispatchEx_GetIDsOfNames, \
1151         cpname, \
1152         DispatchEx_GetDispID, \
1153         DispatchEx_InvokeEx, \
1154         DispatchEx_DeleteMemberByName, \
1155         DispatchEx_DeleteMemberByDispID, \
1156         DispatchEx_GetMemberProperties, \
1157         DispatchEx_GetMemberName, \
1158         DispatchEx_GetNextDispID, \
1159         DispatchEx_GetNameSpaceParent \
1160     }; \
1161     static IDispatchEx cpname ## _obj = { &cpname ## Vtbl }
1162
1163 #define test_cp_args(a,b,c,d,e,f) _test_cp_args(__LINE__,a,b,c,d,e,f)
1164 static void _test_cp_args(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
1165 {
1166     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
1167     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
1168     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
1169     ok_(__FILE__,line)(!dp->cArgs, "dp->cArgs = %d\n", dp->cArgs);
1170     ok_(__FILE__,line)(!dp->rgvarg, "dp->rgvarg = %p\n", dp->rgvarg);
1171     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
1172     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
1173     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
1174     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
1175     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
1176     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
1177 }
1178
1179 static HRESULT WINAPI doccp(IDispatchEx *iface, DISPID dispIdMember,
1180                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1181                             VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1182 {
1183     switch(dispIdMember) {
1184     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1185         CHECK_EXPECT(doccp_onclick);
1186         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1187         break;
1188     default:
1189         ok(0, "unexpected call %d\n", dispIdMember);
1190         return E_NOTIMPL;
1191     }
1192
1193     return S_OK;
1194 }
1195
1196 CONNECTION_POINT_OBJ(doccp, DIID_HTMLDocumentEvents);
1197
1198 static HRESULT WINAPI doccp_onclick_cancel(IDispatchEx *iface, DISPID dispIdMember,
1199         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1200 {
1201     switch(dispIdMember) {
1202     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1203         CHECK_EXPECT(doccp_onclick_cancel);
1204         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1205         V_VT(pVarResult) = VT_BOOL;
1206         V_BOOL(pVarResult) = VARIANT_FALSE;
1207         break;
1208     default:
1209         ok(0, "unexpected call %d\n", dispIdMember);
1210         return E_NOTIMPL;
1211     }
1212
1213     return S_OK;
1214 }
1215
1216 CONNECTION_POINT_OBJ(doccp_onclick_cancel, DIID_HTMLDocumentEvents);
1217
1218 static HRESULT WINAPI timeoutFunc_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1219                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1220                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1221 {
1222     CHECK_EXPECT(timeout);
1223
1224     ok(dispIdMember == DISPID_VALUE, "dispIdMember = %d\n", dispIdMember);
1225     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
1226     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
1227     ok(!lcid, "lcid = %x\n", lcid);
1228     ok(pDispParams != NULL, "pDispParams == NULL\n");
1229     ok(!pDispParams->cArgs, "pdp->cArgs = %d\n", pDispParams->cArgs);
1230     ok(!pDispParams->cNamedArgs, "pdp->cNamedArgs = %d\n", pDispParams->cNamedArgs);
1231     ok(!pDispParams->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
1232     ok(!pDispParams->rgvarg, "rgvarg = %p\n", pDispParams->rgvarg);
1233     ok(pVarResult != NULL, "pVarResult = NULL\n");
1234     ok(pExcepInfo != NULL, "pExcepInfo = NULL\n");
1235     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1236     ok(V_VT(pVarResult) == VT_EMPTY, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1237
1238     return S_OK;
1239 }
1240
1241 static const IDispatchExVtbl timeoutFuncVtbl = {
1242     DispatchEx_QueryInterface,
1243     DispatchEx_AddRef,
1244     DispatchEx_Release,
1245     DispatchEx_GetTypeInfoCount,
1246     DispatchEx_GetTypeInfo,
1247     DispatchEx_GetIDsOfNames,
1248     timeoutFunc_Invoke,
1249     DispatchEx_GetDispID,
1250     DispatchEx_InvokeEx,
1251     DispatchEx_DeleteMemberByName,
1252     DispatchEx_DeleteMemberByDispID,
1253     DispatchEx_GetMemberProperties,
1254     DispatchEx_GetMemberName,
1255     DispatchEx_GetNextDispID,
1256     DispatchEx_GetNameSpaceParent
1257 };
1258
1259 static IDispatchEx timeoutFunc = { &timeoutFuncVtbl };
1260
1261 static HRESULT WINAPI div_onclick_disp_Invoke(IDispatchEx *iface, DISPID id,
1262         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1263         VARIANT *pvarRes, EXCEPINFO *pei, UINT *puArgErr)
1264 {
1265     CHECK_EXPECT(div_onclick_disp);
1266
1267     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1268
1269     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
1270     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1271
1272     return S_OK;
1273 }
1274
1275 static const IDispatchExVtbl div_onclick_dispVtbl = {
1276     Dispatch_QueryInterface,
1277     DispatchEx_AddRef,
1278     DispatchEx_Release,
1279     DispatchEx_GetTypeInfoCount,
1280     DispatchEx_GetTypeInfo,
1281     DispatchEx_GetIDsOfNames,
1282     div_onclick_disp_Invoke,
1283 };
1284
1285 static IDispatchEx div_onclick_disp = { &div_onclick_dispVtbl };
1286
1287 static void pump_msgs(BOOL *b)
1288 {
1289     MSG msg;
1290
1291     if(b) {
1292         while(!*b && GetMessageW(&msg, NULL, 0, 0)) {
1293             TranslateMessage(&msg);
1294             DispatchMessage(&msg);
1295         }
1296     }else {
1297         while(!b && PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) {
1298             TranslateMessage(&msg);
1299             DispatchMessage(&msg);
1300         }
1301     }
1302 }
1303
1304 static IConnectionPoint *get_cp(IUnknown *unk, REFIID riid)
1305 {
1306     IConnectionPointContainer *cp_container;
1307     IConnectionPoint *cp;
1308     HRESULT hres;
1309
1310     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&cp_container);
1311     ok(hres == S_OK, "Could not get IConnectionPointContainer: %08x\n", hres);
1312
1313     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, riid, &cp);
1314     IConnectionPointContainer_Release(cp_container);
1315     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1316
1317     return cp;
1318 }
1319
1320 static DWORD register_cp(IUnknown *unk, REFIID riid, IUnknown *sink)
1321 {
1322     IConnectionPoint *cp;
1323     DWORD cookie;
1324     HRESULT hres;
1325
1326     cp = get_cp(unk, riid);
1327     hres = IConnectionPoint_Advise(cp, sink, &cookie);
1328     IConnectionPoint_Release(cp);
1329     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1330
1331     return cookie;
1332 }
1333
1334 static void unregister_cp(IUnknown *unk, REFIID riid, DWORD cookie)
1335 {
1336     IConnectionPoint *cp;
1337     HRESULT hres;
1338
1339     cp = get_cp(unk, riid);
1340     hres = IConnectionPoint_Unadvise(cp, cookie);
1341     IConnectionPoint_Release(cp);
1342     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
1343 }
1344
1345 static HRESULT WINAPI EventDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1346 {
1347     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
1348         *ppv = iface;
1349         return S_OK;
1350     }
1351
1352     ok(0, "Unexpected call\n");
1353     return E_NOINTERFACE;
1354 }
1355
1356 static DWORD WINAPI EventDispatch_AddRef(IDispatch *iface)
1357 {
1358     return 2;
1359 }
1360
1361 static DWORD WINAPI EventDispatch_Release(IDispatch *iface)
1362 {
1363     return 1;
1364 }
1365
1366 static HRESULT WINAPI EventDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1367 {
1368     ok(0, "Unexpected call\n");
1369     return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI EventDispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1373 {
1374     ok(0, "Unexpected call\n");
1375     return E_NOTIMPL;
1376 }
1377
1378 static HRESULT WINAPI EventDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
1379         UINT cNames, LCID lcid, DISPID *rgDispId)
1380 {
1381     ok(0, "Unexpected call\n");
1382     return E_NOTIMPL;
1383 }
1384
1385 static HRESULT WINAPI EventDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1386         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1387         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1388 {
1389     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
1390     ok(pDispParams != NULL, "pDispParams == NULL\n");
1391     ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
1392     ok(puArgErr != NULL, "puArgErr == NULL\n");
1393     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1394     ok(wFlags == DISPATCH_METHOD, "wFlags = %d\n", wFlags);
1395
1396     switch(dispIdMember) {
1397     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1398         CHECK_EXPECT2(invoke_onclick);
1399         break;
1400     case DISPID_HTMLDOCUMENTEVENTS2_ONPROPERTYCHANGE:
1401     case DISPID_HTMLDOCUMENTEVENTS2_ONREADYSTATECHANGE:
1402     case 1027:
1403     case 1034:
1404     case 1037:
1405     case 1044:
1406     case 1045:
1407     case 1047:
1408     case 1048:
1409     case 1049:
1410         break; /* TODO */
1411     default:
1412         ok(0, "Unexpected call: %d\n", dispIdMember);
1413     }
1414
1415     return S_OK;
1416 }
1417
1418 static const IDispatchVtbl EventDispatchVtbl = {
1419     EventDispatch_QueryInterface,
1420     EventDispatch_AddRef,
1421     EventDispatch_Release,
1422     EventDispatch_GetTypeInfoCount,
1423     EventDispatch_GetTypeInfo,
1424     EventDispatch_GetIDsOfNames,
1425     EventDispatch_Invoke
1426 };
1427
1428 static IDispatch EventDispatch = { &EventDispatchVtbl };
1429
1430 static void test_onclick(IHTMLDocument2 *doc)
1431 {
1432     IHTMLElement *div, *body;
1433     DWORD cp_cookie;
1434     VARIANT v;
1435     HRESULT hres;
1436
1437     register_cp((IUnknown*)doc, &IID_IDispatch, (IUnknown*)&EventDispatch);
1438
1439     div = get_elem_id(doc, "clickdiv");
1440
1441     elem_attach_event((IUnknown*)div, "abcde", (IDispatch*)&nocall_obj);
1442     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_attached_obj);
1443
1444     V_VT(&v) = VT_EMPTY;
1445     hres = IHTMLElement_get_onclick(div, &v);
1446     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1447     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1448
1449     V_VT(&v) = VT_EMPTY;
1450     hres = IHTMLElement_put_onclick(div, v);
1451     ok(hres == E_NOTIMPL, "put_onclick failed: %08x\n", hres);
1452
1453     V_VT(&v) = VT_BSTR;
1454     V_BSTR(&v) = a2bstr("function();");
1455     hres = IHTMLElement_put_onclick(div, v);
1456     todo_wine ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1457
1458     if(hres == S_OK) {
1459         V_VT(&v) = VT_EMPTY;
1460         hres = IHTMLElement_get_onclick(div, &v);
1461         ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1462         ok(V_VT(&v) == VT_BSTR, "V_VT(onclick) = %d\n", V_VT(&v));
1463         ok(!strcmp_wa(V_BSTR(&v), "function();"), "V_BSTR(onclick) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1464     }
1465     VariantClear(&v);
1466
1467     V_VT(&v) = VT_DISPATCH;
1468     V_DISPATCH(&v) = (IDispatch*)&div_onclick_obj;
1469     hres = IHTMLElement_put_onclick(div, v);
1470     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1471
1472     V_VT(&v) = VT_NULL;
1473     hres = IHTMLElement_put_ondblclick(div, v);
1474     ok(hres == S_OK, "put_ondblclick failed: %08x\n", hres);
1475
1476     V_VT(&v) = VT_EMPTY;
1477     hres = IHTMLElement_get_onclick(div, &v);
1478     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1479     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1480     ok(V_DISPATCH(&v) == (IDispatch*)&div_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1481     VariantClear(&v);
1482
1483     V_VT(&v) = VT_EMPTY;
1484     hres = IHTMLDocument2_get_onclick(doc, &v);
1485     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1486     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1487
1488     V_VT(&v) = VT_DISPATCH;
1489     V_DISPATCH(&v) = (IDispatch*)&document_onclick_obj;
1490     hres = IHTMLDocument2_put_onclick(doc, v);
1491     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1492
1493     V_VT(&v) = VT_EMPTY;
1494     hres = IHTMLDocument2_get_onclick(doc, &v);
1495     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1496     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1497     ok(V_DISPATCH(&v) == (IDispatch*)&document_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1498     VariantClear(&v);
1499
1500     body = doc_get_body(doc);
1501
1502     V_VT(&v) = VT_DISPATCH;
1503     V_DISPATCH(&v) = (IDispatch*)&body_onclick_obj;
1504     hres = IHTMLElement_put_onclick(body, v);
1505     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1506
1507     if(winetest_interactive) {
1508         SET_EXPECT(div_onclick);
1509         SET_EXPECT(div_onclick_attached);
1510         SET_EXPECT(body_onclick);
1511         SET_EXPECT(document_onclick);
1512         SET_EXPECT(invoke_onclick);
1513         pump_msgs(&called_document_onclick);
1514         CHECK_CALLED(div_onclick);
1515         CHECK_CALLED(div_onclick_attached);
1516         CHECK_CALLED(body_onclick);
1517         CHECK_CALLED(document_onclick);
1518         CHECK_CALLED(invoke_onclick);
1519     }
1520
1521     xy_todo = TRUE;
1522
1523     SET_EXPECT(div_onclick);
1524     SET_EXPECT(div_onclick_attached);
1525     SET_EXPECT(body_onclick);
1526     SET_EXPECT(document_onclick);
1527     SET_EXPECT(invoke_onclick);
1528
1529     hres = IHTMLElement_click(div);
1530     ok(hres == S_OK, "click failed: %08x\n", hres);
1531
1532     CHECK_CALLED(div_onclick);
1533     CHECK_CALLED(div_onclick_attached);
1534     CHECK_CALLED(body_onclick);
1535     CHECK_CALLED(document_onclick);
1536     CHECK_CALLED(invoke_onclick);
1537
1538     SET_EXPECT(div_onclick);
1539     SET_EXPECT(div_onclick_attached);
1540     SET_EXPECT(body_onclick);
1541     SET_EXPECT(document_onclick);
1542     SET_EXPECT(invoke_onclick);
1543
1544     V_VT(&v) = VT_EMPTY;
1545     elem_fire_event((IUnknown*)div, "onclick", &v);
1546
1547     CHECK_CALLED(div_onclick);
1548     CHECK_CALLED(div_onclick_attached);
1549     CHECK_CALLED(body_onclick);
1550     CHECK_CALLED(document_onclick);
1551     CHECK_CALLED(invoke_onclick);
1552
1553     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_obj);
1554     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1555     doc_attach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1556
1557     SET_EXPECT(div_onclick);
1558     SET_EXPECT(div_onclick_disp);
1559     SET_EXPECT(div_onclick_attached);
1560     SET_EXPECT(body_onclick);
1561     SET_EXPECT(document_onclick);
1562     SET_EXPECT(doc_onclick_attached);
1563     SET_EXPECT(doccp_onclick);
1564     SET_EXPECT(invoke_onclick);
1565
1566     hres = IHTMLElement_click(div);
1567     ok(hres == S_OK, "click failed: %08x\n", hres);
1568
1569     CHECK_CALLED(div_onclick);
1570     CHECK_CALLED(div_onclick_disp);
1571     CHECK_CALLED(div_onclick_attached);
1572     CHECK_CALLED(body_onclick);
1573     CHECK_CALLED(document_onclick);
1574     CHECK_CALLED(doc_onclick_attached);
1575     CHECK_CALLED(doccp_onclick);
1576     CHECK_CALLED(invoke_onclick);
1577
1578     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1579
1580     V_VT(&v) = VT_NULL;
1581     hres = IHTMLElement_put_onclick(div, v);
1582     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1583
1584     hres = IHTMLElement_get_onclick(div, &v);
1585     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1586     ok(V_VT(&v) == VT_NULL, "get_onclick returned vt %d\n", V_VT(&v));
1587
1588     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1589     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1590     elem_detach_event((IUnknown*)div, "test", (IDispatch*)&div_onclick_disp);
1591     doc_detach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1592
1593     SET_EXPECT(div_onclick_attached);
1594     SET_EXPECT(body_onclick);
1595     SET_EXPECT(document_onclick);
1596     SET_EXPECT(invoke_onclick);
1597
1598     hres = IHTMLElement_click(div);
1599     ok(hres == S_OK, "click failed: %08x\n", hres);
1600
1601     CHECK_CALLED(div_onclick_attached);
1602     CHECK_CALLED(body_onclick);
1603     CHECK_CALLED(document_onclick);
1604     CHECK_CALLED(invoke_onclick);
1605
1606     IHTMLElement_Release(div);
1607     IHTMLElement_Release(body);
1608 }
1609
1610 static void test_onreadystatechange(IHTMLDocument2 *doc)
1611 {
1612     IHTMLFrameBase *iframe;
1613     IHTMLElement2 *elem2;
1614     IHTMLElement *elem;
1615     VARIANT v;
1616     BSTR str;
1617     HRESULT hres;
1618
1619     elem = get_elem_id(doc, "iframe");
1620     elem2 = get_elem2_iface((IUnknown*)elem);
1621     IHTMLElement_Release(elem);
1622
1623     V_VT(&v) = VT_EMPTY;
1624     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1625     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1626     ok(V_VT(&v) == VT_NULL, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1627
1628     V_VT(&v) = VT_DISPATCH;
1629     V_DISPATCH(&v) = (IDispatch*)&iframe_onreadystatechange_obj;
1630     hres = IHTMLElement2_put_onreadystatechange(elem2, v);
1631     ok(hres == S_OK, "put_onreadystatechange failed: %08x\n", hres);
1632
1633     V_VT(&v) = VT_EMPTY;
1634     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1635     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1636     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1637     ok(V_DISPATCH(&v) == (IDispatch*)&iframe_onreadystatechange_obj, "unexpected onreadystatechange value\n");
1638
1639     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase, (void**)&iframe);
1640     IHTMLElement2_Release(elem2);
1641     ok(hres == S_OK, "Could not get IHTMLFrameBase iface: %08x\n", hres);
1642
1643     hres = IHTMLFrameBase_put_src(iframe, (str = a2bstr("about:blank")));
1644     SysFreeString(str);
1645     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1646
1647     SET_EXPECT(iframe_onreadystatechange_loading);
1648     SET_EXPECT(iframedoc_onreadystatechange);
1649     SET_EXPECT(iframe_onreadystatechange_interactive);
1650     SET_EXPECT(iframe_onreadystatechange_complete);
1651     pump_msgs(&called_iframe_onreadystatechange_complete);
1652     CHECK_CALLED(iframe_onreadystatechange_loading);
1653     CHECK_CALLED(iframedoc_onreadystatechange);
1654     CHECK_CALLED(iframe_onreadystatechange_interactive);
1655     CHECK_CALLED(iframe_onreadystatechange_complete);
1656
1657     IHTMLFrameBase_Release(iframe);
1658 }
1659
1660 static void test_imgload(IHTMLDocument2 *doc)
1661 {
1662     IHTMLImgElement *img;
1663     IHTMLElement *elem;
1664     VARIANT v;
1665     BSTR str;
1666     HRESULT hres;
1667
1668     elem = get_elem_id(doc, "imgid");
1669     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLImgElement, (void**)&img);
1670     IHTMLElement_Release(elem);
1671     ok(hres == S_OK, "Could not get IHTMLImgElement iface: %08x\n", hres);
1672
1673     V_VT(&v) = VT_EMPTY;
1674     hres = IHTMLImgElement_get_onload(img, &v);
1675     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1676     ok(V_VT(&v) == VT_NULL, "V_VT(onload) = %d\n", V_VT(&v));
1677
1678     V_VT(&v) = VT_DISPATCH;
1679     V_DISPATCH(&v) = (IDispatch*)&img_onload_obj;
1680     hres = IHTMLImgElement_put_onload(img, v);
1681     ok(hres == S_OK, "put_onload failed: %08x\n", hres);
1682
1683     V_VT(&v) = VT_EMPTY;
1684     hres = IHTMLImgElement_get_onload(img, &v);
1685     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1686     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onload) = %d\n", V_VT(&v));
1687     ok(V_DISPATCH(&v) == (IDispatch*)&img_onload_obj, "V_DISPATCH(onload) != onloadkFunc\n");
1688     VariantClear(&v);
1689
1690     V_VT(&v) = VT_DISPATCH;
1691     V_DISPATCH(&v) = (IDispatch*)&img_onerror_obj;
1692     hres = IHTMLImgElement_put_onerror(img, v);
1693     ok(hres == S_OK, "put_onerror failed: %08x\n", hres);
1694
1695     V_VT(&v) = VT_EMPTY;
1696     hres = IHTMLImgElement_get_onerror(img, &v);
1697     ok(hres == S_OK, "get_onerror failed: %08x\n", hres);
1698     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onerror) = %d\n", V_VT(&v));
1699     ok(V_DISPATCH(&v) == (IDispatch*)&img_onerror_obj, "V_DISPATCH(onerror) != onerrorFunc\n");
1700     VariantClear(&v);
1701
1702     str = a2bstr("http://www.winehq.org/images/winehq_logo_text.png");
1703     hres = IHTMLImgElement_put_src(img, str);
1704     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1705     SysFreeString(str);
1706
1707     SET_EXPECT(img_onload);
1708     pump_msgs(&called_img_onload);
1709     CHECK_CALLED(img_onload);
1710
1711     SET_EXPECT(img_onerror);
1712
1713     str = a2bstr("about:blank");
1714     hres = IHTMLImgElement_put_src(img, str);
1715     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1716     SysFreeString(str);
1717
1718     pump_msgs(&called_img_onerror); /* FIXME: should not be needed */
1719
1720     CHECK_CALLED(img_onerror);
1721
1722     IHTMLImgElement_Release(img);
1723 }
1724
1725 static void test_focus(IHTMLDocument2 *doc)
1726 {
1727     IHTMLElement2 *elem2;
1728     IHTMLElement *elem;
1729     VARIANT v;
1730     HRESULT hres;
1731
1732     elem = get_elem_id(doc, "inputid");
1733     elem2 = get_elem2_iface((IUnknown*)elem);
1734     IHTMLElement_Release(elem);
1735
1736     V_VT(&v) = VT_EMPTY;
1737     hres = IHTMLElement2_get_onfocus(elem2, &v);
1738     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
1739     ok(V_VT(&v) == VT_NULL, "V_VT(onfocus) = %d\n", V_VT(&v));
1740
1741     V_VT(&v) = VT_DISPATCH;
1742     V_DISPATCH(&v) = (IDispatch*)&input_onfocus_obj;
1743     hres = IHTMLElement2_put_onfocus(elem2, v);
1744     ok(hres == S_OK, "put_onfocus failed: %08x\n", hres);
1745
1746     V_VT(&v) = VT_EMPTY;
1747     hres = IHTMLElement2_get_onfocus(elem2, &v);
1748     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
1749     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onfocus) = %d\n", V_VT(&v));
1750     ok(V_DISPATCH(&v) == (IDispatch*)&input_onfocus_obj, "V_DISPATCH(onfocus) != onfocusFunc\n");
1751     VariantClear(&v);
1752
1753     if(!winetest_interactive)
1754         ShowWindow(container_hwnd, SW_SHOW);
1755
1756     SetFocus(NULL);
1757     ok(!IsChild(container_hwnd, GetFocus()), "focus belongs to document window\n");
1758
1759     hres = IHTMLWindow2_focus(window);
1760     ok(hres == S_OK, "focus failed: %08x\n", hres);
1761
1762     ok(IsChild(container_hwnd, GetFocus()), "focus does not belong to document window\n");
1763     pump_msgs(NULL);
1764
1765     SET_EXPECT(input_onfocus);
1766     hres = IHTMLElement2_focus(elem2);
1767     pump_msgs(NULL);
1768     CHECK_CALLED(input_onfocus);
1769     ok(hres == S_OK, "focus failed: %08x\n", hres);
1770
1771     if(!winetest_interactive)
1772         ShowWindow(container_hwnd, SW_HIDE);
1773
1774     IHTMLElement2_Release(elem2);
1775 }
1776
1777 static void test_submit(IHTMLDocument2 *doc)
1778 {
1779     IHTMLElement *elem, *submit;
1780     IHTMLFormElement *form;
1781     VARIANT v;
1782     DWORD cp_cookie;
1783     HRESULT hres;
1784
1785     elem = get_elem_id(doc, "formid");
1786
1787     V_VT(&v) = VT_DISPATCH;
1788     V_DISPATCH(&v) = (IDispatch*)&form_onclick_obj;
1789     hres = IHTMLElement_put_onclick(elem, v);
1790     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1791
1792     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLFormElement, (void**)&form);
1793     IHTMLElement_Release(elem);
1794     ok(hres == S_OK, "Could not get IHTMLFormElement iface: %08x\n", hres);
1795
1796     V_VT(&v) = VT_DISPATCH;
1797     V_DISPATCH(&v) = (IDispatch*)&form_onsubmit_obj;
1798     hres = IHTMLFormElement_put_onsubmit(form, v);
1799     ok(hres == S_OK, "put_onsubmit failed: %08x\n", hres);
1800
1801     IHTMLFormElement_Release(form);
1802
1803     submit = get_elem_id(doc, "submitid");
1804
1805     SET_EXPECT(form_onclick);
1806     SET_EXPECT(form_onsubmit);
1807     hres = IHTMLElement_click(submit);
1808     ok(hres == S_OK, "click failed: %08x\n", hres);
1809     CHECK_CALLED(form_onclick);
1810     CHECK_CALLED(form_onsubmit);
1811
1812     V_VT(&v) = VT_DISPATCH;
1813     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_obj;
1814     hres = IHTMLElement_put_onclick(submit, v);
1815     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1816
1817     SET_EXPECT(form_onclick);
1818     SET_EXPECT(submit_onclick);
1819     hres = IHTMLElement_click(submit);
1820     ok(hres == S_OK, "click failed: %08x\n", hres);
1821     CHECK_CALLED(form_onclick);
1822     CHECK_CALLED(submit_onclick);
1823
1824     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
1825
1826     SET_EXPECT(form_onclick);
1827     SET_EXPECT(submit_onclick);
1828     SET_EXPECT(submit_onclick_attached);
1829     hres = IHTMLElement_click(submit);
1830     ok(hres == S_OK, "click failed: %08x\n", hres);
1831     CHECK_CALLED(form_onclick);
1832     CHECK_CALLED(submit_onclick);
1833     CHECK_CALLED(submit_onclick_attached);
1834
1835     V_VT(&v) = VT_NULL;
1836     hres = IHTMLElement_put_onclick(submit, v);
1837     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1838
1839     SET_EXPECT(form_onclick);
1840     SET_EXPECT(submit_onclick_attached);
1841     hres = IHTMLElement_click(submit);
1842     ok(hres == S_OK, "click failed: %08x\n", hres);
1843     CHECK_CALLED(form_onclick);
1844     CHECK_CALLED(submit_onclick_attached);
1845
1846     elem_detach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
1847
1848     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_onclick_cancel_obj);
1849
1850     SET_EXPECT(form_onclick);
1851     SET_EXPECT(doccp_onclick_cancel);
1852     hres = IHTMLElement_click(submit);
1853     ok(hres == S_OK, "click failed: %08x\n", hres);
1854     CHECK_CALLED(form_onclick);
1855     CHECK_CALLED(doccp_onclick_cancel);
1856
1857     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1858
1859     V_VT(&v) = VT_DISPATCH;
1860     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_setret_obj;
1861     hres = IHTMLElement_put_onclick(submit, v);
1862     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1863
1864     V_VT(&onclick_retval) = VT_BOOL;
1865     V_BOOL(&onclick_retval) = VARIANT_TRUE;
1866     V_VT(&onclick_event_retval) = VT_BOOL;
1867     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
1868
1869     SET_EXPECT(submit_onclick_setret);
1870     SET_EXPECT(form_onclick);
1871     SET_EXPECT(form_onsubmit);
1872     hres = IHTMLElement_click(submit);
1873     ok(hres == S_OK, "click failed: %08x\n", hres);
1874     CHECK_CALLED(submit_onclick_setret);
1875     CHECK_CALLED(form_onclick);
1876     CHECK_CALLED(form_onsubmit);
1877
1878     V_VT(&onclick_event_retval) = VT_BOOL;
1879     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
1880
1881     SET_EXPECT(submit_onclick_setret);
1882     SET_EXPECT(form_onclick);
1883     hres = IHTMLElement_click(submit);
1884     ok(hres == S_OK, "click failed: %08x\n", hres);
1885     CHECK_CALLED(submit_onclick_setret);
1886     CHECK_CALLED(form_onclick);
1887
1888     V_VT(&onclick_retval) = VT_BOOL;
1889     V_BOOL(&onclick_retval) = VARIANT_FALSE;
1890     V_VT(&onclick_event_retval) = VT_BOOL;
1891     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
1892
1893     SET_EXPECT(submit_onclick_setret);
1894     SET_EXPECT(form_onclick);
1895     hres = IHTMLElement_click(submit);
1896     ok(hres == S_OK, "click failed: %08x\n", hres);
1897     CHECK_CALLED(submit_onclick_setret);
1898     CHECK_CALLED(form_onclick);
1899
1900     V_VT(&onclick_event_retval) = VT_BOOL;
1901     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
1902
1903     SET_EXPECT(submit_onclick_setret);
1904     SET_EXPECT(form_onclick);
1905     hres = IHTMLElement_click(submit);
1906     ok(hres == S_OK, "click failed: %08x\n", hres);
1907     CHECK_CALLED(submit_onclick_setret);
1908     CHECK_CALLED(form_onclick);
1909
1910     IHTMLElement_Release(submit);
1911 }
1912
1913 static void test_timeout(IHTMLDocument2 *doc)
1914 {
1915     IHTMLWindow3 *win3;
1916     VARIANT expr, var;
1917     LONG id;
1918     HRESULT hres;
1919
1920     hres = IHTMLWindow2_QueryInterface(window, &IID_IHTMLWindow3, (void**)&win3);
1921     ok(hres == S_OK, "Could not get IHTMLWindow3 iface: %08x\n", hres);
1922
1923     V_VT(&expr) = VT_DISPATCH;
1924     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
1925     V_VT(&var) = VT_EMPTY;
1926     id = 0;
1927     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
1928     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
1929     ok(id, "id = 0\n");
1930
1931     SET_EXPECT(timeout);
1932     pump_msgs(&called_timeout);
1933     CHECK_CALLED(timeout);
1934
1935     V_VT(&expr) = VT_DISPATCH;
1936     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
1937     V_VT(&var) = VT_EMPTY;
1938     id = 0;
1939     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
1940     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
1941     ok(id, "id = 0\n");
1942
1943     hres = IHTMLWindow2_clearTimeout(window, id);
1944     ok(hres == S_OK, "clearTimeout failed: %08x\n", hres);
1945
1946     IHTMLWindow3_Release(win3);
1947 }
1948
1949 static IHTMLElement* find_element_by_id(IHTMLDocument2 *doc, const char *id)
1950 {
1951     HRESULT hres;
1952     IHTMLDocument3 *doc3;
1953     IHTMLElement *result;
1954     BSTR idW = a2bstr(id);
1955
1956     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1957     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument3) failed: %08x\n", hres);
1958
1959     hres = IHTMLDocument3_getElementById(doc3, idW, &result);
1960     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1961     ok(result != NULL, "result == NULL\n");
1962     SysFreeString(idW);
1963
1964     IHTMLDocument3_Release(doc3);
1965     return result;
1966 }
1967
1968 static IHTMLDocument2* get_iframe_doc(IHTMLIFrameElement *iframe)
1969 {
1970     HRESULT hres;
1971     IHTMLFrameBase2 *base;
1972     IHTMLDocument2 *result = NULL;
1973
1974     hres = IHTMLIFrameElement_QueryInterface(iframe, &IID_IHTMLFrameBase2, (void**)&base);
1975     ok(hres == S_OK, "QueryInterface(IID_IHTMLFrameBase2) failed: %08x\n", hres);
1976     if(hres == S_OK) {
1977         IHTMLWindow2 *window;
1978
1979         hres = IHTMLFrameBase2_get_contentWindow(base, &window);
1980         ok(hres == S_OK, "get_contentWindow failed: %08x\n", hres);
1981         ok(window != NULL, "window == NULL\n");
1982         if(window) {
1983             hres = IHTMLWindow2_get_document(window, &result);
1984             ok(hres == S_OK, "get_document failed: %08x\n", hres);
1985             ok(result != NULL, "result == NULL\n");
1986             IHTMLWindow2_Release(window);
1987         }
1988     }
1989     if(base) IHTMLFrameBase2_Release(base);
1990
1991     return result;
1992 }
1993
1994 static void test_iframe_connections(IHTMLDocument2 *doc)
1995 {
1996     HRESULT hres;
1997     IHTMLIFrameElement *iframe;
1998     IHTMLDocument2 *iframes_doc;
1999     DWORD cookie;
2000     IConnectionPoint *cp;
2001     IHTMLElement *element = find_element_by_id(doc, "ifr");
2002
2003     hres = IHTMLElement_QueryInterface(element, &IID_IHTMLIFrameElement, (void**)&iframe);
2004     IHTMLElement_Release(element);
2005     ok(hres == S_OK, "QueryInterface(IID_IHTMLIFrameElement) failed: %08x\n", hres);
2006
2007     iframes_doc = get_iframe_doc(iframe);
2008     IHTMLIFrameElement_Release(iframe);
2009
2010     cookie = register_cp((IUnknown*)iframes_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
2011
2012     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
2013     hres = IConnectionPoint_Unadvise(cp, cookie);
2014     IConnectionPoint_Release(cp);
2015     ok(hres == CONNECT_E_NOCONNECTION, "Unadvise returned %08x, expected CONNECT_E_NOCONNECTION\n", hres);
2016
2017     IHTMLDocument2_Release(iframes_doc);
2018 }
2019
2020 static HRESULT QueryInterface(REFIID,void**);
2021
2022 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
2023 {
2024     return E_NOINTERFACE;
2025 }
2026
2027 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
2028 {
2029     return 2;
2030 }
2031
2032 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
2033 {
2034     return 1;
2035 }
2036
2037 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
2038 {
2039     return E_NOTIMPL;
2040 }
2041
2042 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
2043 {
2044     return E_NOTIMPL;
2045 }
2046
2047 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
2048 {
2049     return E_NOTIMPL;
2050 }
2051
2052 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
2053         LPCBORDERWIDTHS pborderwidths)
2054 {
2055     return E_NOTIMPL;
2056 }
2057
2058 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
2059         LPCBORDERWIDTHS pborderwidths)
2060 {
2061     return S_OK;
2062 }
2063
2064 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
2065         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2066 {
2067     return S_OK;
2068 }
2069
2070 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
2071         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2072 {
2073     return S_OK;
2074 }
2075
2076 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
2077         LPOLEMENUGROUPWIDTHS lpMenuWidths)
2078 {
2079     return E_NOTIMPL;
2080 }
2081
2082 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
2083         HOLEMENU holemenu, HWND hwndActiveObject)
2084 {
2085     ok(0, "unexpected call\n");
2086     return E_NOTIMPL;
2087 }
2088
2089 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
2090 {
2091     ok(0, "unexpected call\n");
2092     return E_NOTIMPL;
2093 }
2094
2095 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
2096 {
2097     return S_OK;
2098 }
2099
2100 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
2101 {
2102     return E_NOTIMPL;
2103 }
2104
2105 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
2106 {
2107     ok(0, "unexpected call\n");
2108     return E_NOTIMPL;
2109 }
2110
2111 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
2112     InPlaceFrame_QueryInterface,
2113     InPlaceFrame_AddRef,
2114     InPlaceFrame_Release,
2115     InPlaceFrame_GetWindow,
2116     InPlaceFrame_ContextSensitiveHelp,
2117     InPlaceFrame_GetBorder,
2118     InPlaceFrame_RequestBorderSpace,
2119     InPlaceFrame_SetBorderSpace,
2120     InPlaceFrame_SetActiveObject,
2121     InPlaceFrame_InsertMenus,
2122     InPlaceFrame_SetMenu,
2123     InPlaceFrame_RemoveMenus,
2124     InPlaceFrame_SetStatusText,
2125     InPlaceFrame_EnableModeless,
2126     InPlaceFrame_TranslateAccelerator
2127 };
2128
2129 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
2130
2131 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
2132     InPlaceFrame_QueryInterface,
2133     InPlaceFrame_AddRef,
2134     InPlaceFrame_Release,
2135     InPlaceFrame_GetWindow,
2136     InPlaceFrame_ContextSensitiveHelp,
2137     InPlaceFrame_GetBorder,
2138     InPlaceFrame_RequestBorderSpace,
2139     InPlaceFrame_SetBorderSpace,
2140     InPlaceUIWindow_SetActiveObject,
2141 };
2142
2143 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
2144
2145 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
2146 {
2147     return QueryInterface(riid, ppv);
2148 }
2149
2150 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
2151 {
2152     return 2;
2153 }
2154
2155 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
2156 {
2157     return 1;
2158 }
2159
2160 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
2161 {
2162     *phwnd = container_hwnd;
2163     return S_OK;
2164 }
2165
2166 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
2167 {
2168     ok(0, "unexpected call\n");
2169     return E_NOTIMPL;
2170 }
2171
2172 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
2173 {
2174     return S_OK;
2175 }
2176
2177 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
2178 {
2179     return S_OK;
2180 }
2181
2182 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
2183 {
2184     return S_OK;
2185 }
2186
2187 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
2188         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
2189         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
2190 {
2191     static const RECT rect = {0,0,300,300};
2192
2193     *ppFrame = &InPlaceFrame;
2194     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
2195     *lprcPosRect = rect;
2196     *lprcClipRect = rect;
2197
2198     ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
2199     lpFrameInfo->fMDIApp = FALSE;
2200     lpFrameInfo->hwndFrame = container_hwnd;
2201     lpFrameInfo->haccel = NULL;
2202     lpFrameInfo->cAccelEntries = 0;
2203
2204     return S_OK;
2205 }
2206
2207 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
2208 {
2209     return E_NOTIMPL;
2210 }
2211
2212 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
2213 {
2214     return S_OK;
2215 }
2216
2217 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
2218 {
2219     return S_OK;
2220 }
2221
2222 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
2223 {
2224     return E_NOTIMPL;
2225 }
2226
2227 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
2228 {
2229     return E_NOTIMPL;
2230 }
2231
2232 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
2233 {
2234     return E_NOTIMPL;
2235 }
2236
2237 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
2238     InPlaceSite_QueryInterface,
2239     InPlaceSite_AddRef,
2240     InPlaceSite_Release,
2241     InPlaceSite_GetWindow,
2242     InPlaceSite_ContextSensitiveHelp,
2243     InPlaceSite_CanInPlaceActivate,
2244     InPlaceSite_OnInPlaceActivate,
2245     InPlaceSite_OnUIActivate,
2246     InPlaceSite_GetWindowContext,
2247     InPlaceSite_Scroll,
2248     InPlaceSite_OnUIDeactivate,
2249     InPlaceSite_OnInPlaceDeactivate,
2250     InPlaceSite_DiscardUndoState,
2251     InPlaceSite_DeactivateAndUndo,
2252     InPlaceSite_OnPosRectChange,
2253 };
2254
2255 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
2256
2257 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
2258 {
2259     return QueryInterface(riid, ppv);
2260 }
2261
2262 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
2263 {
2264     return 2;
2265 }
2266
2267 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
2268 {
2269     return 1;
2270 }
2271
2272 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
2273 {
2274     ok(0, "unexpected call\n");
2275     return E_NOTIMPL;
2276 }
2277
2278 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
2279         IMoniker **ppmon)
2280 {
2281     ok(0, "unexpected call\n");
2282     return E_NOTIMPL;
2283 }
2284
2285 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
2286 {
2287     return E_NOTIMPL;
2288 }
2289
2290 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
2291 {
2292     ok(0, "unexpected call\n");
2293     return E_NOTIMPL;
2294 }
2295
2296 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
2297 {
2298     ok(0, "unexpected call\n");
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
2303 {
2304     ok(0, "unexpected call\n");
2305     return E_NOTIMPL;
2306 }
2307
2308 static const IOleClientSiteVtbl ClientSiteVtbl = {
2309     ClientSite_QueryInterface,
2310     ClientSite_AddRef,
2311     ClientSite_Release,
2312     ClientSite_SaveObject,
2313     ClientSite_GetMoniker,
2314     ClientSite_GetContainer,
2315     ClientSite_ShowObject,
2316     ClientSite_OnShowWindow,
2317     ClientSite_RequestNewObjectLayout
2318 };
2319
2320 static IOleClientSite ClientSite = { &ClientSiteVtbl };
2321
2322 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2323 {
2324     return QueryInterface(riid, ppv);
2325 }
2326
2327 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2328 {
2329     return 2;
2330 }
2331
2332 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2333 {
2334     return 1;
2335 }
2336
2337 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2338 {
2339     RECT rect = {0,0,300,300};
2340     IOleDocument *document;
2341     HRESULT hres;
2342
2343     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2344     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2345
2346     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
2347     IOleDocument_Release(document);
2348     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2349
2350     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
2351     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2352
2353     hres = IOleDocumentView_UIActivate(view, TRUE);
2354     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2355
2356     hres = IOleDocumentView_SetRect(view, &rect);
2357     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2358
2359     hres = IOleDocumentView_Show(view, TRUE);
2360     ok(hres == S_OK, "Show failed: %08x\n", hres);
2361
2362     return S_OK;
2363 }
2364
2365 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2366     DocumentSite_QueryInterface,
2367     DocumentSite_AddRef,
2368     DocumentSite_Release,
2369     DocumentSite_ActivateMe
2370 };
2371
2372 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2373
2374 static HRESULT QueryInterface(REFIID riid, void **ppv)
2375 {
2376     *ppv = NULL;
2377
2378     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2379         *ppv = &ClientSite;
2380     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2381         *ppv = &DocumentSite;
2382     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2383         *ppv = &InPlaceSite;
2384
2385     return *ppv ? S_OK : E_NOINTERFACE;
2386 }
2387
2388 static IHTMLDocument2 *notif_doc;
2389 static BOOL doc_complete;
2390
2391 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
2392         REFIID riid, void**ppv)
2393 {
2394     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2395         *ppv = iface;
2396         return S_OK;
2397     }
2398
2399     ok(0, "unexpected call\n");
2400     return E_NOINTERFACE;
2401 }
2402
2403 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
2404 {
2405     return 2;
2406 }
2407
2408 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
2409 {
2410     return 1;
2411 }
2412
2413 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
2414 {
2415     if(dispID == DISPID_READYSTATE){
2416         BSTR state;
2417         HRESULT hres;
2418
2419         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
2420         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
2421
2422         if(!strcmp_wa(state, "complete"))
2423             doc_complete = TRUE;
2424
2425         SysFreeString(state);
2426     }
2427
2428     return S_OK;
2429 }
2430
2431 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
2432 {
2433     ok(0, "unexpected call\n");
2434     return E_NOTIMPL;
2435 }
2436
2437 static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2438     PropertyNotifySink_QueryInterface,
2439     PropertyNotifySink_AddRef,
2440     PropertyNotifySink_Release,
2441     PropertyNotifySink_OnChanged,
2442     PropertyNotifySink_OnRequestEdit
2443 };
2444
2445 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2446
2447 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2448 {
2449     IPersistStreamInit *init;
2450     IStream *stream;
2451     HGLOBAL mem;
2452     SIZE_T len;
2453
2454     notif_doc = doc;
2455
2456     doc_complete = FALSE;
2457     len = strlen(str);
2458     mem = GlobalAlloc(0, len);
2459     memcpy(mem, str, len);
2460     CreateStreamOnHGlobal(mem, TRUE, &stream);
2461
2462     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
2463
2464     IPersistStreamInit_Load(init, stream);
2465     IPersistStreamInit_Release(init);
2466     IStream_Release(stream);
2467 }
2468
2469 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
2470 {
2471     IConnectionPointContainer *container;
2472     IConnectionPoint *cp;
2473     DWORD cookie;
2474     HRESULT hres;
2475
2476     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2477     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2478
2479     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2480     IConnectionPointContainer_Release(container);
2481     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2482
2483     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
2484     IConnectionPoint_Release(cp);
2485     ok(hres == S_OK, "Advise failed: %08x\n", hres);
2486 }
2487
2488 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
2489 {
2490     IOleObject *oleobj;
2491     HRESULT hres;
2492
2493     if(!set && view) {
2494         IOleDocumentView_Show(view, FALSE);
2495         IOleDocumentView_CloseView(view, 0);
2496         IOleDocumentView_SetInPlaceSite(view, NULL);
2497         IOleDocumentView_Release(view);
2498         view = NULL;
2499     }
2500
2501     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
2502     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
2503
2504     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
2505     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
2506
2507     if(set) {
2508         IHlinkTarget *hlink;
2509
2510         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
2511         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
2512
2513         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2514         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
2515
2516         IHlinkTarget_Release(hlink);
2517     }
2518
2519     IOleObject_Release(oleobj);
2520 }
2521 static IHTMLDocument2 *create_document(void)
2522 {
2523     IHTMLDocument2 *doc;
2524     IHTMLDocument5 *doc5;
2525     HRESULT hres;
2526
2527     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2528             &IID_IHTMLDocument2, (void**)&doc);
2529     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2530     if (FAILED(hres))
2531         return NULL;
2532
2533     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
2534     if(FAILED(hres)) {
2535         win_skip("Could not get IHTMLDocument5 interface, probably too old IE\n");
2536         IHTMLDocument2_Release(doc);
2537         return NULL;
2538     }
2539
2540     IHTMLDocument5_Release(doc5);
2541     return doc;
2542 }
2543
2544
2545 typedef void (*testfunc_t)(IHTMLDocument2*);
2546
2547 static void run_test(const char *str, testfunc_t test)
2548 {
2549     IHTMLDocument2 *doc;
2550     IHTMLElement *body = NULL;
2551     MSG msg;
2552     HRESULT hres;
2553
2554     xy_todo = FALSE;
2555     doc = create_document();
2556     if (!doc)
2557         return;
2558     set_client_site(doc, TRUE);
2559     doc_load_string(doc, str);
2560     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2561
2562     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
2563         TranslateMessage(&msg);
2564         DispatchMessage(&msg);
2565     }
2566
2567     hres = IHTMLDocument2_get_body(doc, &body);
2568     ok(hres == S_OK, "get_body failed: %08x\n", hres);
2569
2570     if(body) {
2571         IHTMLElement_Release(body);
2572
2573         hres = IHTMLDocument2_get_parentWindow(doc, &window);
2574         ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2575         ok(window != NULL, "window == NULL\n");
2576
2577         test(doc);
2578
2579         IHTMLWindow2_Release(window);
2580         window = NULL;
2581     }else {
2582         skip("Could not get document body. Assuming no Gecko installed.\n");
2583     }
2584
2585     set_client_site(doc, FALSE);
2586     IHTMLDocument2_Release(doc);
2587 }
2588
2589 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2590 {
2591     return DefWindowProc(hwnd, msg, wParam, lParam);
2592 }
2593
2594 static HWND create_container_window(void)
2595 {
2596     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
2597     static WNDCLASSEXA wndclass = {
2598         sizeof(WNDCLASSEXA),
2599         0,
2600         wnd_proc,
2601         0, 0, NULL, NULL, NULL, NULL, NULL,
2602         szHTMLDocumentTest,
2603         NULL
2604     };
2605
2606     RegisterClassExA(&wndclass);
2607     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
2608             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2609             300, 300, NULL, NULL, NULL, NULL);
2610 }
2611
2612 static void test_empty_document(void)
2613 {
2614     HRESULT hres;
2615     IHTMLWindow2 *window;
2616     IHTMLDocument2 *windows_doc, *doc;
2617     IConnectionPoint *cp;
2618     DWORD cookie;
2619
2620     doc = create_document();
2621     if(!doc)
2622         return;
2623
2624     hres = IHTMLDocument2_get_parentWindow(doc, &window);
2625     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2626
2627     hres = IHTMLWindow2_get_document(window, &windows_doc);
2628     IHTMLWindow2_Release(window);
2629     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2630
2631     cookie = register_cp((IUnknown*)windows_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
2632
2633     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
2634     hres = IConnectionPoint_Unadvise(cp, cookie);
2635     IConnectionPoint_Release(cp);
2636     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
2637
2638     IHTMLDocument2_Release(windows_doc);
2639     IHTMLDocument2_Release(doc);
2640 }
2641
2642 START_TEST(events)
2643 {
2644     CoInitialize(NULL);
2645     container_hwnd = create_container_window();
2646
2647     if(winetest_interactive)
2648         ShowWindow(container_hwnd, SW_SHOW);
2649
2650     run_test(empty_doc_str, test_timeout);
2651     run_test(click_doc_str, test_onclick);
2652     run_test(readystate_doc_str, test_onreadystatechange);
2653     run_test(img_doc_str, test_imgload);
2654     run_test(input_doc_str, test_focus);
2655     run_test(form_doc_str, test_submit);
2656     run_test(iframe_doc_str, test_iframe_connections);
2657
2658     test_empty_document();
2659
2660     DestroyWindow(container_hwnd);
2661     CoUninitialize();
2662 }