dlls/mshtml/tests/script.c

   1 /*
   2  * Copyright 2008-2009 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "dispex.h"
  30 #include "mshtml.h"
  31 #include "initguid.h"
  32 #include "activscp.h"
  33 #include "activdbg.h"
  34 #include "objsafe.h"
  35 #include "mshtmdid.h"
  36 #include "mshtml_test.h"
  37
  38 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  39
  40 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
  41 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
  42     {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
  43
  44 #ifdef _WIN64
  45
  46 #define CTXARG_T DWORDLONG
  47 #define IActiveScriptParseVtbl IActiveScriptParse64Vtbl
  48 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_64Vtbl
  49
  50 #else
  51
  52 #define CTXARG_T DWORD
  53 #define IActiveScriptParseVtbl IActiveScriptParse32Vtbl
  54 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_32Vtbl
  55
  56 #endif
  57
  58 #define DEFINE_EXPECT(func) \
  59     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  60
  61 #define SET_EXPECT(func) \
  62     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  63
  64 #define CHECK_EXPECT2(func) \
  65     do { \
  66         ok(expect_ ##func, "unexpected call " #func "\n"); \
  67         called_ ## func = TRUE; \
  68     }while(0)
  69
  70 #define CHECK_EXPECT(func) \
  71     do { \
  72         CHECK_EXPECT2(func); \
  73         expect_ ## func = FALSE; \
  74     }while(0)
  75
  76 #define CHECK_CALLED(func) \
  77     do { \
  78         ok(called_ ## func, "expected " #func "\n"); \
  79         expect_ ## func = called_ ## func = FALSE; \
  80     }while(0)
  81
  82 #define CHECK_CALLED_BROKEN(func) \
  83     do { \
  84         ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
  85         expect_ ## func = called_ ## func = FALSE; \
  86     }while(0)
  87
  88 #define CHECK_NOT_CALLED(func) \
  89     do { \
  90         ok(!called_ ## func, "unexpected " #func "\n"); \
  91         expect_ ## func = called_ ## func = FALSE; \
  92     }while(0)
  93
  94 #define CLEAR_CALLED(func) \
  95     expect_ ## func = called_ ## func = FALSE
  96
  97
  98 DEFINE_EXPECT(CreateInstance);
  99 DEFINE_EXPECT(GetInterfaceSafetyOptions);
 100 DEFINE_EXPECT(SetInterfaceSafetyOptions);
 101 DEFINE_EXPECT(InitNew);
 102 DEFINE_EXPECT(Close);
 103 DEFINE_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
 104 DEFINE_EXPECT(SetProperty_INVOKEVERSIONING);
 105 DEFINE_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
 106 DEFINE_EXPECT(SetScriptSite);
 107 DEFINE_EXPECT(GetScriptState);
 108 DEFINE_EXPECT(SetScriptState_STARTED);
 109 DEFINE_EXPECT(SetScriptState_CONNECTED);
 110 DEFINE_EXPECT(SetScriptState_DISCONNECTED);
 111 DEFINE_EXPECT(AddNamedItem);
 112 DEFINE_EXPECT(ParseScriptText);
 113 DEFINE_EXPECT(GetScriptDispatch);
 114 DEFINE_EXPECT(funcDisp);
 115 DEFINE_EXPECT(script_divid_d);
 116 DEFINE_EXPECT(script_testprop_d);
 117 DEFINE_EXPECT(script_testprop_i);
 118 DEFINE_EXPECT(script_testprop2_d);
 119 DEFINE_EXPECT(AXQueryInterface_IActiveScript);
 120 DEFINE_EXPECT(AXQueryInterface_IObjectSafety);
 121 DEFINE_EXPECT(AXGetInterfaceSafetyOptions);
 122 DEFINE_EXPECT(AXSetInterfaceSafetyOptions);
 123
 124 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
 125 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80646}"
 126
 127 #define DISPID_SCRIPT_TESTPROP   0x100000
 128 #define DISPID_SCRIPT_TESTPROP2  0x100001
 129
 130 static const GUID CLSID_TestScript =
 131     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
 132 static const GUID CLSID_TestActiveX =
 133     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
 134
 135 static IHTMLDocument2 *notif_doc;
 136 static IDispatchEx *window_dispex;
 137 static BOOL doc_complete;
 138 static IDispatch *script_disp;
 139 static BOOL ax_objsafe;
 140
 141 static const char *debugstr_guid(REFIID riid)
 142 {
 143     static char buf[50];
 144
 145     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 146             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 147             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 148             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 149
 150     return buf;
 151 }
 152
 153 static int strcmp_wa(LPCWSTR strw, const char *stra)
 154 {
 155     CHAR buf[512];
 156     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 157     return lstrcmpA(stra, buf);
 158 }
 159
 160 static BSTR a2bstr(const char *str)
 161 {
 162     BSTR ret;
 163     int len;
 164
 165     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 166     ret = SysAllocStringLen(NULL, len);
 167     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 168
 169     return ret;
 170 }
 171
 172 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 173 {
 174     HKEY hkey;
 175     DWORD res;
 176
 177     if(!init) {
 178         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 179         return TRUE;
 180     }
 181
 182     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 183     if(res != ERROR_SUCCESS)
 184         return FALSE;
 185
 186     if(def_value)
 187         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 188
 189     RegCloseKey(hkey);
 190
 191     return res == ERROR_SUCCESS;
 192 }
 193
 194 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 195         REFIID riid, void**ppv)
 196 {
 197     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 198         *ppv = iface;
 199         return S_OK;
 200     }
 201
 202     return E_NOINTERFACE;
 203 }
 204
 205 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 206 {
 207     return 2;
 208 }
 209
 210 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 211 {
 212     return 1;
 213 }
 214
 215 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 216 {
 217     if(dispID == DISPID_READYSTATE){
 218         BSTR state;
 219         HRESULT hres;
 220
 221         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 222
 223         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 224         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 225
 226         if(!lstrcmpW(state, completeW))
 227             doc_complete = TRUE;
 228
 229         SysFreeString(state);
 230     }
 231
 232     return S_OK;
 233 }
 234
 235 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 236 {
 237     ok(0, "unexpected call\n");
 238     return E_NOTIMPL;
 239 }
 240
 241 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 242     PropertyNotifySink_QueryInterface,
 243     PropertyNotifySink_AddRef,
 244     PropertyNotifySink_Release,
 245     PropertyNotifySink_OnChanged,
 246     PropertyNotifySink_OnRequestEdit
 247 };
 248
 249 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 250
 251 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 252 {
 253     *ppv = NULL;
 254
 255     if(IsEqualGUID(riid, &IID_IUnknown)
 256        || IsEqualGUID(riid, &IID_IDispatch)
 257        || IsEqualGUID(riid, &IID_IDispatchEx))
 258         *ppv = iface;
 259     else
 260         return E_NOINTERFACE;
 261
 262     return S_OK;
 263 }
 264
 265 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 266 {
 267     return 2;
 268 }
 269
 270 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 271 {
 272     return 1;
 273 }
 274
 275 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 276 {
 277     ok(0, "unexpected call\n");
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 282                                               LCID lcid, ITypeInfo **ppTInfo)
 283 {
 284     ok(0, "unexpected call\n");
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 289                                                 LPOLESTR *rgszNames, UINT cNames,
 290                                                 LCID lcid, DISPID *rgDispId)
 291 {
 292     ok(0, "unexpected call\n");
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 297                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 298                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 299 {
 300     ok(0, "unexpected call\n");
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 305 {
 306     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 311 {
 312     ok(0, "unexpected call\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 317 {
 318     ok(0, "unexpected call\n");
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 323 {
 324     ok(0, "unexpected call\n");
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 329 {
 330     ok(0, "unexpected call\n");
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 335 {
 336     ok(0, "unexpected call\n");
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 341 {
 342     ok(0, "unexpected call\n");
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI funcDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 347         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 348 {
 349     CHECK_EXPECT(funcDisp);
 350
 351     ok(id == DISPID_VALUE, "id = %d\n", id);
 352     ok(lcid == 0, "lcid = %x\n", lcid);
 353     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 354     ok(pdp != NULL, "pdp == NULL\n");
 355     ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
 356     ok(pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 357     ok(pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 358     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 359     ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(rgvarg[1]) = %d\n", V_VT(pdp->rgvarg));
 360     ok(V_BOOL(pdp->rgvarg+1) == VARIANT_TRUE, "V_BOOL(rgvarg[1]) = %x\n", V_BOOL(pdp->rgvarg));
 361     ok(pvarRes != NULL, "pvarRes == NULL\n");
 362     ok(pei != NULL, "pei == NULL\n");
 363     ok(!pspCaller, "pspCaller != NULL\n");
 364
 365     V_VT(pvarRes) = VT_I4;
 366     V_I4(pvarRes) = 100;
 367     return S_OK;
 368 }
 369
 370 static IDispatchExVtbl testObjVtbl = {
 371     DispatchEx_QueryInterface,
 372     DispatchEx_AddRef,
 373     DispatchEx_Release,
 374     DispatchEx_GetTypeInfoCount,
 375     DispatchEx_GetTypeInfo,
 376     DispatchEx_GetIDsOfNames,
 377     DispatchEx_Invoke,
 378     DispatchEx_GetDispID,
 379     funcDisp_InvokeEx,
 380     DispatchEx_DeleteMemberByName,
 381     DispatchEx_DeleteMemberByDispID,
 382     DispatchEx_GetMemberProperties,
 383     DispatchEx_GetMemberName,
 384     DispatchEx_GetNextDispID,
 385     DispatchEx_GetNameSpaceParent
 386 };
 387
 388 static IDispatchEx funcDisp = { &testObjVtbl };
 389
 390 static HRESULT WINAPI scriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 391 {
 392     if(!strcmp_wa(bstrName, "testProp")) {
 393         CHECK_EXPECT(script_testprop_d);
 394         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 395         *pid = DISPID_SCRIPT_TESTPROP;
 396         return S_OK;
 397     }
 398
 399     if(!strcmp_wa(bstrName, "testProp2")) {
 400         CHECK_EXPECT(script_testprop2_d);
 401         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 402         *pid = DISPID_SCRIPT_TESTPROP2;
 403         return S_OK;
 404     }
 405
 406     if(!strcmp_wa(bstrName, "divid")) {
 407         CHECK_EXPECT(script_divid_d);
 408         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 409         return E_FAIL;
 410     }
 411
 412     ok(0, "unexpected call\n");
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI scriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 417         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 418 {
 419     switch(id) {
 420     case DISPID_SCRIPT_TESTPROP:
 421         CHECK_EXPECT(script_testprop_i);
 422
 423         ok(lcid == 0, "lcid = %x\n", lcid);
 424         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 425         ok(pdp != NULL, "pdp == NULL\n");
 426         ok(pdp->cArgs == 0, "pdp->cArgs = %d\n", pdp->cArgs);
 427         ok(pdp->cNamedArgs == 0, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 428         ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs != NULL\n");
 429         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 430         ok(pvarRes != NULL, "pvarRes == NULL\n");
 431         ok(pei != NULL, "pei == NULL\n");
 432         ok(!pspCaller, "pspCaller != NULL\n");
 433
 434         V_VT(pvarRes) = VT_NULL;
 435         break;
 436     default:
 437         ok(0, "unexpected call\n");
 438         return E_NOTIMPL;
 439     }
 440
 441     return S_OK;
 442 }
 443
 444 static IDispatchExVtbl scriptDispVtbl = {
 445     DispatchEx_QueryInterface,
 446     DispatchEx_AddRef,
 447     DispatchEx_Release,
 448     DispatchEx_GetTypeInfoCount,
 449     DispatchEx_GetTypeInfo,
 450     DispatchEx_GetIDsOfNames,
 451     DispatchEx_Invoke,
 452     scriptDisp_GetDispID,
 453     scriptDisp_InvokeEx,
 454     DispatchEx_DeleteMemberByName,
 455     DispatchEx_DeleteMemberByDispID,
 456     DispatchEx_GetMemberProperties,
 457     DispatchEx_GetMemberName,
 458     DispatchEx_GetNextDispID,
 459     DispatchEx_GetNameSpaceParent
 460 };
 461
 462 static IDispatchEx scriptDisp = { &scriptDispVtbl };
 463
 464 static IHTMLDocument2 *create_document(void)
 465 {
 466     IHTMLDocument2 *doc;
 467     HRESULT hres;
 468
 469     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 470             &IID_IHTMLDocument2, (void**)&doc);
 471     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 472
 473     return doc;
 474 }
 475
 476 static IHTMLDocument2 *create_doc_with_string(const char *str)
 477 {
 478     IPersistStreamInit *init;
 479     IStream *stream;
 480     IHTMLDocument2 *doc;
 481     HGLOBAL mem;
 482     SIZE_T len;
 483
 484     notif_doc = doc = create_document();
 485     if(!doc)
 486         return NULL;
 487
 488     doc_complete = FALSE;
 489     len = strlen(str);
 490     mem = GlobalAlloc(0, len);
 491     memcpy(mem, str, len);
 492     CreateStreamOnHGlobal(mem, TRUE, &stream);
 493
 494     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
 495
 496     IPersistStreamInit_Load(init, stream);
 497     IPersistStreamInit_Release(init);
 498     IStream_Release(stream);
 499
 500     return doc;
 501 }
 502
 503 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
 504 {
 505     IConnectionPointContainer *container;
 506     IConnectionPoint *cp;
 507     DWORD cookie;
 508     HRESULT hres;
 509
 510     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
 511     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
 512
 513     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
 514     IConnectionPointContainer_Release(container);
 515     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
 516
 517     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
 518     IConnectionPoint_Release(cp);
 519     ok(hres == S_OK, "Advise failed: %08x\n", hres);
 520 }
 521
 522 typedef void (*domtest_t)(IHTMLDocument2*);
 523
 524 static IHTMLDocument2 *create_and_load_doc(const char *str)
 525 {
 526     IHTMLDocument2 *doc;
 527     IHTMLElement *body = NULL;
 528     MSG msg;
 529     HRESULT hres;
 530     static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
 531     DISPID dispID = -1;
 532     OLECHAR *name;
 533
 534
 535     doc = create_doc_with_string(str);
 536     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
 537
 538     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
 539         TranslateMessage(&msg);
 540         DispatchMessage(&msg);
 541     }
 542
 543     hres = IHTMLDocument2_get_body(doc, &body);
 544     ok(hres == S_OK, "get_body failed: %08x\n", hres);
 545
 546     /* Check we can query for function on the IHTMLElementBody interface */
 547     name = (WCHAR*)ucPtr;
 548     hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
 549     ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
 550     ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
 551
 552     IHTMLElement_Release(body);
 553     return doc;
 554 }
 555
 556 static IActiveScriptSite *site;
 557 static SCRIPTSTATE state;
 558
 559 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
 560 {
 561     *ppv = NULL;
 562     ok(0, "unexpected call %s\n", debugstr_guid(riid));
 563     return E_NOINTERFACE;
 564 }
 565
 566 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
 567 {
 568     return 2;
 569 }
 570
 571 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
 572 {
 573     return 1;
 574 }
 575
 576 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 577         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
 578 {
 579     CHECK_EXPECT(GetInterfaceSafetyOptions);
 580
 581     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 582     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
 583     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
 584
 585     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
 586     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
 587
 588     return S_OK;
 589 }
 590
 591 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 592         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
 593 {
 594     CHECK_EXPECT(SetInterfaceSafetyOptions);
 595
 596     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 597
 598     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 599        "dwOptionSetMask=%x\n", dwOptionSetMask);
 600     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 601        "dwEnabledOptions=%x\n", dwOptionSetMask);
 602
 603     return S_OK;
 604 }
 605
 606 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
 607     ObjectSafety_QueryInterface,
 608     ObjectSafety_AddRef,
 609     ObjectSafety_Release,
 610     ObjectSafety_GetInterfaceSafetyOptions,
 611     ObjectSafety_SetInterfaceSafetyOptions
 612 };
 613
 614 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
 615
 616 static HRESULT WINAPI AXObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
 617 {
 618     *ppv = NULL;
 619
 620     if(IsEqualGUID(&IID_IActiveScript, riid)) {
 621         CHECK_EXPECT(AXQueryInterface_IActiveScript);
 622         return E_NOINTERFACE;
 623     }
 624
 625     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
 626         CHECK_EXPECT(AXQueryInterface_IObjectSafety);
 627         if(!ax_objsafe)
 628             return E_NOINTERFACE;
 629         *ppv = iface;
 630         return S_OK;
 631     }
 632
 633     ok(0, "unexpected call %s\n", debugstr_guid(riid));
 634     return E_NOINTERFACE;
 635 }
 636
 637 static HRESULT WINAPI AXObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 638         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
 639 {
 640     CHECK_EXPECT(AXGetInterfaceSafetyOptions);
 641
 642     ok(IsEqualGUID(&IID_IDispatchEx, riid), "unexpected riid %s\n", debugstr_guid(riid));
 643     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
 644     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
 645
 646     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
 647     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI AXObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 653         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
 654 {
 655     CHECK_EXPECT(AXSetInterfaceSafetyOptions);
 656
 657     ok(IsEqualGUID(&IID_IDispatchEx, riid), "unexpected riid %s\n", debugstr_guid(riid));
 658
 659     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACE_USES_SECURITY_MANAGER),
 660        "dwOptionSetMask=%x\n", dwOptionSetMask);
 661     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACE_USES_SECURITY_MANAGER),
 662        "dwEnabledOptions=%x\n", dwOptionSetMask);
 663
 664     return S_OK;
 665 }
 666
 667 static const IObjectSafetyVtbl AXObjectSafetyVtbl = {
 668     AXObjectSafety_QueryInterface,
 669     ObjectSafety_AddRef,
 670     ObjectSafety_Release,
 671     AXObjectSafety_GetInterfaceSafetyOptions,
 672     AXObjectSafety_SetInterfaceSafetyOptions
 673 };
 674
 675 static IObjectSafety AXObjectSafety = { &AXObjectSafetyVtbl };
 676
 677 static BOOL set_safe_reg(BOOL init)
 678 {
 679     return init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
 680                     NULL, init);
 681 }
 682
 683 static void test_security(void)
 684 {
 685     IInternetHostSecurityManager *sec_mgr;
 686     IServiceProvider *sp;
 687     DWORD policy, policy_size;
 688     struct CONFIRMSAFETY cs;
 689     BYTE *ppolicy;
 690     HRESULT hres;
 691
 692     hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
 693     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
 694
 695     hres = IServiceProvider_QueryService(sp, &SID_SInternetHostSecurityManager,
 696             &IID_IInternetHostSecurityManager, (void**)&sec_mgr);
 697     IServiceProvider_Release(sp);
 698     ok(hres == S_OK, "QueryService failed: %08x\n", hres);
 699
 700     hres = IInternetHostSecurityManager_ProcessUrlAction(sec_mgr, URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy),
 701                                                          (BYTE*)&CLSID_TestActiveX, sizeof(CLSID), 0, 0);
 702     ok(hres == S_OK, "ProcessUrlAction failed: %08x\n", hres);
 703     ok(policy == URLPOLICY_ALLOW, "policy = %x\n", policy);
 704
 705     cs.clsid = CLSID_TestActiveX;
 706     cs.pUnk = (IUnknown*)&AXObjectSafety;
 707     cs.dwFlags = 0;
 708
 709     ax_objsafe = TRUE;
 710     SET_EXPECT(AXQueryInterface_IActiveScript);
 711     SET_EXPECT(AXQueryInterface_IObjectSafety);
 712     SET_EXPECT(AXGetInterfaceSafetyOptions);
 713     SET_EXPECT(AXSetInterfaceSafetyOptions);
 714     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
 715             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
 716     CHECK_CALLED(AXQueryInterface_IActiveScript);
 717     CHECK_CALLED(AXQueryInterface_IObjectSafety);
 718     CHECK_CALLED(AXGetInterfaceSafetyOptions);
 719     CHECK_CALLED(AXSetInterfaceSafetyOptions);
 720
 721     ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
 722     ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
 723     ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
 724     CoTaskMemFree(ppolicy);
 725
 726     ax_objsafe = FALSE;
 727     SET_EXPECT(AXQueryInterface_IActiveScript);
 728     SET_EXPECT(AXQueryInterface_IObjectSafety);
 729     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
 730             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
 731     CHECK_CALLED(AXQueryInterface_IActiveScript);
 732     CHECK_CALLED(AXQueryInterface_IObjectSafety);
 733
 734     ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
 735     ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
 736     ok(*(DWORD*)ppolicy == URLPOLICY_DISALLOW, "policy = %x\n", *(DWORD*)ppolicy);
 737     CoTaskMemFree(ppolicy);
 738
 739     if(set_safe_reg(TRUE)) {
 740         ax_objsafe = FALSE;
 741         SET_EXPECT(AXQueryInterface_IActiveScript);
 742         SET_EXPECT(AXQueryInterface_IObjectSafety);
 743         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
 744                  &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
 745         CHECK_CALLED(AXQueryInterface_IActiveScript);
 746         CHECK_CALLED(AXQueryInterface_IObjectSafety);
 747
 748         ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
 749         ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
 750         ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
 751         CoTaskMemFree(ppolicy);
 752
 753         ax_objsafe = TRUE;
 754         SET_EXPECT(AXQueryInterface_IActiveScript);
 755         SET_EXPECT(AXQueryInterface_IObjectSafety);
 756         SET_EXPECT(AXGetInterfaceSafetyOptions);
 757         SET_EXPECT(AXSetInterfaceSafetyOptions);
 758         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
 759                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
 760         CHECK_CALLED(AXQueryInterface_IActiveScript);
 761         CHECK_CALLED(AXQueryInterface_IObjectSafety);
 762         CHECK_CALLED(AXGetInterfaceSafetyOptions);
 763         CHECK_CALLED(AXSetInterfaceSafetyOptions);
 764
 765         ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
 766         ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
 767         ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
 768         CoTaskMemFree(ppolicy);
 769
 770         set_safe_reg(FALSE);
 771     }else {
 772         skip("Could not set safety registry\n");
 773     }
 774
 775     IInternetHostSecurityManager_Release(sec_mgr);
 776 }
 777
 778 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
 779 {
 780     *ppv = NULL;
 781     ok(0, "unexpected call\n");
 782     return E_NOINTERFACE;
 783 }
 784
 785 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
 786 {
 787     return 2;
 788 }
 789
 790 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
 791 {
 792     return 1;
 793 }
 794
 795 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 796         VARIANT *pvarIndex, VARIANT *pvarValue)
 797 {
 798     ok(0, "unexpected call\n");
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 803         VARIANT *pvarIndex, VARIANT *pvarValue)
 804 {
 805     switch(dwProperty) {
 806     case SCRIPTPROP_HACK_TRIDENTEVENTSINK:
 807         CHECK_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
 808         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 809         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 810         break;
 811     case SCRIPTPROP_INVOKEVERSIONING:
 812         CHECK_EXPECT(SetProperty_INVOKEVERSIONING);
 813         ok(V_VT(pvarValue) == VT_I4, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 814         ok(V_I4(pvarValue) == 1, "V_I4(pvarValue)=%d\n", V_I4(pvarValue));
 815         break;
 816     case SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION:
 817         CHECK_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
 818         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 819         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 820         break;
 821     default:
 822         ok(0, "unexpected property %x\n", dwProperty);
 823         return E_NOTIMPL;
 824     }
 825
 826     ok(!pvarIndex, "pvarIndex != NULL\n");
 827     ok(pvarValue != NULL, "pvarValue == NULL\n");
 828
 829     return S_OK;
 830 }
 831
 832 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
 833     ActiveScriptProperty_QueryInterface,
 834     ActiveScriptProperty_AddRef,
 835     ActiveScriptProperty_Release,
 836     ActiveScriptProperty_GetProperty,
 837     ActiveScriptProperty_SetProperty
 838 };
 839
 840 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
 841
 842 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
 843 {
 844     *ppv = NULL;
 845     ok(0, "unexpected call\n");
 846     return E_NOINTERFACE;
 847 }
 848
 849 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
 850 {
 851     return 2;
 852 }
 853
 854 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
 855 {
 856     return 1;
 857 }
 858
 859 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
 860         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
 861         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
 862         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
 863 {
 864     ok(0, "unexpected call\n");
 865     return E_NOTIMPL;
 866 }
 867
 868 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
 869     ActiveScriptParseProcedure_QueryInterface,
 870     ActiveScriptParseProcedure_AddRef,
 871     ActiveScriptParseProcedure_Release,
 872     ActiveScriptParseProcedure_ParseProcedureText
 873 };
 874
 875 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
 876
 877 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
 878 {
 879     *ppv = NULL;
 880     ok(0, "unexpected call\n");
 881     return E_NOINTERFACE;
 882 }
 883
 884 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
 885 {
 886     return 2;
 887 }
 888
 889 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
 890 {
 891     return 1;
 892 }
 893
 894 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
 895 {
 896     CHECK_EXPECT(InitNew);
 897     return S_OK;
 898 }
 899
 900 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
 901         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
 902         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
 903         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
 904         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
 905 {
 906     ok(0, "unexpected call\n");
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT dispex_propput(IDispatchEx *obj, DISPID id, DWORD flags, VARIANT *var)
 911 {
 912     DISPID propput_arg = DISPID_PROPERTYPUT;
 913     DISPPARAMS dp = {var, &propput_arg, 1, 1};
 914     EXCEPINFO ei = {0};
 915
 916     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT|flags, &dp, NULL, &ei, NULL);
 917 }
 918
 919 static void test_func(IDispatchEx *obj)
 920 {
 921     DISPID id;
 922     IDispatchEx *dispex;
 923     IDispatch *disp;
 924     EXCEPINFO ei;
 925     DISPPARAMS dp;
 926     BSTR str;
 927     VARIANT var;
 928     HRESULT hres;
 929
 930     str = a2bstr("toString");
 931     hres = IDispatchEx_GetDispID(obj, str, fdexNameCaseSensitive, &id);
 932     SysFreeString(str);
 933     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 934     ok(id == DISPID_IOMNAVIGATOR_TOSTRING, "id = %x\n", id);
 935
 936     memset(&dp, 0, sizeof(dp));
 937     memset(&ei, 0, sizeof(ei));
 938     VariantInit(&var);
 939     hres = IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
 940     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 941     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
 942     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(var) == NULL\n");
 943     disp = V_DISPATCH(&var);
 944
 945     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 946     IDispatch_Release(disp);
 947     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
 948
 949     /* FIXME: Test InvokeEx(DISPATCH_METHOD) */
 950
 951     memset(&dp, 0, sizeof(dp));
 952     memset(&ei, 0, sizeof(ei));
 953     VariantInit(&var);
 954     hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
 955     ok(hres == S_OK || broken(E_ACCESSDENIED), "InvokeEx failed: %08x\n", hres);
 956     if(SUCCEEDED(hres)) {
 957         ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
 958         ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
 959         VariantClear(&var);
 960     }
 961
 962     V_VT(&var) = VT_I4;
 963     V_I4(&var) = 100;
 964     hres = dispex_propput(obj, id, 0, &var);
 965     ok(hres == E_NOTIMPL, "InvokeEx failed: %08x\n", hres);
 966
 967     IDispatchEx_Release(dispex);
 968 }
 969
 970 static void test_nextdispid(IDispatchEx *dispex)
 971 {
 972     DISPID last_id = DISPID_STARTENUM, id, dyn_id;
 973     BSTR name;
 974     VARIANT var;
 975     HRESULT hres;
 976
 977     name = a2bstr("dynVal");
 978     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseSensitive|fdexNameEnsure, &dyn_id);
 979     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 980     SysFreeString(name);
 981
 982     V_VT(&var) = VT_EMPTY;
 983     hres = dispex_propput(dispex, dyn_id, 0, &var);
 984
 985     while(last_id != dyn_id) {
 986         hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, last_id, &id);
 987         ok(hres == S_OK, "GetNextDispID returned: %08x\n", hres);
 988         ok(id != DISPID_STARTENUM, "id == DISPID_STARTENUM\n");
 989         ok(id != DISPID_IOMNAVIGATOR_TOSTRING, "id == DISPID_IOMNAVIGATOR_TOSTRING\n");
 990
 991         hres = IDispatchEx_GetMemberName(dispex, id, &name);
 992         ok(hres == S_OK, "GetMemberName failed: %08x\n", hres);
 993
 994         if(id == dyn_id)
 995             ok(!strcmp_wa(name, "dynVal"), "name = %s\n", wine_dbgstr_w(name));
 996         else if(id == DISPID_IOMNAVIGATOR_PLATFORM)
 997             ok(!strcmp_wa(name, "platform"), "name = %s\n", wine_dbgstr_w(name));
 998
 999         SysFreeString(name);
