git.oblomov.eu Git - wine/blob - dlls/jscript/tests/activex.c

   1 /*
   2  * Copyright 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 #include <stdio.h>
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <ole2.h>
  25 #include <dispex.h>
  26 #include <activscp.h>
  27 #include <objsafe.h>
  28 #include <urlmon.h>
  29 #include <mshtmhst.h>
  30
  31 #include "wine/test.h"
  32
  33 static const CLSID CLSID_JScript =
  34     {0xf414c260,0x6ac0,0x11cf,{0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58}};
  35
  36 #define DEFINE_EXPECT(func) \
  37     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  38
  39 #define SET_EXPECT(func) \
  40     expect_ ## func = TRUE
  41
  42 #define SET_CALLED(func) \
  43     called_ ## func = TRUE
  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_EXPECT(CreateInstance);
  64 DEFINE_EXPECT(ProcessUrlAction);
  65 DEFINE_EXPECT(QueryCustomPolicy);
  66 DEFINE_EXPECT(reportSuccess);
  67 DEFINE_EXPECT(Host_QS_SecMgr);
  68 DEFINE_EXPECT(Caller_QS_SecMgr);
  69 DEFINE_EXPECT(QI_IObjectWithSite);
  70
  71 static const WCHAR testW[] = {'t','e','s','t',0};
  72
  73 static HRESULT QS_SecMgr_hres;
  74 static HRESULT ProcessUrlAction_hres;
  75 static DWORD ProcessUrlAction_policy;
  76 static HRESULT CreateInstance_hres;
  77 static HRESULT QueryCustomPolicy_hres;
  78 static DWORD QueryCustomPolicy_psize;
  79 static DWORD QueryCustomPolicy_policy;
  80 static HRESULT QI_IDispatch_hres;
  81
  82 #define TESTOBJ_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80646}"
  83
  84 static const GUID CLSID_TestObj =
  85     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
  86
  87 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
  88 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
  89     {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
  90
  91 #define DISPID_TEST_REPORTSUCCESS    0x1000
  92
  93 #define DISPID_GLOBAL_OK             0x2000
  94
  95 static const char *debugstr_guid(REFIID riid)
  96 {
  97     static char buf[50];
  98
  99     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 100             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 101             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 102             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 103
 104     return buf;
 105 }
 106
 107 static BSTR a2bstr(const char *str)
 108 {
 109     BSTR ret;
 110     int len;
 111
 112     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 113     ret = SysAllocStringLen(NULL, len-1);
 114     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 115
 116     return ret;
 117 }
 118
 119 static int strcmp_wa(LPCWSTR strw, const char *stra)
 120 {
 121     CHAR buf[512];
 122     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
 123     return lstrcmpA(buf, stra);
 124 }
 125
 126 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 127 {
 128     *ppv = NULL;
 129
 130     if(IsEqualGUID(riid, &IID_IUnknown)) {
 131        *ppv = iface;
 132     }else if(IsEqualGUID(riid, &IID_IDispatch) || IsEqualGUID(riid, &IID_IDispatchEx)) {
 133         if(FAILED(QI_IDispatch_hres))
 134             return QI_IDispatch_hres;
 135         *ppv = iface;
 136     }else if(IsEqualGUID(&IID_IObjectWithSite, riid)) {
 137         CHECK_EXPECT(QI_IObjectWithSite);
 138         return E_NOINTERFACE;
 139     }else {
 140         return E_NOINTERFACE;
 141     }
 142
 143     return S_OK;
 144 }
 145
 146 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 147 {
 148     return 2;
 149 }
 150
 151 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 152 {
 153     return 1;
 154 }
 155
 156 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 157 {
 158     ok(0, "unexpected call\n");
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 163                                               LCID lcid, ITypeInfo **ppTInfo)
 164 {
 165     ok(0, "unexpected call\n");
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 170                                                 LPOLESTR *rgszNames, UINT cNames,
 171                                                 LCID lcid, DISPID *rgDispId)
 172 {
 173     ok(0, "unexpected call\n");
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 178                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 179                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 180 {
 181     ok(0, "unexpected call\n");
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 186 {
 187     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 192 {
 193     ok(0, "unexpected call\n");
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 198 {
 199     ok(0, "unexpected call\n");
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 204 {
 205     ok(0, "unexpected call\n");
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 210 {
 211     ok(0, "unexpected call\n");
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 216 {
 217     ok(0, "unexpected call\n");
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI Test_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 222 {
 223     if(!strcmp_wa(bstrName, "reportSuccess")) {
 224         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 225         *pid = DISPID_TEST_REPORTSUCCESS;
 226         return S_OK;
 227     }
 228
 229     ok(0, "unexpected name %s\n", wine_dbgstr_w(bstrName));
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI Test_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 234         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 235 {
 236     switch(id) {
 237     case DISPID_TEST_REPORTSUCCESS:
 238         CHECK_EXPECT(reportSuccess);
 239
 240         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 241         ok(pdp != NULL, "pdp == NULL\n");
 242         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 243         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 244         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 245         ok(!pvarRes, "pvarRes != NULL\n");
 246         ok(pei != NULL, "pei == NULL\n");
 247         break;
 248
 249     default:
 250         ok(0, "unexpected call\n");
 251         return E_NOTIMPL;
 252     }
 253
 254     return S_OK;
 255 }
 256
 257 static IDispatchExVtbl testObjVtbl = {
 258     DispatchEx_QueryInterface,
 259     DispatchEx_AddRef,
 260     DispatchEx_Release,
 261     DispatchEx_GetTypeInfoCount,
 262     DispatchEx_GetTypeInfo,
 263     DispatchEx_GetIDsOfNames,
 264     DispatchEx_Invoke,
 265     Test_GetDispID,
 266     Test_InvokeEx,
 267     DispatchEx_DeleteMemberByName,
 268     DispatchEx_DeleteMemberByDispID,
 269     DispatchEx_GetMemberProperties,
 270     DispatchEx_GetMemberName,
 271     DispatchEx_GetNextDispID,
 272     DispatchEx_GetNameSpaceParent
 273 };
 274
 275 static IDispatchEx testObj = { &testObjVtbl };
 276
 277 static HRESULT WINAPI Global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 278 {
 279     if(!strcmp_wa(bstrName, "ok")) {
 280         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 281         *pid = DISPID_GLOBAL_OK;
 282         return S_OK;
 283     }
 284
 285     ok(0, "unexpected name %s\n", wine_dbgstr_w(bstrName));
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 290         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 291 {
 292     switch(id) {
 293     case DISPID_GLOBAL_OK:
 294         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 295         ok(pdp != NULL, "pdp == NULL\n");
 296         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 297         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 298         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 299         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 300         ok(pei != NULL, "pei == NULL\n");
 301
 302         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 303         ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
 304         ok(V_BOOL(pdp->rgvarg+1), "%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 305         break;
 306
 307     default:
 308         ok(0, "unexpected call\n");
 309         return E_NOTIMPL;
 310     }
 311
 312     return S_OK;
 313 }
 314
 315 static IDispatchExVtbl globalObjVtbl = {
 316     DispatchEx_QueryInterface,
 317     DispatchEx_AddRef,
 318     DispatchEx_Release,
 319     DispatchEx_GetTypeInfoCount,
 320     DispatchEx_GetTypeInfo,
 321     DispatchEx_GetIDsOfNames,
 322     DispatchEx_Invoke,
 323     Global_GetDispID,
 324     Global_InvokeEx,
 325     DispatchEx_DeleteMemberByName,
 326     DispatchEx_DeleteMemberByDispID,
 327     DispatchEx_GetMemberProperties,
 328     DispatchEx_GetMemberName,
 329     DispatchEx_GetNextDispID,
 330     DispatchEx_GetNameSpaceParent
 331 };
 332
 333 static IDispatchEx globalObj = { &globalObjVtbl };
 334
 335 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 336 {
 337     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 338         *ppv = iface;
 339         return S_OK;
 340     }
 341
 342     /* TODO: IClassFactoryEx */
 343     *ppv = NULL;
 344     return E_NOINTERFACE;
 345 }
 346
 347 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 348 {
 349     return 2;
 350 }
 351
 352 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 353 {
 354     return 1;
 355 }
 356
 357 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 358 {
 359     CHECK_EXPECT(CreateInstance);
 360
 361     ok(!outer, "outer = %p\n", outer);
 362     ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
 363
 364     if(SUCCEEDED(CreateInstance_hres))
 365         *ppv = &testObj;
 366     return CreateInstance_hres;
 367 }
 368
 369 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 370 {
 371     ok(0, "unexpected call\n");
 372     return S_OK;
 373 }
 374
 375 static const IClassFactoryVtbl ClassFactoryVtbl = {
 376     ClassFactory_QueryInterface,
 377     ClassFactory_AddRef,
 378     ClassFactory_Release,
 379     ClassFactory_CreateInstance,
 380     ClassFactory_LockServer
 381 };
 382
 383 static IClassFactory activex_cf = { &ClassFactoryVtbl };
 384
 385 static HRESULT WINAPI InternetHostSecurityManager_QueryInterface(IInternetHostSecurityManager *iface, REFIID riid, void **ppv)
 386 {
 387     ok(0, "unexpected call\n");
 388     return E_NOINTERFACE;
 389 }
 390
 391 static ULONG WINAPI InternetHostSecurityManager_AddRef(IInternetHostSecurityManager *iface)
 392 {
 393     return 2;
 394 }
 395
 396 static ULONG WINAPI InternetHostSecurityManager_Release(IInternetHostSecurityManager *iface)
 397 {
 398     return 1;
 399 }
 400
 401 static HRESULT WINAPI InternetHostSecurityManager_GetSecurityId(IInternetHostSecurityManager *iface,  BYTE *pbSecurityId,
 402         DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 403 {
 404     ok(0, "unexpected call\n");
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT WINAPI InternetHostSecurityManager_ProcessUrlAction(IInternetHostSecurityManager *iface, DWORD dwAction,
 409         BYTE *pPolicy, DWORD cbPolicy, BYTE *pContext, DWORD cbContext, DWORD dwFlags, DWORD dwReserved)
 410 {
 411     CHECK_EXPECT(ProcessUrlAction);
 412
 413     ok(dwAction == URLACTION_ACTIVEX_RUN, "dwAction = %x\n", dwAction);
 414     ok(pPolicy != NULL, "pPolicy == NULL\n");
 415     ok(cbPolicy == sizeof(DWORD), "cbPolicy = %d\n", cbPolicy);
 416     ok(pContext != NULL, "pContext == NULL\n");
 417     ok(cbContext == sizeof(GUID), "cbContext = %d\n", cbContext);
 418     ok(IsEqualGUID(pContext, &CLSID_TestObj), "pContext = %s\n", debugstr_guid((const IID*)pContext));
 419     ok(!dwFlags, "dwFlags = %x\n", dwFlags);
 420     ok(!dwReserved, "dwReserved = %x\n", dwReserved);
 421
 422     if(SUCCEEDED(ProcessUrlAction_hres))
 423         *(DWORD*)pPolicy = ProcessUrlAction_policy;
 424     return ProcessUrlAction_hres;
 425 }
 426
 427 static HRESULT WINAPI InternetHostSecurityManager_QueryCustomPolicy(IInternetHostSecurityManager *iface, REFGUID guidKey,
 428         BYTE **ppPolicy, DWORD *pcbPolicy, BYTE *pContext, DWORD cbContext, DWORD dwReserved)
 429 {
 430     const struct CONFIRMSAFETY *cs = (const struct CONFIRMSAFETY*)pContext;
 431     DWORD *ret;
 432
 433     CHECK_EXPECT(QueryCustomPolicy);
 434
 435     ok(IsEqualGUID(&GUID_CUSTOM_CONFIRMOBJECTSAFETY, guidKey), "guidKey = %s\n", debugstr_guid(guidKey));
 436
 437     ok(ppPolicy != NULL, "ppPolicy == NULL\n");
 438     ok(pcbPolicy != NULL, "pcbPolicy == NULL\n");
 439     ok(pContext != NULL, "pContext == NULL\n");
 440     ok(cbContext == sizeof(struct CONFIRMSAFETY), "cbContext = %d\n", cbContext);
 441     ok(!dwReserved, "dwReserved = %x\n", dwReserved);
 442
 443     /* TODO: CLSID */
 444     ok(cs->pUnk != NULL, "cs->pUnk == NULL\n");
 445     ok(!cs->dwFlags, "dwFlags = %x\n", cs->dwFlags);
 446
 447     if(FAILED(QueryCustomPolicy_hres))
 448         return QueryCustomPolicy_hres;
 449
 450     ret = CoTaskMemAlloc(QueryCustomPolicy_psize);
 451     *ppPolicy = (BYTE*)ret;
 452     *pcbPolicy = QueryCustomPolicy_psize;
 453     memset(ret, 0, QueryCustomPolicy_psize);
 454     if(QueryCustomPolicy_psize >= sizeof(DWORD))
 455         *ret = QueryCustomPolicy_policy;
 456
 457     return QueryCustomPolicy_hres;
 458 }
 459
 460 static const IInternetHostSecurityManagerVtbl InternetHostSecurityManagerVtbl = {
 461     InternetHostSecurityManager_QueryInterface,
 462     InternetHostSecurityManager_AddRef,
 463     InternetHostSecurityManager_Release,
 464     InternetHostSecurityManager_GetSecurityId,
 465     InternetHostSecurityManager_ProcessUrlAction,
 466     InternetHostSecurityManager_QueryCustomPolicy
 467 };
 468
 469 static IInternetHostSecurityManager InternetHostSecurityManager = { &InternetHostSecurityManagerVtbl };
 470
 471 static IServiceProvider ServiceProvider;
 472
 473 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 474 {
 475     ok(0, "unexpected call\n");
 476     return E_NOINTERFACE;
 477 }
 478
 479 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 480 {
 481     return 2;
 482 }
 483
 484 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 485 {
 486     return 1;
 487 }
 488
 489 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
 490         REFGUID guidService, REFIID riid, void **ppv)
 491 {
 492     if(IsEqualGUID(&SID_GetCaller, guidService))
 493         return E_NOINTERFACE;
 494
 495     if(IsEqualGUID(&SID_SInternetHostSecurityManager, guidService)) {
 496         if(iface == &ServiceProvider)
 497             CHECK_EXPECT(Host_QS_SecMgr);
 498         else
 499             CHECK_EXPECT(Caller_QS_SecMgr);
 500         ok(IsEqualGUID(&IID_IInternetHostSecurityManager, riid), "unexpected riid %s\n", debugstr_guid(riid));
 501         if(SUCCEEDED(QS_SecMgr_hres))
 502             *ppv = &InternetHostSecurityManager;
 503         return QS_SecMgr_hres;
 504     }
 505
 506     ok(0, "unexpected service %s\n", debugstr_guid(guidService));
 507     return E_NOINTERFACE;
 508 }
 509
 510 static IServiceProviderVtbl ServiceProviderVtbl = {
 511     ServiceProvider_QueryInterface,
 512     ServiceProvider_AddRef,
 513     ServiceProvider_Release,
 514     ServiceProvider_QueryService
 515 };
 516
 517 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
 518 static IServiceProvider caller_sp = { &ServiceProviderVtbl };
 519
 520 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 521 {
 522     if(IsEqualGUID(&IID_IUnknown, riid)) {
 523         *ppv = iface;
 524     }else if(IsEqualGUID(&IID_IActiveScriptSite, riid)) {
 525         *ppv = iface;
 526     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 527         *ppv = &ServiceProvider;
 528     }else {
 529         *ppv = NULL;
 530         return E_NOINTERFACE;
 531     }
 532
 533     IUnknown_AddRef((IUnknown*)*ppv);
 534     return S_OK;
 535 }
 536
 537 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 538 {
 539     return 2;
 540 }
 541
 542 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 543 {
 544     return 1;
 545 }
 546
 547 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 548 {
 549     *plcid = GetUserDefaultLCID();
 550     return S_OK;
 551 }
 552
 553 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 554         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 555 {
 556     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
 557     ok(!ppti, "ppti != NULL\n");
 558     ok(!strcmp_wa(pstrName, "test"), "pstrName = %s\n", wine_dbgstr_w(pstrName));
 559
 560     *ppiunkItem = (IUnknown*)&globalObj;
 561     return S_OK;
 562 }
 563
 564 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 565 {
 566     return E_NOTIMPL;
 567 }
 568
 569 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 570         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 571 {
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 576 {
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 581 {
 582     return E_NOTIMPL;
 583 }
 584
 585 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 586 {
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 591 {
 592     return E_NOTIMPL;
 593 }
 594
 595 #undef ACTSCPSITE_THIS
 596
 597 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 598     ActiveScriptSite_QueryInterface,
 599     ActiveScriptSite_AddRef,
 600     ActiveScriptSite_Release,
 601     ActiveScriptSite_GetLCID,
 602     ActiveScriptSite_GetItemInfo,
 603     ActiveScriptSite_GetDocVersionString,
 604     ActiveScriptSite_OnScriptTerminate,
 605     ActiveScriptSite_OnStateChange,
 606     ActiveScriptSite_OnScriptError,
 607     ActiveScriptSite_OnEnterScript,
 608     ActiveScriptSite_OnLeaveScript
 609 };
 610
 611 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
 612
 613 static void set_safety_options(IUnknown *unk)
 614 {
 615     IObjectSafety *safety;
 616     DWORD supported, enabled;
 617     HRESULT hres;
 618
 619     hres = IUnknown_QueryInterface(unk, &IID_IObjectSafety, (void**)&safety);
 620     ok(hres == S_OK, "Could not get IObjectSafety: %08x\n", hres);
 621     if(FAILED(hres))
 622         return;
 623
 624     hres = IObjectSafety_SetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse,
 625             INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER,
 626             INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER);
 627     ok(hres == S_OK, "SetInterfaceSafetyOptions failed: %08x\n", hres);
 628
 629     supported = enabled = 0xdeadbeef;
 630     hres = IObjectSafety_GetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse, &supported, &enabled);
 631     ok(hres == S_OK, "GetInterfaceSafetyOptions failed: %08x\n", hres);
 632     ok(supported == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 633        "supported=%x\n", supported);
 634     ok(enabled == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 635        "enabled=%x\n", enabled);
 636
 637     IObjectSafety_Release(safety);
 638 }
 639
 640 #define parse_script_a(p,s) _parse_script_a(__LINE__,p,s)
 641 static void _parse_script_a(unsigned line, IActiveScriptParse *parser, const char *script)
 642 {
 643     BSTR str;
 644     HRESULT hres;
 645
 646     str = a2bstr(script);
 647     hres = IActiveScriptParse64_ParseScriptText(parser, str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 648     SysFreeString(str);
 649     ok_(__FILE__,line)(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 650 }
 651
 652 static IActiveScriptParse *create_script(void)
 653 {
 654     IActiveScriptParse *parser;
 655     IActiveScript *script;
 656     HRESULT hres;
 657
 658     QS_SecMgr_hres = S_OK;
 659     ProcessUrlAction_hres = S_OK;
 660     ProcessUrlAction_policy = URLPOLICY_ALLOW;
 661     CreateInstance_hres = S_OK;
 662     QueryCustomPolicy_hres = S_OK;
 663     QueryCustomPolicy_psize = sizeof(DWORD);
 664     QueryCustomPolicy_policy = URLPOLICY_ALLOW;
 665     QI_IDispatch_hres = S_OK;
 666
 667     hres = CoCreateInstance(&CLSID_JScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 668             &IID_IActiveScript, (void**)&script);
 669     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 670
 671     set_safety_options((IUnknown*)script);
 672
 673     hres = IActiveScript_QueryInterface(script, &IID_IActiveScriptParse, (void**)&parser);
 674     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 675
 676     hres = IActiveScriptParse64_InitNew(parser);
 677     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 678
 679     hres = IActiveScript_SetScriptSite(script, &ActiveScriptSite);
 680     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 681
 682     hres = IActiveScript_AddNamedItem(script, testW,
 683             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 684     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 685
 686     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_STARTED);
 687     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 688
 689     IActiveScript_Release(script);
 690
 691     parse_script_a(parser,
 692             "function testException(func, type, number) {\n"
 693             "try {\n"
 694             "    func();\n"
 695             "}catch(e) {\n"
 696             "    ok(e.name === type, 'e.name = ' + e.name + ', expected ' + type)\n"
 697             "    ok(e.number === number, 'e.number = ' + e.number + ', expected ' + number);\n"
 698             "    return;\n"
 699             "}"
 700             "ok(false, 'exception expected');\n"
 701             "}");
 702
 703     return parser;
 704 }
 705
 706 static IDispatchEx *parse_procedure_a(IActiveScriptParse *parser, const char *src)
 707 {
 708     IActiveScriptParseProcedure2 *parse_proc;
 709     IDispatchEx *dispex;
 710     IDispatch *disp;
 711     BSTR str;
 712     HRESULT hres;
 713
 714     hres = IUnknown_QueryInterface(parser, &IID_IActiveScriptParseProcedure2, (void**)&parse_proc);
 715     ok(hres == S_OK, "Coult not get IActiveScriptParseProcedure2: %08x\n", hres);
 716
 717     str = a2bstr(src);
 718     hres = IActiveScriptParseProcedure2_64_ParseProcedureText(parse_proc, str, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, &disp);
 719     SysFreeString(str);
 720     IUnknown_Release(parse_proc);
 721     ok(hres == S_OK, "ParseProcedureText failed: %08x\n", hres);
 722     ok(disp != NULL, "disp == NULL\n");
 723
 724     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 725     IDispatch_Release(dispex);
 726     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
 727
 728     return dispex;
 729 }
 730
 731 #define call_procedure(p,c) _call_procedure(__LINE__,p,c)
 732 static void _call_procedure(unsigned line, IDispatchEx *proc, IServiceProvider *caller)
 733 {
 734     DISPPARAMS dp = {NULL,NULL,0,0};
 735     EXCEPINFO ei = {0};
 736     HRESULT hres;
 737
 738     hres = IDispatchEx_InvokeEx(proc, DISPID_VALUE, 0, DISPATCH_METHOD, &dp, NULL, &ei, caller);
 739     ok_(__FILE__,line)(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 740
 741 }
 742
 743 static void test_ActiveXObject(void)
 744 {
 745     IActiveScriptParse *parser;
 746     IDispatchEx *proc;
 747
 748     parser = create_script();
 749
 750     SET_EXPECT(Host_QS_SecMgr);
 751     SET_EXPECT(ProcessUrlAction);
 752     SET_EXPECT(CreateInstance);
 753     SET_EXPECT(QueryCustomPolicy);
 754     SET_EXPECT(QI_IObjectWithSite);
 755     SET_EXPECT(reportSuccess);
 756     parse_script_a(parser, "(new ActiveXObject('Wine.Test')).reportSuccess();");
 757     CHECK_CALLED(Host_QS_SecMgr);
 758     CHECK_CALLED(ProcessUrlAction);
 759     CHECK_CALLED(CreateInstance);
 760     CHECK_CALLED(QueryCustomPolicy);
 761     CHECK_CALLED(QI_IObjectWithSite);
 762     CHECK_CALLED(reportSuccess);
 763
 764     proc = parse_procedure_a(parser, "(new ActiveXObject('Wine.Test')).reportSuccess();");
 765
 766     SET_EXPECT(ProcessUrlAction);
 767     SET_EXPECT(CreateInstance);
 768     SET_EXPECT(QueryCustomPolicy);
 769     SET_EXPECT(QI_IObjectWithSite);
 770     SET_EXPECT(reportSuccess);
 771     call_procedure(proc, NULL);
 772     CHECK_CALLED(ProcessUrlAction);
 773     CHECK_CALLED(CreateInstance);
 774     CHECK_CALLED(QueryCustomPolicy);
 775     CHECK_CALLED(QI_IObjectWithSite);
 776     CHECK_CALLED(reportSuccess);
 777
 778     SET_EXPECT(ProcessUrlAction);
 779     SET_EXPECT(CreateInstance);
 780     SET_EXPECT(QueryCustomPolicy);
 781     SET_EXPECT(QI_IObjectWithSite);
 782     SET_EXPECT(reportSuccess);
 783     call_procedure(proc, &caller_sp);
 784     CHECK_CALLED(ProcessUrlAction);
 785     CHECK_CALLED(CreateInstance);
 786     CHECK_CALLED(QueryCustomPolicy);
 787     CHECK_CALLED(QI_IObjectWithSite);
 788     CHECK_CALLED(reportSuccess);
 789
 790     IDispatchEx_Release(proc);
 791     IUnknown_Release(parser);
 792
 793     parser = create_script();
 794     proc = parse_procedure_a(parser, "(new ActiveXObject('Wine.Test')).reportSuccess();");
 795
 796     SET_EXPECT(Host_QS_SecMgr);
 797     SET_EXPECT(ProcessUrlAction);
 798     SET_EXPECT(CreateInstance);
 799     SET_EXPECT(QueryCustomPolicy);
 800     SET_EXPECT(QI_IObjectWithSite);
 801     SET_EXPECT(reportSuccess);
 802     call_procedure(proc, &caller_sp);
 803     CHECK_CALLED(Host_QS_SecMgr);
 804     CHECK_CALLED(ProcessUrlAction);
 805     CHECK_CALLED(CreateInstance);
 806     CHECK_CALLED(QueryCustomPolicy);
 807     CHECK_CALLED(QI_IObjectWithSite);
 808     CHECK_CALLED(reportSuccess);
 809
 810     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.TestABC'); }, 'Error', -2146827859);");
 811
 812     IDispatchEx_Release(proc);
 813     IUnknown_Release(parser);
 814
 815     parser = create_script();
 816     QS_SecMgr_hres = E_NOINTERFACE;
 817
 818     SET_EXPECT(Host_QS_SecMgr);
 819     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 820     CHECK_CALLED(Host_QS_SecMgr);
 821
 822     IUnknown_Release(parser);
 823
 824     parser = create_script();
 825     ProcessUrlAction_hres = E_FAIL;
 826
 827     SET_EXPECT(Host_QS_SecMgr);
 828     SET_EXPECT(ProcessUrlAction);
 829     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 830     CHECK_CALLED(Host_QS_SecMgr);
 831     CHECK_CALLED(ProcessUrlAction);
 832
 833     IUnknown_Release(parser);
 834
 835     parser = create_script();
 836     ProcessUrlAction_policy = URLPOLICY_DISALLOW;
 837
 838     SET_EXPECT(Host_QS_SecMgr);
 839     SET_EXPECT(ProcessUrlAction);
 840     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 841     CHECK_CALLED(Host_QS_SecMgr);
 842     CHECK_CALLED(ProcessUrlAction);
 843
 844     IUnknown_Release(parser);
 845
 846     parser = create_script();
 847     CreateInstance_hres = E_FAIL;
 848
 849     SET_EXPECT(Host_QS_SecMgr);
 850     SET_EXPECT(ProcessUrlAction);
 851     SET_EXPECT(CreateInstance);
 852     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 853     CHECK_CALLED(Host_QS_SecMgr);
 854     CHECK_CALLED(ProcessUrlAction);
 855     CHECK_CALLED(CreateInstance);
 856
 857     IUnknown_Release(parser);
 858
 859     parser = create_script();
 860     QueryCustomPolicy_hres = E_FAIL;
 861
 862     SET_EXPECT(Host_QS_SecMgr);
 863     SET_EXPECT(ProcessUrlAction);
 864     SET_EXPECT(CreateInstance);
 865     SET_EXPECT(QueryCustomPolicy);
 866     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 867     CHECK_CALLED(Host_QS_SecMgr);
 868     CHECK_CALLED(ProcessUrlAction);
 869     CHECK_CALLED(CreateInstance);
 870     CHECK_CALLED(QueryCustomPolicy);
 871
 872     IUnknown_Release(parser);
 873
 874     parser = create_script();
 875     QueryCustomPolicy_psize = 6;
 876
 877     SET_EXPECT(Host_QS_SecMgr);
 878     SET_EXPECT(ProcessUrlAction);
 879     SET_EXPECT(CreateInstance);
 880     SET_EXPECT(QueryCustomPolicy);
 881     SET_EXPECT(QI_IObjectWithSite);
 882     SET_EXPECT(reportSuccess);
 883     parse_script_a(parser, "(new ActiveXObject('Wine.Test')).reportSuccess();");
 884     CHECK_CALLED(Host_QS_SecMgr);
 885     CHECK_CALLED(ProcessUrlAction);
 886     CHECK_CALLED(CreateInstance);
 887     CHECK_CALLED(QueryCustomPolicy);
 888     CHECK_CALLED(QI_IObjectWithSite);
 889     CHECK_CALLED(reportSuccess);
 890
 891     IUnknown_Release(parser);
 892
 893     parser = create_script();
 894     QueryCustomPolicy_policy = URLPOLICY_DISALLOW;
 895
 896     SET_EXPECT(Host_QS_SecMgr);
 897     SET_EXPECT(ProcessUrlAction);
 898     SET_EXPECT(CreateInstance);
 899     SET_EXPECT(QueryCustomPolicy);
 900     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 901     CHECK_CALLED(Host_QS_SecMgr);
 902     CHECK_CALLED(ProcessUrlAction);
 903     CHECK_CALLED(CreateInstance);
 904     CHECK_CALLED(QueryCustomPolicy);
 905
 906     QueryCustomPolicy_psize = 6;
 907
 908     SET_EXPECT(ProcessUrlAction);
 909     SET_EXPECT(CreateInstance);
 910     SET_EXPECT(QueryCustomPolicy);
 911     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 912     CHECK_CALLED(ProcessUrlAction);
 913     CHECK_CALLED(CreateInstance);
 914     CHECK_CALLED(QueryCustomPolicy);
 915
 916     QueryCustomPolicy_policy = URLPOLICY_ALLOW;
 917     QueryCustomPolicy_psize = 3;
 918
 919     SET_EXPECT(ProcessUrlAction);
 920     SET_EXPECT(CreateInstance);
 921     SET_EXPECT(QueryCustomPolicy);
 922     parse_script_a(parser, "testException(function() { new ActiveXObject('Wine.Test'); }, 'Error', -2146827859);");
 923     CHECK_CALLED(ProcessUrlAction);
 924     CHECK_CALLED(CreateInstance);
 925     CHECK_CALLED(QueryCustomPolicy);
 926
 927     IUnknown_Release(parser);
 928 }
 929
 930 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 931 {
 932     HKEY hkey;
 933     DWORD res;
 934
 935     if(!init) {
 936         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 937         return TRUE;
 938     }
 939
 940     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 941     if(res != ERROR_SUCCESS)
 942         return FALSE;
 943
 944     if(def_value)
 945         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 946
 947     RegCloseKey(hkey);
 948
 949     return res == ERROR_SUCCESS;
 950 }
 951
 952 static BOOL init_registry(BOOL init)
 953 {
 954     return init_key("Wine.Test\\CLSID", TESTOBJ_CLSID, init);
 955 }
 956
 957 static BOOL register_activex(void)
 958 {
 959     DWORD regid;
 960     HRESULT hres;
 961
 962     if(!init_registry(TRUE)) {
 963         init_registry(FALSE);
 964         return FALSE;
 965     }
 966
 967     hres = CoRegisterClassObject(&CLSID_TestObj, (IUnknown *)&activex_cf,
 968                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 969     ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
 970
 971     return TRUE;
 972 }
 973
 974 START_TEST(activex)
 975 {
 976     CoInitialize(NULL);
 977     register_activex();
 978
 979     test_ActiveXObject();
 980
 981     init_registry(FALSE);
 982     CoUninitialize();
 983 }