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
 241     doc = create_doc_with_string(str);
 242     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
 243
 244     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
 245         TranslateMessage(&msg);
 246         DispatchMessage(&msg);
 247     }
 248
 249     hres = IHTMLDocument2_get_body(doc, &body);
 250     ok(hres == S_OK, "get_body failed: %08x\n", hres);
 251
 252     if(!body) {
 253         skip("Could not get document body. Assuming no Gecko installed.\n");
 254         ref = IHTMLDocument2_Release(doc);
 255         ok(!ref, "ref = %d\n", ref);
 256         return NULL;
 257     }
 258
 259     IHTMLElement_Release(body);
 260     return doc;
 261 }
 262
 263 static IActiveScriptSite *site;
 264 static SCRIPTSTATE state;
 265
 266 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
 267 {
 268     *ppv = NULL;
 269     ok(0, "unexpected call\n");
 270     return E_NOINTERFACE;
 271 }
 272
 273 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
 274 {
 275     return 2;
 276 }
 277
 278 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
 279 {
 280     return 1;
 281 }
 282
 283 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 284         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
 285 {
 286     CHECK_EXPECT(GetInterfaceSafetyOptions);
 287
 288     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 289     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
 290     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
 291
 292     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
 293     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
 294
 295     return S_OK;
 296 }
 297
 298 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 299         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
 300 {
 301     CHECK_EXPECT(SetInterfaceSafetyOptions);
 302
 303     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 304
 305     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 306        "dwOptionSetMask=%x\n", dwOptionSetMask);
 307     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 308        "dwEnabledOptions=%x\n", dwOptionSetMask);
 309
 310     return S_OK;
 311 }
 312
 313 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
 314     ObjectSafety_QueryInterface,
 315     ObjectSafety_AddRef,
 316     ObjectSafety_Release,
 317     ObjectSafety_GetInterfaceSafetyOptions,
 318     ObjectSafety_SetInterfaceSafetyOptions
 319 };
 320
 321 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
 322
 323 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
 324 {
 325     *ppv = NULL;
 326     ok(0, "unexpected call\n");
 327     return E_NOINTERFACE;
 328 }
 329
 330 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
 331 {
 332     return 2;
 333 }
 334
 335 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
 336 {
 337     return 1;
 338 }
 339
 340 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 341         VARIANT *pvarIndex, VARIANT *pvarValue)
 342 {
 343     ok(0, "unexpected call\n");
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 348         VARIANT *pvarIndex, VARIANT *pvarValue)
 349 {
 350     CHECK_EXPECT(SetProperty);
 351
 352     ok(dwProperty == SCRIPTPROP_HACK_TRIDENTEVENTSINK, "unexpected property %d\n", dwProperty);
 353     ok(!pvarIndex, "pvarIndex != NULL\n");
 354     ok(pvarValue != NULL, "pvarValue == NULL\n");
 355     ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 356     ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 357
 358     return E_NOTIMPL;
 359 }
 360
 361 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
 362     ActiveScriptProperty_QueryInterface,
 363     ActiveScriptProperty_AddRef,
 364     ActiveScriptProperty_Release,
 365     ActiveScriptProperty_GetProperty,
 366     ActiveScriptProperty_SetProperty
 367 };
 368
 369 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
 370
 371 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
 372 {
 373     *ppv = NULL;
 374     ok(0, "unexpected call\n");
 375     return E_NOINTERFACE;
 376 }
 377
 378 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
 379 {
 380     return 2;
 381 }
 382
 383 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
 384 {
 385     return 1;
 386 }
 387
 388 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
 389         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
 390         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
 391         DWORD dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
 392 {
 393     ok(0, "unexpected call\n");
 394     return E_NOTIMPL;
 395 }
 396
 397 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
 398     ActiveScriptParseProcedure_QueryInterface,
 399     ActiveScriptParseProcedure_AddRef,
 400     ActiveScriptParseProcedure_Release,
 401     ActiveScriptParseProcedure_ParseProcedureText
 402 };
 403
 404 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
 405
 406 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
 407 {
 408     *ppv = NULL;
 409     ok(0, "unexpected call\n");
 410     return E_NOINTERFACE;
 411 }
 412
 413 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
 414 {
 415     return 2;
 416 }
 417
 418 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
 419 {
 420     return 1;
 421 }
 422
 423 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
 424 {
 425     CHECK_EXPECT(InitNew);
 426     return S_OK;
 427 }
 428
 429 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
 430         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
 431         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
 432         DWORD dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
 433         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
 434 {
 435     ok(0, "unexpected call\n");
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
 440         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
 441         LPCOLESTR pstrDelimiter, DWORD dwSourceContextCookie, ULONG ulStartingLine,
 442         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
 443 {
 444     IDispatchEx *document;
 445     IUnknown *unk;
 446     VARIANT var;
 447     DISPPARAMS dp;
 448     EXCEPINFO ei;
 449     DISPID id, named_arg = DISPID_PROPERTYPUT;
 450     BSTR tmp;
 451     HRESULT hres;
 452
 453     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
 454     static const WCHAR testW[] = {'t','e','s','t',0};
 455
 456     CHECK_EXPECT(ParseScriptText);
 457
 458     SET_EXPECT(GetScriptDispatch);
 459
 460     tmp = SysAllocString(documentW);
 461     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
 462     SysFreeString(tmp);
 463     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 464     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
 465
 466     todo_wine CHECK_CALLED(GetScriptDispatch);
 467
 468     VariantInit(&var);
 469     memset(&dp, 0, sizeof(dp));
 470     memset(&ei, 0, sizeof(ei));
 471
 472     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 473     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 474     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
 475     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
 476
 477     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
 478     VariantClear(&var);
 479     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
 480
 481     tmp = SysAllocString(testW);
 482     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 483     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 484     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
 485     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 486     SysFreeString(tmp);
 487
 488     id = 0;
 489     tmp = SysAllocString(testW);
 490     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
 491     SysFreeString(tmp);
 492     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 493     ok(id, "id == 0\n");
 494
 495     dp.cArgs = 1;
 496     dp.rgvarg = &var;
 497     dp.cNamedArgs = 1;
 498     dp.rgdispidNamedArgs = &named_arg;
 499     V_VT(&var) = VT_I4;
 500     V_I4(&var) = 100;
 501
 502     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
 503     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 504
 505     tmp = SysAllocString(testW);
 506     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 507     SysFreeString(tmp);
 508     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 509
 510     VariantInit(&var);
 511     memset(&dp, 0, sizeof(dp));
 512     memset(&ei, 0, sizeof(ei));
 513     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 514     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 515     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
 516     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
 517
 518     IDispatchEx_Release(document);
 519
 520     unk = (void*)0xdeadbeef;
 521     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
 522     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
 523     ok(!unk, "unk=%p, expected NULL\n", unk);
 524
 525     return S_OK;
 526 }
 527
 528 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
 529     ActiveScriptParse_QueryInterface,
 530     ActiveScriptParse_AddRef,
 531     ActiveScriptParse_Release,
 532     ActiveScriptParse_InitNew,
 533     ActiveScriptParse_AddScriptlet,
 534     ActiveScriptParse_ParseScriptText
 535 };
 536
 537 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
 538
 539 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
 540 {
 541     *ppv = NULL;
 542
 543     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
 544         *ppv = iface;
 545         return S_OK;
 546     }
 547
 548     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
 549         *ppv = &ActiveScriptParse;
 550         return S_OK;
 551     }
 552
 553     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
 554         *ppv = &ActiveScriptParseProcedure;
 555         return S_OK;
 556     }
 557
 558     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
 559         *ppv = &ActiveScriptProperty;
 560         return S_OK;
 561     }
 562
 563     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
 564         *ppv = &ObjectSafety;
 565         return S_OK;
 566     }
 567
 568     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 569     return E_NOINTERFACE;
 570 }
 571
 572 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
 573 {
 574     return 2;
 575 }
 576
 577 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
 578 {
 579     return 1;
 580 }
 581
 582 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
 583 {
 584     IActiveScriptSiteInterruptPoll *poll;
 585     IActiveScriptSiteDebug *debug;
 586     LCID lcid;
 587     HRESULT hres;
 588
 589     CHECK_EXPECT(SetScriptSite);
 590
 591     ok(pass != NULL, "pass == NULL\n");
 592
 593     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
 594     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
 595     if(FAILED(hres))
 596         IActiveScriptSiteInterruptPoll_Release(poll);
 597
 598     hres = IActiveScriptSite_GetLCID(pass, &lcid);
 599     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
 600
 601     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
 602     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
 603
 604     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
 605     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
 606     if(SUCCEEDED(hres))
 607         IActiveScriptSiteDebug32_Release(debug);
 608
 609     site = pass;
 610     IActiveScriptSite_AddRef(site);
 611     return S_OK;
 612 }
 613
 614 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
 615                                             void **ppvObject)
 616 {
 617     ok(0, "unexpected call\n");
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
 622 {
 623     HRESULT hres;
 624
 625     switch(ss) {
 626     case SCRIPTSTATE_STARTED:
 627         CHECK_EXPECT(SetScriptState_STARTED);
 628         break;
 629     case SCRIPTSTATE_CONNECTED:
 630         CHECK_EXPECT(SetScriptState_CONNECTED);
 631         break;
 632     case SCRIPTSTATE_DISCONNECTED:
 633         CHECK_EXPECT(SetScriptState_DISCONNECTED);
 634         break;
 635     default:
 636         ok(0, "unexpected state %d\n", ss);
 637         return E_NOTIMPL;
 638     }
 639
 640     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
 641     return S_OK;
 642 }
 643
 644 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
 645 {
 646     CHECK_EXPECT(GetScriptState);
 647
 648     *pssState = state;
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
 653 {
 654     CHECK_EXPECT(Close);
 655     return E_NOTIMPL;
 656 }
 657
 658 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
 659         LPCOLESTR pstrName, DWORD dwFlags)
 660 {
 661     IDispatch *disp;
 662     IUnknown *unk = NULL, *unk2;
 663     HRESULT hres;
 664
 665     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
 666
 667     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
 668
 669     CHECK_EXPECT(AddNamedItem);
 670
 671     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", debugstr_w(pstrName));
 672     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
 673
 674     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
 675     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
 676     ok(unk != NULL, "unk == NULL\n");
 677
 678     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
 679     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
 680     if(SUCCEEDED(hres))
 681         IDispatch_Release(disp);
 682
 683     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
 684     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
 685     if(SUCCEEDED(hres))
 686         IUnknown_Release(unk2);
 687
 688     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
 689     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
 690
 691     IUnknown_Release(unk);
 692     return S_OK;
 693 }
 694
 695 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
 696                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
 697 {
 698     ok(0, "unexpected call\n");
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
 703                                                 IDispatch **ppdisp)
 704 {
 705     CHECK_EXPECT(GetScriptDispatch);
 706     return E_NOTIMPL;
 707 }
 708
 709 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
 710                                                        SCRIPTTHREADID *pstridThread)
 711 {
 712     ok(0, "unexpected call\n");
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
 717                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
 718 {
 719     ok(0, "unexpected call\n");
 720     return E_NOTIMPL;
 721 }
 722
 723 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
 724         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
 725 {
 726     ok(0, "unexpected call\n");
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
 731         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
 732 {
 733     ok(0, "unexpected call\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static const IActiveScriptVtbl ActiveScriptVtbl = {
 744     ActiveScript_QueryInterface,
 745     ActiveScript_AddRef,
 746     ActiveScript_Release,
 747     ActiveScript_SetScriptSite,
 748     ActiveScript_GetScriptSite,
 749     ActiveScript_SetScriptState,
 750     ActiveScript_GetScriptState,
 751     ActiveScript_Close,
 752     ActiveScript_AddNamedItem,
 753     ActiveScript_AddTypeLib,
 754     ActiveScript_GetScriptDispatch,
 755     ActiveScript_GetCurrentScriptThreadID,
 756     ActiveScript_GetScriptThreadID,
 757     ActiveScript_GetScriptThreadState,
 758     ActiveScript_InterruptScriptThread,
 759     ActiveScript_Clone
 760 };
 761
 762 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
 763
 764 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 765 {
 766     *ppv = NULL;
 767
 768     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 769         *ppv = iface;
 770         return S_OK;
 771     }
 772
 773     if(IsEqualGUID(&IID_IMarshal, riid))
 774         return E_NOINTERFACE;
 775     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
 776         return E_NOINTERFACE;
 777
 778     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 779     return E_NOTIMPL;
 780 }
 781
 782 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 783 {
 784     return 2;
 785 }
 786
 787 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 788 {
 789     return 1;
 790 }
 791
 792 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 793 {
 794     CHECK_EXPECT(CreateInstance);
 795
 796     ok(!outer, "outer = %p\n", outer);
 797     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", debugstr_guid(riid));
 798     *ppv = &ActiveScript;
 799     return S_OK;
 800 }
 801
 802 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 803 {
 804     ok(0, "unexpected call\n");
 805     return S_OK;
 806 }
 807
 808 static const IClassFactoryVtbl ClassFactoryVtbl = {
 809     ClassFactory_QueryInterface,
 810     ClassFactory_AddRef,
 811     ClassFactory_Release,
 812     ClassFactory_CreateInstance,
 813     ClassFactory_LockServer
 814 };
 815
 816 static IClassFactory script_cf = { &ClassFactoryVtbl };
 817
 818 static const char simple_script_str[] =
 819     "<html><head></head><body>"
 820     "<script language=\"TestScript\">simple script</script>"
 821     "</body></html>";
 822
 823 static void test_simple_script(void)
 824 {
 825     IHTMLDocument2 *doc;
 826
 827     SET_EXPECT(CreateInstance);
 828     SET_EXPECT(GetInterfaceSafetyOptions);
 829     SET_EXPECT(SetInterfaceSafetyOptions);
 830     SET_EXPECT(SetProperty);
 831     SET_EXPECT(InitNew);
 832     SET_EXPECT(SetScriptSite);
 833     SET_EXPECT(GetScriptState);
 834     SET_EXPECT(SetScriptState_STARTED);
 835     SET_EXPECT(AddNamedItem);
 836     SET_EXPECT(ParseScriptText);
 837     SET_EXPECT(SetScriptState_CONNECTED);
 838
 839     doc = create_and_load_doc(simple_script_str);
 840     if(!doc) return;
 841
 842     CHECK_CALLED(CreateInstance);
 843     CHECK_CALLED(GetInterfaceSafetyOptions);
 844     CHECK_CALLED(SetInterfaceSafetyOptions);
 845     CHECK_CALLED(SetProperty);
 846     CHECK_CALLED(InitNew);
 847     CHECK_CALLED(SetScriptSite);
 848     CHECK_CALLED(GetScriptState);
 849     CHECK_CALLED(SetScriptState_STARTED);
 850     CHECK_CALLED(AddNamedItem);
 851     CHECK_CALLED(ParseScriptText);
 852     CHECK_CALLED(SetScriptState_CONNECTED);
 853
 854     if(site)
 855         IActiveScriptSite_Release(site);
 856     if(window_dispex)
 857         IDispatchEx_Release(window_dispex);
 858
 859     SET_EXPECT(SetScriptState_DISCONNECTED);
 860     SET_EXPECT(Close);
 861
 862     IHTMLDocument2_Release(doc);
 863
 864     CHECK_CALLED(SetScriptState_DISCONNECTED);
 865     CHECK_CALLED(Close);
 866 }
 867
 868 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 869 {
 870     HKEY hkey;
 871     DWORD res;
 872
 873     if(!init) {
 874         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 875         return TRUE;
 876     }
 877
 878     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 879     if(res != ERROR_SUCCESS)
 880         return FALSE;
 881
 882     if(def_value)
 883         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 884
 885     RegCloseKey(hkey);
 886
 887     return res == ERROR_SUCCESS;
 888 }
 889
 890 static BOOL init_registry(BOOL init)
 891 {
 892     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
 893         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
 894                     NULL, init)
 895         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
 896                     NULL, init);
 897 }
 898
 899 static BOOL register_script_engine(void)
 900 {
 901     DWORD regid;
 902     HRESULT hres;
 903
 904     if(!init_registry(TRUE)) {
 905         init_registry(FALSE);
 906         return FALSE;
 907     }
 908
 909     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
 910                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 911     ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
 912
 913     return TRUE;
 914 }
 915
 916 static void gecko_installer_workaround(BOOL disable)
 917 {
 918     HKEY hkey;
 919     DWORD res;
 920
 921     static BOOL has_url = FALSE;
 922     static char url[2048];
 923
 924     if(!disable && !has_url)
 925         return;
 926
 927     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
 928     if(res != ERROR_SUCCESS)
 929         return;
 930
 931     if(disable) {
 932         DWORD type, size = sizeof(url);
 933
 934         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
 935         if(res == ERROR_SUCCESS && type == REG_SZ)
 936             has_url = TRUE;
 937
 938         RegDeleteValue(hkey, "GeckoUrl");
 939     }else {
 940         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
 941     }
 942
 943     RegCloseKey(hkey);
 944 }
 945
 946 START_TEST(script)
 947 {
 948     gecko_installer_workaround(TRUE);
 949     CoInitialize(NULL);
 950
 951     if(register_script_engine()) {
 952         test_simple_script();
 953         init_registry(FALSE);
 954     }else {
 955         skip("Could not register TestScript engine\n");
 956     }
 957
 958     CoUninitialize();
 959     gecko_installer_workaround(FALSE);
 960 }