1000         last_id = id;
1001     }
1002
1003     hres = IDispatchEx_GetNextDispID(dispex, 0, id, &id);
1004     ok(hres == S_FALSE, "GetNextDispID returned: %08x\n", hres);
1005     ok(id == DISPID_STARTENUM, "id != DISPID_STARTENUM\n");
1006 }
1007
1008 static void test_global_id(void)
1009 {
1010     VARIANT var;
1011     DISPPARAMS dp;
1012     EXCEPINFO ei;
1013     BSTR tmp;
1014     DISPID id;
1015     HRESULT hres;
1016
1017     SET_EXPECT(GetScriptDispatch);
1018     SET_EXPECT(script_divid_d);
1019     tmp = a2bstr("divid");
1020     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1021     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1022     SysFreeString(tmp);
1023     CHECK_CALLED(GetScriptDispatch);
1024     CHECK_CALLED(script_divid_d);
1025
1026     VariantInit(&var);
1027     memset(&ei, 0, sizeof(ei));
1028     memset(&dp, 0, sizeof(dp));
1029     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1030     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1031     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var) = %d\n", V_VT(&var));
1032     VariantClear(&var);
1033 }
1034
1035 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
1036         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
1037         LPCOLESTR pstrDelimiter, CTXARG_T dwSourceContextCookie, ULONG ulStartingLine,
1038         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
1039 {
1040     IDispatchEx *document, *dispex;
1041     IHTMLWindow2 *window;
1042     IOmNavigator *navigator;
1043     IUnknown *unk;
1044     VARIANT var, arg;
1045     DISPPARAMS dp;
1046     EXCEPINFO ei;
1047     DISPID id;
1048     BSTR tmp;
1049     HRESULT hres;
1050
1051     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
1052     static const WCHAR testW[] = {'t','e','s','t',0};
1053     static const WCHAR funcW[] = {'f','u','n','c',0};
1054
1055     CHECK_EXPECT(ParseScriptText);
1056
1057     SET_EXPECT(GetScriptDispatch);
1058
1059     tmp = SysAllocString(documentW);
1060     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1061     SysFreeString(tmp);
1062     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1063     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
1064
1065     CHECK_CALLED(GetScriptDispatch);
1066
1067     VariantInit(&var);
1068     memset(&dp, 0, sizeof(dp));
1069     memset(&ei, 0, sizeof(ei));
1070
1071     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1072     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1073     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
1074     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
1075
1076     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
1077     VariantClear(&var);
1078     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
1079
1080     tmp = SysAllocString(testW);
1081     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
1082     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
1083     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
1084     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
1085     SysFreeString(tmp);
1086
1087     id = 0;
1088     tmp = SysAllocString(testW);
1089     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1090     SysFreeString(tmp);
1091     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1092     ok(id, "id == 0\n");
1093
1094     V_VT(&var) = VT_I4;
1095     V_I4(&var) = 100;
1096     hres = dispex_propput(document, id, 0, &var);
1097     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1098
1099     tmp = SysAllocString(testW);
1100     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
1101     SysFreeString(tmp);
1102     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1103
1104     VariantInit(&var);
1105     memset(&dp, 0, sizeof(dp));
1106     memset(&ei, 0, sizeof(ei));
1107     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1108     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1109     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1110     ok(V_I4(&var) == 100, "V_I4(&var) = %d\n", V_I4(&var));
1111
1112     V_VT(&var) = VT_I4;
1113     V_I4(&var) = 200;
1114     hres = dispex_propput(document, id, DISPATCH_PROPERTYPUTREF, &var);
1115     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1116
1117     VariantInit(&var);
1118     memset(&dp, 0, sizeof(dp));
1119     memset(&ei, 0, sizeof(ei));
1120     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1121     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1122     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1123     ok(V_I4(&var) == 200, "V_I4(&var) = %d\n", V_I4(&var));
1124
1125     memset(&dp, 0, sizeof(dp));
1126     memset(&ei, 0, sizeof(ei));
1127     V_VT(&var) = VT_I4;
1128     V_I4(&var) = 300;
1129     dp.cArgs = 1;
1130     dp.rgvarg = &var;
1131     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
1132     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1133
1134     VariantInit(&var);
1135     memset(&dp, 0, sizeof(dp));
1136     memset(&ei, 0, sizeof(ei));
1137     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1138     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1139     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1140     ok(V_I4(&var) == 300, "V_I4(&var) = %d\n", V_I4(&var));
1141
1142     unk = (void*)0xdeadbeef;
1143     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
1144     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
1145     ok(!unk, "unk=%p, expected NULL\n", unk);
1146
1147     id = 0;
1148     tmp = SysAllocString(funcW);
1149     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1150     SysFreeString(tmp);
1151     ok(hres == S_OK, "GetDispID(func) failed: %08x\n", hres);
1152     ok(id, "id == 0\n");
1153
1154     dp.cArgs = 1;
1155     dp.rgvarg = &var;
1156     dp.cNamedArgs = 0;
1157     dp.rgdispidNamedArgs = NULL;
1158     V_VT(&var) = VT_DISPATCH;
1159     V_DISPATCH(&var) = (IDispatch*)&funcDisp;
1160     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
1161     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1162
1163     VariantInit(&var);
1164     memset(&dp, 0, sizeof(dp));
1165     memset(&ei, 0, sizeof(ei));
1166     V_VT(&arg) = VT_BOOL;
1167     V_BOOL(&arg) = VARIANT_TRUE;
1168     dp.cArgs = 1;
1169     dp.rgvarg = &arg;
1170
1171     SET_EXPECT(funcDisp);
1172     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_FUNC, &dp, &var, &ei, NULL);
1173     CHECK_CALLED(funcDisp);
1174
1175     ok(hres == S_OK, "InvokeEx(INVOKE_FUNC) failed: %08x\n", hres);
1176     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1177     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
1178
1179     IDispatchEx_Release(document);
1180
1181     hres = IDispatchEx_QueryInterface(window_dispex, &IID_IHTMLWindow2, (void**)&window);
1182     ok(hres == S_OK, "Could not get IHTMLWindow2 iface: %08x\n", hres);
1183
1184     hres = IHTMLWindow2_get_navigator(window, &navigator);
1185     IHTMLWindow2_Release(window);
1186     ok(hres == S_OK, "get_navigator failed: %08x\n", hres);
1187
1188     hres = IOmNavigator_QueryInterface(navigator, &IID_IDispatchEx, (void**)&dispex);
1189     IOmNavigator_Release(navigator);
1190     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
1191
1192     test_func(dispex);
1193     test_nextdispid(dispex);
1194     IDispatchEx_Release(dispex);
1195
1196     script_disp = (IDispatch*)&scriptDisp;
1197
1198     SET_EXPECT(GetScriptDispatch);
1199     SET_EXPECT(script_testprop_d);
1200     tmp = a2bstr("testProp");
1201     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1202     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1203     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
1204     CHECK_CALLED(GetScriptDispatch);
1205     CHECK_CALLED(script_testprop_d);
1206     SysFreeString(tmp);
1207
1208     tmp = a2bstr("testProp");
1209     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1210     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1211     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
1212     SysFreeString(tmp);
1213
1214     SET_EXPECT(GetScriptDispatch);
1215     SET_EXPECT(script_testprop_i);
1216     memset(&ei, 0, sizeof(ei));
1217     memset(&dp, 0, sizeof(dp));
1218     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1219     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1220     ok(V_VT(&var) == VT_NULL, "V_VT(var) = %d\n", V_VT(&var));
1221     CHECK_CALLED(GetScriptDispatch);
1222     CHECK_CALLED(script_testprop_i);
1223
1224     SET_EXPECT(GetScriptDispatch);
1225     SET_EXPECT(script_testprop2_d);
1226     tmp = a2bstr("testProp2");
1227     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1228     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1229     ok(id != DISPID_SCRIPT_TESTPROP2, "id == DISPID_SCRIPT_TESTPROP2\n");
1230     CHECK_CALLED(GetScriptDispatch);
1231     CHECK_CALLED(script_testprop2_d);
1232     SysFreeString(tmp);
1233
1234     test_global_id();
1235
1236     test_security();
1237
1238     return S_OK;
1239 }
1240
1241 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
1242     ActiveScriptParse_QueryInterface,
1243     ActiveScriptParse_AddRef,
1244     ActiveScriptParse_Release,
1245     ActiveScriptParse_InitNew,
1246     ActiveScriptParse_AddScriptlet,
1247     ActiveScriptParse_ParseScriptText
1248 };
1249
1250 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
1251
1252 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
1253 {
1254     *ppv = NULL;
1255
1256     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
1257         *ppv = iface;
1258         return S_OK;
1259     }
1260
1261     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
1262         *ppv = &ActiveScriptParse;
1263         return S_OK;
1264     }
1265
1266     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
1267         *ppv = &ActiveScriptParseProcedure;
1268         return S_OK;
1269     }
1270
1271     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
1272         *ppv = &ActiveScriptProperty;
1273         return S_OK;
1274     }
1275
1276     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1277         *ppv = &ObjectSafety;
1278         return S_OK;
1279     }
1280
1281     if(IsEqualGUID(&IID_IActiveScriptDebug, riid))
1282         return E_NOINTERFACE;
1283
1284     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1285     return E_NOINTERFACE;
1286 }
1287
1288 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
1289 {
1290     return 2;
1291 }
1292
1293 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
1294 {
1295     return 1;
1296 }
1297
1298 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
1299 {
1300     IActiveScriptSiteInterruptPoll *poll;
1301     IActiveScriptSiteDebug *debug;
1302     IServiceProvider *service;
1303     ICanHandleException *canexpection;
1304     LCID lcid;
1305     HRESULT hres;
1306
1307     CHECK_EXPECT(SetScriptSite);
1308
1309     ok(pass != NULL, "pass == NULL\n");
1310
1311     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
1312     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
1313     if(FAILED(hres))
1314         IActiveScriptSiteInterruptPoll_Release(poll);
1315
1316     hres = IActiveScriptSite_GetLCID(pass, &lcid);
1317     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
1318
1319     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
1320     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
1321
1322     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
1323     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
1324     if(SUCCEEDED(hres))
1325         IActiveScriptSiteDebug32_Release(debug);
1326
1327     hres = IActiveScriptSite_QueryInterface(pass, &IID_ICanHandleException, (void**)&canexpection);
1328     ok(hres == E_NOINTERFACE, "Could not get IID_ICanHandleException interface: %08x\n", hres);
1329
1330     hres = IActiveScriptSite_QueryInterface(pass, &IID_IServiceProvider, (void**)&service);
1331     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
1332     if(SUCCEEDED(hres))
1333         IServiceProvider_Release(service);
1334
1335     site = pass;
1336     IActiveScriptSite_AddRef(site);
1337     return S_OK;
1338 }
1339
1340 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
1341                                             void **ppvObject)
1342 {
1343     ok(0, "unexpected call\n");
1344     return E_NOTIMPL;
1345 }
1346
1347 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
1348 {
1349     HRESULT hres;
1350
1351     switch(ss) {
1352     case SCRIPTSTATE_STARTED:
1353         CHECK_EXPECT(SetScriptState_STARTED);
1354         break;
1355     case SCRIPTSTATE_CONNECTED:
1356         CHECK_EXPECT(SetScriptState_CONNECTED);
1357         break;
1358     case SCRIPTSTATE_DISCONNECTED:
1359         CHECK_EXPECT(SetScriptState_DISCONNECTED);
1360         break;
1361     default:
1362         ok(0, "unexpected state %d\n", ss);
1363         return E_NOTIMPL;
1364     }
1365
1366     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
1367     return S_OK;
1368 }
1369
1370 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
1371 {
1372     CHECK_EXPECT(GetScriptState);
1373
1374     *pssState = state;
1375     return S_OK;
1376 }
1377
1378 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
1379 {
1380     CHECK_EXPECT(Close);
1381     return E_NOTIMPL;
1382 }
1383
1384 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
1385         LPCOLESTR pstrName, DWORD dwFlags)
1386 {
1387     IDispatch *disp;
1388     IUnknown *unk = NULL, *unk2;
1389     HRESULT hres;
1390
1391     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
1392
1393     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
1394
1395     CHECK_EXPECT(AddNamedItem);
1396
1397     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", wine_dbgstr_w(pstrName));
1398     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
1399
1400     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
1401     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
1402     ok(unk != NULL, "unk == NULL\n");
1403
1404     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
1405     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
1406     if(SUCCEEDED(hres))
1407         IDispatch_Release(disp);
1408
1409     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
1410     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
1411     if(SUCCEEDED(hres))
1412         IUnknown_Release(unk2);
1413
1414     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
1415     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
1416
1417     IUnknown_Release(unk);
1418     return S_OK;
1419 }
1420
1421 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
1422                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
1423 {
1424     ok(0, "unexpected call\n");
1425     return E_NOTIMPL;
1426 }
1427
1428 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
1429                                                 IDispatch **ppdisp)
1430 {
1431     CHECK_EXPECT(GetScriptDispatch);
1432
1433     ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
1434
1435     if(!script_disp)
1436         return E_NOTIMPL;
1437
1438     *ppdisp = script_disp;
1439     return S_OK;
1440 }
1441
1442 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
1443                                                        SCRIPTTHREADID *pstridThread)
1444 {
1445     ok(0, "unexpected call\n");
1446     return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
1450                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
1451 {
1452     ok(0, "unexpected call\n");
1453     return E_NOTIMPL;
1454 }
1455
1456 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
1457         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
1458 {
1459     ok(0, "unexpected call\n");
1460     return E_NOTIMPL;
1461 }
1462
1463 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
1464         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
1465 {
1466     ok(0, "unexpected call\n");
1467     return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
1471 {
1472     ok(0, "unexpected call\n");
1473     return E_NOTIMPL;
1474 }
1475
1476 static const IActiveScriptVtbl ActiveScriptVtbl = {
1477     ActiveScript_QueryInterface,
1478     ActiveScript_AddRef,
1479     ActiveScript_Release,
1480     ActiveScript_SetScriptSite,
1481     ActiveScript_GetScriptSite,
1482     ActiveScript_SetScriptState,
1483     ActiveScript_GetScriptState,
1484     ActiveScript_Close,
1485     ActiveScript_AddNamedItem,
1486     ActiveScript_AddTypeLib,
1487     ActiveScript_GetScriptDispatch,
1488     ActiveScript_GetCurrentScriptThreadID,
1489     ActiveScript_GetScriptThreadID,
1490     ActiveScript_GetScriptThreadState,
1491     ActiveScript_InterruptScriptThread,
1492     ActiveScript_Clone
1493 };
1494
1495 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
1496
1497 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1498 {
1499     *ppv = NULL;
1500
1501     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1502         *ppv = iface;
1503         return S_OK;
1504     }
1505
1506     if(IsEqualGUID(&IID_IMarshal, riid))
1507         return E_NOINTERFACE;
1508     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1509         return E_NOINTERFACE;
1510
1511     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1512     return E_NOTIMPL;
1513 }
1514
1515 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1516 {
1517     return 2;
1518 }
1519
1520 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1521 {
1522     return 1;
1523 }
1524
1525 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1526 {
1527     CHECK_EXPECT(CreateInstance);
1528
1529     ok(!outer, "outer = %p\n", outer);
1530     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", debugstr_guid(riid));
1531     *ppv = &ActiveScript;
1532     return S_OK;
1533 }
1534
1535 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1536 {
1537     ok(0, "unexpected call\n");
1538     return S_OK;
1539 }
1540
1541 static const IClassFactoryVtbl ClassFactoryVtbl = {
1542     ClassFactory_QueryInterface,
1543     ClassFactory_AddRef,
1544     ClassFactory_Release,
1545     ClassFactory_CreateInstance,
1546     ClassFactory_LockServer
1547 };
1548
1549 static IClassFactory script_cf = { &ClassFactoryVtbl };
1550
1551 static const char simple_script_str[] =
1552     "<html><head></head><body>"
1553     "<div id=\"divid\"></div>"
1554     "<script language=\"TestScript\">simple script</script>"
1555     "</body></html>";
1556
1557 static void test_simple_script(void)
1558 {
1559     IHTMLDocument2 *doc;
1560
1561     SET_EXPECT(CreateInstance);
1562     SET_EXPECT(GetInterfaceSafetyOptions);
1563     SET_EXPECT(SetInterfaceSafetyOptions);
1564     SET_EXPECT(SetProperty_INVOKEVERSIONING); /* IE8 */
1565     SET_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
1566     SET_EXPECT(InitNew);
1567     SET_EXPECT(SetScriptSite);
1568     SET_EXPECT(GetScriptState);
1569     SET_EXPECT(SetScriptState_STARTED);
1570     SET_EXPECT(AddNamedItem);
1571     SET_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
1572     SET_EXPECT(ParseScriptText);
1573     SET_EXPECT(SetScriptState_CONNECTED);
1574
1575     doc = create_and_load_doc(simple_script_str);
1576     if(!doc) return;
1577
1578     CHECK_CALLED(CreateInstance);
1579     CHECK_CALLED(GetInterfaceSafetyOptions);
1580     CHECK_CALLED(SetInterfaceSafetyOptions);
1581     CHECK_CALLED_BROKEN(SetProperty_INVOKEVERSIONING); /* IE8 */
1582     CHECK_CALLED(SetProperty_HACK_TRIDENTEVENTSINK);
1583     CHECK_CALLED(InitNew);
1584     CHECK_CALLED(SetScriptSite);
1585     CHECK_CALLED(GetScriptState);
1586     CHECK_CALLED(SetScriptState_STARTED);
1587     CHECK_CALLED(AddNamedItem);
1588     CHECK_CALLED_BROKEN(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
1589     CHECK_CALLED(ParseScriptText);
1590     CHECK_CALLED(SetScriptState_CONNECTED);
1591
1592     if(site)
1593         IActiveScriptSite_Release(site);
1594     if(window_dispex)
1595         IDispatchEx_Release(window_dispex);
1596
1597     SET_EXPECT(SetScriptState_DISCONNECTED);
1598     SET_EXPECT(Close);
1599
1600     IHTMLDocument2_Release(doc);
1601
1602     CHECK_CALLED(SetScriptState_DISCONNECTED);
1603     CHECK_CALLED(Close);
1604 }
1605
1606 static BOOL init_registry(BOOL init)
1607 {
1608     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
1609         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
1610                     NULL, init)
1611         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
1612                     NULL, init);
1613 }
1614
1615 static BOOL register_script_engine(void)
1616 {
1617     DWORD regid;
1618     HRESULT hres;
1619
1620     if(!init_registry(TRUE)) {
1621         init_registry(FALSE);
1622         return FALSE;
1623     }
1624
1625     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
1626                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
1627     ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
1628
1629     return TRUE;
1630 }
1631
1632 START_TEST(script)
1633 {
1634     CoInitialize(NULL);
1635
1636     if(winetest_interactive || ! is_ie_hardened()) {
1637         if(register_script_engine()) {
1638             test_simple_script();
1639             init_registry(FALSE);
1640         }else {
1641             skip("Could not register TestScript engine\n");
1642         }
1643     }else {
1644         skip("IE running in Enhanced Security Configuration\n");
1645     }
1646
1647     CoUninitialize();
1648 }