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

   1 /*
   2  * Copyright 2008 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
  37 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  38
  39 #define DEFINE_EXPECT(func) \
  40     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  41
  42 #define SET_EXPECT(func) \
  43     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  44
  45 #define CHECK_EXPECT2(func) \
  46     do { \
  47         ok(expect_ ##func, "unexpected call " #func "\n"); \
  48         called_ ## func = TRUE; \
  49     }while(0)
  50
  51 #define CHECK_EXPECT(func) \
  52     do { \
  53         CHECK_EXPECT2(func); \
  54         expect_ ## func = FALSE; \
  55     }while(0)
  56
  57 #define CHECK_CALLED(func) \
  58     do { \
  59         ok(called_ ## func, "expected " #func "\n"); \
  60         expect_ ## func = called_ ## func = FALSE; \
  61     }while(0)
  62
  63 #define CHECK_NOT_CALLED(func) \
  64     do { \
  65         ok(!called_ ## func, "unexpected " #func "\n"); \
  66         expect_ ## func = called_ ## func = FALSE; \
  67     }while(0)
  68
  69 #define CLEAR_CALLED(func) \
  70     expect_ ## func = called_ ## func = FALSE
  71
  72
  73 DEFINE_EXPECT(CreateInstance);
  74 DEFINE_EXPECT(GetInterfaceSafetyOptions);
  75 DEFINE_EXPECT(SetInterfaceSafetyOptions);
  76 DEFINE_EXPECT(InitNew);
  77 DEFINE_EXPECT(Close);
  78 DEFINE_EXPECT(SetProperty);
  79 DEFINE_EXPECT(SetScriptSite);
  80 DEFINE_EXPECT(GetScriptState);
  81 DEFINE_EXPECT(SetScriptState_STARTED);
  82 DEFINE_EXPECT(SetScriptState_CONNECTED);
  83 DEFINE_EXPECT(SetScriptState_DISCONNECTED);
  84 DEFINE_EXPECT(AddNamedItem);
  85 DEFINE_EXPECT(ParseScriptText);
  86 DEFINE_EXPECT(GetScriptDispatch);
  87
  88 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
  89
  90 static const GUID CLSID_TestScript =
  91     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
  92
  93 static IHTMLDocument2 *notif_doc;
  94 static IDispatchEx *window_dispex;
  95 static BOOL doc_complete;
  96
  97 static const char *debugstr_w(LPCWSTR str)
  98 {
  99     static char buf[1024];
 100     WideCharToMultiByte(CP_ACP, 0, str, -1, buf, sizeof(buf), NULL, NULL);
 101     return buf;
 102 }
 103
 104 static const char *debugstr_guid(REFIID riid)
 105 {
 106     static char buf[50];
 107
 108     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 109             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 110             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 111             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 112
 113     return buf;
 114 }
 115
 116 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 117         REFIID riid, void**ppv)
 118 {
 119     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 120         *ppv = iface;
 121         return S_OK;
 122     }
 123
 124     return E_NOINTERFACE;
 125 }
 126
 127 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 128 {
 129     return 2;
 130 }
 131
 132 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 133 {
 134     return 1;
 135 }
 136
 137 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 138 {
 139     if(dispID == DISPID_READYSTATE){
 140         BSTR state;
 141         HRESULT hres;
 142
 143         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 144
 145         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 146         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 147
 148         if(!lstrcmpW(state, completeW))
 149             doc_complete = TRUE;
 150
 151         SysFreeString(state);
 152     }
 153
 154     return S_OK;
 155 }
 156
 157 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 158 {
 159     ok(0, "unexpected call\n");
 160     return E_NOTIMPL;
 161 }
 162
 163 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 164     PropertyNotifySink_QueryInterface,
 165     PropertyNotifySink_AddRef,
 166     PropertyNotifySink_Release,
 167     PropertyNotifySink_OnChanged,
 168     PropertyNotifySink_OnRequestEdit
 169 };
 170
 171 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 172
 173 static IHTMLDocument2 *create_document(void)
 174 {
 175     IHTMLDocument2 *doc;
 176     HRESULT hres;
 177
 178     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 179             &IID_IHTMLDocument2, (void**)&doc);
 180     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 181
 182     return doc;
 183 }
 184
 185 static IHTMLDocument2 *create_doc_with_string(const char *str)
 186 {
 187     IPersistStreamInit *init;
 188     IStream *stream;
 189     IHTMLDocument2 *doc;
 190     HGLOBAL mem;
 191     SIZE_T len;
 192
 193     notif_doc = doc = create_document();
 194     if(!doc)
 195         return NULL;
 196
 197     doc_complete = FALSE;
 198     len = strlen(str);
 199     mem = GlobalAlloc(0, len);
 200     memcpy(mem, str, len);
 201     CreateStreamOnHGlobal(mem, TRUE, &stream);
 202
 203     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
 204
 205     IPersistStreamInit_Load(init, stream);
 206     IPersistStreamInit_Release(init);
 207     IStream_Release(stream);
 208
 209     return doc;
 210 }
 211
 212 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
 213 {
 214     IConnectionPointContainer *container;
 215     IConnectionPoint *cp;
 216     DWORD cookie;
 217     HRESULT hres;
 218
 219     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
 220     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
 221
 222     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
 223     IConnectionPointContainer_Release(container);
 224     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
 225
 226     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
 227     IConnectionPoint_Release(cp);
 228     ok(hres == S_OK, "Advise failed: %08x\n", hres);
 229 }
 230
 231 typedef void (*domtest_t)(IHTMLDocument2*);
 232
 233 static IHTMLDocument2 *create_and_load_doc(const char *str)
 234 {
 235     IHTMLDocument2 *doc;
 236     IHTMLElement *body = NULL;
 237     ULONG ref;
 238     MSG msg;
 239     HRESULT hres;
 240     static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
 241     DISPID dispID = -1;
 242     OLECHAR *name;
 243
 244
 245     doc = create_doc_with_string(str);
 246     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
 247
 248     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
 249         TranslateMessage(&msg);
 250         DispatchMessage(&msg);
 251     }
 252
 253     hres = IHTMLDocument2_get_body(doc, &body);
 254     ok(hres == S_OK, "get_body failed: %08x\n", hres);
 255
 256     if(!body) {
 257         skip("Could not get document body. Assuming no Gecko installed.\n");
 258         ref = IHTMLDocument2_Release(doc);
 259         ok(!ref, "ref = %d\n", ref);
 260         return NULL;
 261     }
 262
 263     /* Check we can query for function on the IHTMLElementBody interface */
 264     name = (WCHAR*)ucPtr;
 265     hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
 266     ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
 267     ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
 268
 269     IHTMLElement_Release(body);
 270     return doc;
 271 }
 272
 273 static IActiveScriptSite *site;
 274 static SCRIPTSTATE state;
 275
 276 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
 277 {
 278     *ppv = NULL;
 279     ok(0, "unexpected call\n");
 280     return E_NOINTERFACE;
 281 }
 282
 283 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
 284 {
 285     return 2;
 286 }
 287
 288 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
 289 {
 290     return 1;
 291 }
 292
 293 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 294         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
 295 {
 296     CHECK_EXPECT(GetInterfaceSafetyOptions);
 297
 298     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 299     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
 300     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
 301
 302     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
 303     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
 304
 305     return S_OK;
 306 }
 307
 308 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 309         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
 310 {
 311     CHECK_EXPECT(SetInterfaceSafetyOptions);
 312
 313     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 314
 315     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 316        "dwOptionSetMask=%x\n", dwOptionSetMask);
 317     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 318        "dwEnabledOptions=%x\n", dwOptionSetMask);
 319
 320     return S_OK;
 321 }
 322
 323 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
 324     ObjectSafety_QueryInterface,
 325     ObjectSafety_AddRef,
 326     ObjectSafety_Release,
 327     ObjectSafety_GetInterfaceSafetyOptions,
 328     ObjectSafety_SetInterfaceSafetyOptions
 329 };
 330
 331 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
 332
 333 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
 334 {
 335     *ppv = NULL;
 336     ok(0, "unexpected call\n");
 337     return E_NOINTERFACE;
 338 }
 339
 340 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
 341 {
 342     return 2;
 343 }
 344
 345 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
 346 {
 347     return 1;
 348 }
 349
 350 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 351         VARIANT *pvarIndex, VARIANT *pvarValue)
 352 {
 353     ok(0, "unexpected call\n");
 354     return E_NOTIMPL;
 355 }
 356
 357 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 358         VARIANT *pvarIndex, VARIANT *pvarValue)
 359 {
 360     CHECK_EXPECT(SetProperty);
 361
 362     ok(dwProperty == SCRIPTPROP_HACK_TRIDENTEVENTSINK, "unexpected property %d\n", dwProperty);
 363     ok(!pvarIndex, "pvarIndex != NULL\n");
 364     ok(pvarValue != NULL, "pvarValue == NULL\n");
 365     ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 366     ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 367
 368     return E_NOTIMPL;
 369 }
 370
 371 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
 372     ActiveScriptProperty_QueryInterface,
 373     ActiveScriptProperty_AddRef,
 374     ActiveScriptProperty_Release,
 375     ActiveScriptProperty_GetProperty,
 376     ActiveScriptProperty_SetProperty
 377 };
 378
 379 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
 380
 381 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
 382 {
 383     *ppv = NULL;
 384     ok(0, "unexpected call\n");
 385     return E_NOINTERFACE;
 386 }
 387
 388 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
 389 {
 390     return 2;
 391 }
 392
 393 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
 394 {
 395     return 1;
 396 }
 397
 398 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
 399         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
 400         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
 401         DWORD dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
 402 {
 403     ok(0, "unexpected call\n");
 404     return E_NOTIMPL;
 405 }
 406
 407 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
 408     ActiveScriptParseProcedure_QueryInterface,
 409     ActiveScriptParseProcedure_AddRef,
 410     ActiveScriptParseProcedure_Release,
 411     ActiveScriptParseProcedure_ParseProcedureText
 412 };
 413
 414 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
 415
 416 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
 417 {
 418     *ppv = NULL;
 419     ok(0, "unexpected call\n");
 420     return E_NOINTERFACE;
 421 }
 422
 423 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
 424 {
 425     return 2;
 426 }
 427
 428 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
 429 {
 430     return 1;
 431 }
 432
 433 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
 434 {
 435     CHECK_EXPECT(InitNew);
 436     return S_OK;
 437 }
 438
 439 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
 440         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
 441         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
 442         DWORD dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
 443         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
 444 {
 445     ok(0, "unexpected call\n");
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
 450         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
 451         LPCOLESTR pstrDelimiter, DWORD dwSourceContextCookie, ULONG ulStartingLine,
 452         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
 453 {
 454     IDispatchEx *document;
 455     IUnknown *unk;
 456     VARIANT var;
 457     DISPPARAMS dp;
 458     EXCEPINFO ei;
 459     DISPID id, named_arg = DISPID_PROPERTYPUT;
 460     BSTR tmp;
 461     HRESULT hres;
 462
 463     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
 464     static const WCHAR testW[] = {'t','e','s','t',0};
 465
 466     CHECK_EXPECT(ParseScriptText);
 467
 468     SET_EXPECT(GetScriptDispatch);
 469
 470     tmp = SysAllocString(documentW);
 471     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
 472     SysFreeString(tmp);
 473     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 474     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
 475
 476     todo_wine CHECK_CALLED(GetScriptDispatch);
 477
 478     VariantInit(&var);
 479     memset(&dp, 0, sizeof(dp));
 480     memset(&ei, 0, sizeof(ei));
 481
 482     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 483     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 484     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
 485     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
 486
 487     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
 488     VariantClear(&var);
 489     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
 490
 491     tmp = SysAllocString(testW);
 492     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 493     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 494     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
 495     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 496     SysFreeString(tmp);
 497
 498     id = 0;
 499     tmp = SysAllocString(testW);
 500     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
 501     SysFreeString(tmp);
 502     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 503     ok(id, "id == 0\n");
 504
 505     dp.cArgs = 1;
 506     dp.rgvarg = &var;
 507     dp.cNamedArgs = 1;
 508     dp.rgdispidNamedArgs = &named_arg;
 509     V_VT(&var) = VT_I4;
 510     V_I4(&var) = 100;
 511
 512     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
 513     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 514
 515     tmp = SysAllocString(testW);
 516     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 517     SysFreeString(tmp);
 518     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 519
 520     VariantInit(&var);
 521     memset(&dp, 0, sizeof(dp));
 522     memset(&ei, 0, sizeof(ei));
 523     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 524     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 525     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
 526     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
 527
 528     IDispatchEx_Release(document);
 529
 530     unk = (void*)0xdeadbeef;
 531     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
 532     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
 533     ok(!unk, "unk=%p, expected NULL\n", unk);
 534
 535     return S_OK;
 536 }
 537
 538 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
 539     ActiveScriptParse_QueryInterface,
 540     ActiveScriptParse_AddRef,
 541     ActiveScriptParse_Release,
 542     ActiveScriptParse_InitNew,
 543     ActiveScriptParse_AddScriptlet,
 544     ActiveScriptParse_ParseScriptText
 545 };
 546
 547 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
 548
 549 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
 550 {
 551     *ppv = NULL;
 552
 553     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
 554         *ppv = iface;
 555         return S_OK;
 556     }
 557
 558     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
 559         *ppv = &ActiveScriptParse;
 560         return S_OK;
 561     }
 562
 563     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
 564         *ppv = &ActiveScriptParseProcedure;
 565         return S_OK;
 566     }
 567
 568     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
 569         *ppv = &ActiveScriptProperty;
 570         return S_OK;
 571     }
 572
 573     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
 574         *ppv = &ObjectSafety;
 575         return S_OK;
 576     }
 577
 578     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 579     return E_NOINTERFACE;
 580 }
 581
 582 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
 583 {
 584     return 2;
 585 }
 586
 587 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
 588 {
 589     return 1;
 590 }
 591
 592 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
 593 {
 594     IActiveScriptSiteInterruptPoll *poll;
 595     IActiveScriptSiteDebug *debug;
 596     LCID lcid;
 597     HRESULT hres;
 598
 599     CHECK_EXPECT(SetScriptSite);
 600
 601     ok(pass != NULL, "pass == NULL\n");
 602
 603     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
 604     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
 605     if(FAILED(hres))
 606         IActiveScriptSiteInterruptPoll_Release(poll);
 607
 608     hres = IActiveScriptSite_GetLCID(pass, &lcid);
 609     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
 610
 611     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
 612     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
 613
 614     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
 615     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
 616     if(SUCCEEDED(hres))
 617         IActiveScriptSiteDebug32_Release(debug);
 618
 619     site = pass;
 620     IActiveScriptSite_AddRef(site);
 621     return S_OK;
 622 }
 623
 624 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
 625                                             void **ppvObject)
 626 {
 627     ok(0, "unexpected call\n");
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
 632 {
 633     HRESULT hres;
 634
 635     switch(ss) {
 636     case SCRIPTSTATE_STARTED:
 637         CHECK_EXPECT(SetScriptState_STARTED);
 638         break;
 639     case SCRIPTSTATE_CONNECTED:
 640         CHECK_EXPECT(SetScriptState_CONNECTED);
 641         break;
 642     case SCRIPTSTATE_DISCONNECTED:
 643         CHECK_EXPECT(SetScriptState_DISCONNECTED);
 644         break;
 645     default:
 646         ok(0, "unexpected state %d\n", ss);
 647         return E_NOTIMPL;
 648     }
 649
 650     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
 651     return S_OK;
 652 }
 653
 654 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
 655 {
 656     CHECK_EXPECT(GetScriptState);
 657
 658     *pssState = state;
 659     return S_OK;
 660 }
 661
 662 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
 663 {
 664     CHECK_EXPECT(Close);
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
 669         LPCOLESTR pstrName, DWORD dwFlags)
 670 {
 671     IDispatch *disp;
 672     IUnknown *unk = NULL, *unk2;
 673     HRESULT hres;
 674
 675     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
 676
 677     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
 678
 679     CHECK_EXPECT(AddNamedItem);
 680
 681     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", debugstr_w(pstrName));
 682     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
 683
 684     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
 685     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
 686     ok(unk != NULL, "unk == NULL\n");
 687
 688     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
 689     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
 690     if(SUCCEEDED(hres))
 691         IDispatch_Release(disp);
 692
 693     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
 694     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
 695     if(SUCCEEDED(hres))
 696         IUnknown_Release(unk2);
 697
 698     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
 699     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
 700
 701     IUnknown_Release(unk);
 702     return S_OK;
 703 }
 704
 705 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
 706                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
 707 {
 708     ok(0, "unexpected call\n");
 709     return E_NOTIMPL;
 710 }
 711
 712 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
 713                                                 IDispatch **ppdisp)
 714 {
 715     CHECK_EXPECT(GetScriptDispatch);
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
 720                                                        SCRIPTTHREADID *pstridThread)
 721 {
 722     ok(0, "unexpected call\n");
 723     return E_NOTIMPL;
 724 }
 725
 726 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
 727                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
 728 {
 729     ok(0, "unexpected call\n");
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
 734         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
 735 {
 736     ok(0, "unexpected call\n");
 737     return E_NOTIMPL;
 738 }
 739
 740 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
 741         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
 742 {
 743     ok(0, "unexpected call\n");
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
 748 {
 749     ok(0, "unexpected call\n");
 750     return E_NOTIMPL;
 751 }
 752
 753 static const IActiveScriptVtbl ActiveScriptVtbl = {
 754     ActiveScript_QueryInterface,
 755     ActiveScript_AddRef,
 756     ActiveScript_Release,
 757     ActiveScript_SetScriptSite,
 758     ActiveScript_GetScriptSite,
 759     ActiveScript_SetScriptState,
 760     ActiveScript_GetScriptState,
 761     ActiveScript_Close,
 762     ActiveScript_AddNamedItem,
 763     ActiveScript_AddTypeLib,
 764     ActiveScript_GetScriptDispatch,
 765     ActiveScript_GetCurrentScriptThreadID,
 766     ActiveScript_GetScriptThreadID,
 767     ActiveScript_GetScriptThreadState,
 768     ActiveScript_InterruptScriptThread,
 769     ActiveScript_Clone
 770 };
 771
 772 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
 773
 774 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 775 {
 776     *ppv = NULL;
 777
 778     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 779         *ppv = iface;
 780         return S_OK;
 781     }
 782
 783     if(IsEqualGUID(&IID_IMarshal, riid))
 784         return E_NOINTERFACE;
 785     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
 786         return E_NOINTERFACE;
 787
 788     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 789     return E_NOTIMPL;
 790 }
 791
 792 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 793 {
 794     return 2;
 795 }
 796
 797 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 798 {
 799     return 1;
 800 }
 801
 802 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 803 {
 804     CHECK_EXPECT(CreateInstance);
 805
 806     ok(!outer, "outer = %p\n", outer);
 807     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", debugstr_guid(riid));
 808     *ppv = &ActiveScript;
 809     return S_OK;
 810 }
 811
 812 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 813 {
 814     ok(0, "unexpected call\n");
 815     return S_OK;
 816 }
 817
 818 static const IClassFactoryVtbl ClassFactoryVtbl = {
 819     ClassFactory_QueryInterface,
 820     ClassFactory_AddRef,
 821     ClassFactory_Release,
 822     ClassFactory_CreateInstance,
 823     ClassFactory_LockServer
 824 };
 825
 826 static IClassFactory script_cf = { &ClassFactoryVtbl };
 827
 828 static const char simple_script_str[] =
 829     "<html><head></head><body>"
 830     "<script language=\"TestScript\">simple script</script>"
 831     "</body></html>";
 832
 833 static void test_simple_script(void)
 834 {
 835     IHTMLDocument2 *doc;
 836
 837     SET_EXPECT(CreateInstance);
 838     SET_EXPECT(GetInterfaceSafetyOptions);
 839     SET_EXPECT(SetInterfaceSafetyOptions);
 840     SET_EXPECT(SetProperty);
 841     SET_EXPECT(InitNew);
 842     SET_EXPECT(SetScriptSite);
 843     SET_EXPECT(GetScriptState);
 844     SET_EXPECT(SetScriptState_STARTED);
 845     SET_EXPECT(AddNamedItem);
 846     SET_EXPECT(ParseScriptText);
 847     SET_EXPECT(SetScriptState_CONNECTED);
 848
 849     doc = create_and_load_doc(simple_script_str);
 850     if(!doc) return;
 851
 852     CHECK_CALLED(CreateInstance);
 853     CHECK_CALLED(GetInterfaceSafetyOptions);
 854     CHECK_CALLED(SetInterfaceSafetyOptions);
 855     CHECK_CALLED(SetProperty);
 856     CHECK_CALLED(InitNew);
 857     CHECK_CALLED(SetScriptSite);
 858     CHECK_CALLED(GetScriptState);
 859     CHECK_CALLED(SetScriptState_STARTED);
 860     CHECK_CALLED(AddNamedItem);
 861     CHECK_CALLED(ParseScriptText);
 862     CHECK_CALLED(SetScriptState_CONNECTED);
 863
 864     if(site)
 865         IActiveScriptSite_Release(site);
 866     if(window_dispex)
 867         IDispatchEx_Release(window_dispex);
 868
 869     SET_EXPECT(SetScriptState_DISCONNECTED);
 870     SET_EXPECT(Close);
 871
 872     IHTMLDocument2_Release(doc);
 873
 874     CHECK_CALLED(SetScriptState_DISCONNECTED);
 875     CHECK_CALLED(Close);
 876 }
 877
 878 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 879 {
 880     HKEY hkey;
 881     DWORD res;
 882
 883     if(!init) {
 884         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 885         return TRUE;
 886     }
 887
 888     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 889     if(res != ERROR_SUCCESS)
 890         return FALSE;
 891
 892     if(def_value)
 893         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 894
 895     RegCloseKey(hkey);
 896
 897     return res == ERROR_SUCCESS;
 898 }
 899
 900 static BOOL init_registry(BOOL init)
 901 {
 902     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
 903         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
 904                     NULL, init)
 905         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
 906                     NULL, init);
 907 }
 908
 909 static BOOL register_script_engine(void)
 910 {
 911     DWORD regid;
 912     HRESULT hres;
 913
 914     if(!init_registry(TRUE)) {
 915         init_registry(FALSE);
 916         return FALSE;
 917     }
 918
 919     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
 920                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 921     ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
 922
 923     return TRUE;
 924 }
 925
 926 static void gecko_installer_workaround(BOOL disable)
 927 {
 928     HKEY hkey;
 929     DWORD res;
 930
 931     static BOOL has_url = FALSE;
 932     static char url[2048];
 933
 934     if(!disable && !has_url)
 935         return;
 936
 937     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
 938     if(res != ERROR_SUCCESS)
 939         return;
 940
 941     if(disable) {
 942         DWORD type, size = sizeof(url);
 943
 944         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
 945         if(res == ERROR_SUCCESS && type == REG_SZ)
 946             has_url = TRUE;
 947
 948         RegDeleteValue(hkey, "GeckoUrl");
 949     }else {
 950         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
 951     }
 952
 953     RegCloseKey(hkey);
 954 }
 955
 956 START_TEST(script)
 957 {
 958     gecko_installer_workaround(TRUE);
 959     CoInitialize(NULL);
 960
 961     if(register_script_engine()) {
 962         test_simple_script();
 963         init_registry(FALSE);
 964     }else {
 965         skip("Could not register TestScript engine\n");
 966     }
 967
 968     CoUninitialize();
 969     gecko_installer_workaround(FALSE);
 970 }