modules/rostests/winetests/jscript/caller.c

   1 /*
   2  * Copyright 2012 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 WIN32_NO_STATUS
  20 #define _INC_WINDOWS
  21 #define COM_NO_WINDOWS_H
  22
  23 #include <stdio.h>
  24
  25 #define COBJMACROS
  26 #define CONST_VTABLE
  27
  28 #include <windef.h>
  29 #include <winbase.h>
  30 #include <winnls.h>
  31 #include <ole2.h>
  32 #include <dispex.h>
  33 #include <activscp.h>
  34 #include <objsafe.h>
  35
  36 #include <wine/test.h>
  37
  38 #ifdef _WIN64
  39
  40 #define IActiveScriptParse_QueryInterface IActiveScriptParse64_QueryInterface
  41 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  42 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  43 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  44
  45 #else
  46
  47 #define IActiveScriptParse_QueryInterface IActiveScriptParse32_QueryInterface
  48 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  49 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  50 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  51
  52 #endif
  53
  54 static const CLSID CLSID_JScript =
  55     {0xf414c260,0x6ac0,0x11cf,{0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58}};
  56
  57 #define DEFINE_EXPECT(func) \
  58     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  59
  60 #define SET_EXPECT(func) \
  61     expect_ ## func = TRUE
  62
  63 #define CHECK_EXPECT2(func) \
  64     do { \
  65         ok(expect_ ##func, "unexpected call " #func "\n"); \
  66         called_ ## func = TRUE; \
  67     }while(0)
  68
  69 #define CHECK_EXPECT(func) \
  70     do { \
  71         CHECK_EXPECT2(func); \
  72         expect_ ## func = FALSE; \
  73     }while(0)
  74
  75 #define CHECK_CALLED(func) \
  76     do { \
  77         ok(called_ ## func, "expected " #func "\n"); \
  78         expect_ ## func = called_ ## func = FALSE; \
  79     }while(0)
  80
  81 DEFINE_EXPECT(testArgConv);
  82
  83 static const WCHAR testW[] = {'t','e','s','t',0};
  84
  85 static IVariantChangeType *script_change_type;
  86 static IDispatch *stored_obj;
  87
  88 #define DISPID_TEST_TESTARGCONV      0x1000
  89
  90 static BSTR a2bstr(const char *str)
  91 {
  92     BSTR ret;
  93     int len;
  94
  95     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  96     ret = SysAllocStringLen(NULL, len-1);
  97     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  98
  99     return ret;
 100 }
 101
 102 static int strcmp_wa(LPCWSTR strw, const char *stra)
 103 {
 104     CHAR buf[512];
 105     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
 106     return lstrcmpA(buf, stra);
 107 }
 108
 109 typedef struct {
 110     int int_result;
 111     const char *str_result;
 112     VARIANT_BOOL bool_result;
 113     int test_double;
 114     double double_result;
 115 } conv_results_t;
 116
 117 #define call_change_type(a,b,c,d) _call_change_type(__LINE__,a,b,c,d)
 118 static void _call_change_type(unsigned line, IVariantChangeType *change_type, VARIANT *dst, VARIANT *src, VARTYPE vt)
 119 {
 120     HRESULT hres;
 121
 122     VariantInit(dst);
 123     hres = IVariantChangeType_ChangeType(change_type, dst, src, 0, vt);
 124     ok_(__FILE__,line)(hres == S_OK, "ChangeType(%d) failed: %08x\n", vt, hres);
 125     ok_(__FILE__,line)(V_VT(dst) == vt, "V_VT(dst) = %d\n", V_VT(dst));
 126 }
 127
 128 #define change_type_fail(a,b,c,d) _change_type_fail(__LINE__,a,b,c,d)
 129 static void _change_type_fail(unsigned line, IVariantChangeType *change_type, VARIANT *src, VARTYPE vt, HRESULT exhres)
 130 {
 131     VARIANT v;
 132     HRESULT hres;
 133
 134     V_VT(&v) = VT_EMPTY;
 135     hres = IVariantChangeType_ChangeType(change_type, &v, src, 0, vt);
 136     ok_(__FILE__,line)(hres == exhres, "ChangeType failed: %08x, expected %08x\n", hres, exhres);
 137 }
 138
 139 static void test_change_type(IVariantChangeType *change_type, VARIANT *src, const conv_results_t *ex)
 140 {
 141     VARIANT v;
 142
 143     call_change_type(change_type, &v, src, VT_I4);
 144     ok(V_I4(&v) == ex->int_result, "V_I4(v) = %d, expected %d\n", V_I4(&v), ex->int_result);
 145
 146     call_change_type(change_type, &v, src, VT_BSTR);
 147     ok(!strcmp_wa(V_BSTR(&v), ex->str_result), "V_BSTR(v) = %s, expected %s\n", wine_dbgstr_w(V_BSTR(&v)), ex->str_result);
 148     VariantClear(&v);
 149
 150     call_change_type(change_type, &v, src, VT_BOOL);
 151     ok(V_BOOL(&v) == ex->bool_result, "V_BOOL(v) = %x, expected %x\n", V_BOOL(&v), ex->bool_result);
 152
 153     if(ex->test_double) {
 154         call_change_type(change_type, &v, src, VT_R8);
 155         ok(V_R8(&v) == ex->double_result, "V_R8(v) = %lf, expected %lf\n", V_R8(&v), ex->double_result);
 156
 157         call_change_type(change_type, &v, src, VT_R4);
 158         ok(V_R4(&v) == (float)ex->double_result, "V_R4(v) = %f, expected %f\n", V_R4(&v), (float)ex->double_result);
 159     }
 160
 161     if(V_VT(src) == VT_NULL)
 162         call_change_type(change_type, &v, src, VT_NULL);
 163     else
 164         change_type_fail(change_type, src, VT_NULL, E_NOTIMPL);
 165
 166     if(V_VT(src) == VT_EMPTY)
 167         call_change_type(change_type, &v, src, VT_EMPTY);
 168     else
 169         change_type_fail(change_type, src, VT_EMPTY, E_NOTIMPL);
 170
 171     call_change_type(change_type, &v, src, VT_I2);
 172     ok(V_I2(&v) == (INT16)ex->int_result, "V_I2(v) = %d, expected %d\n", V_I2(&v), ex->int_result);
 173 }
 174
 175 static void test_change_types(IVariantChangeType *change_type, IDispatch *obj_disp)
 176 {
 177     VARIANT v, dst;
 178     BSTR str;
 179     HRESULT hres;
 180
 181     static const conv_results_t bool_results[] = {
 182         {0, "false", VARIANT_FALSE, 1,0.0},
 183         {1, "true", VARIANT_TRUE, 1,1.0}};
 184     static const conv_results_t int_results[] = {
 185         {0, "0", VARIANT_FALSE, 1,0.0},
 186         {-100, "-100", VARIANT_TRUE, 1,-100.0},
 187         {0x10010, "65552", VARIANT_TRUE, 1,65552.0}};
 188     static const conv_results_t empty_results =
 189         {0, "undefined", VARIANT_FALSE, 0,0};
 190     static const conv_results_t null_results =
 191         {0, "null", VARIANT_FALSE, 0,0};
 192     static const conv_results_t obj_results =
 193         {10, "strval", VARIANT_TRUE, 1,10.0};
 194
 195     V_VT(&v) = VT_BOOL;
 196     V_BOOL(&v) = VARIANT_FALSE;
 197     test_change_type(change_type, &v, bool_results);
 198     V_BOOL(&v) = VARIANT_TRUE;
 199     test_change_type(change_type, &v, bool_results+1);
 200
 201     V_VT(&v) = VT_I4;
 202     V_I4(&v) = 0;
 203     test_change_type(change_type, &v, int_results);
 204     V_I4(&v) = -100;
 205     test_change_type(change_type, &v, int_results+1);
 206     V_I4(&v) = 0x10010;
 207     test_change_type(change_type, &v, int_results+2);
 208
 209     V_VT(&v) = VT_EMPTY;
 210     test_change_type(change_type, &v, &empty_results);
 211
 212     V_VT(&v) = VT_NULL;
 213     test_change_type(change_type, &v, &null_results);
 214
 215     V_VT(&v) = VT_DISPATCH;
 216     V_DISPATCH(&v) = obj_disp;
 217     test_change_type(change_type, &v, &obj_results);
 218
 219     V_VT(&v) = VT_BOOL;
 220     V_BOOL(&v) = VARIANT_FALSE;
 221     V_VT(&dst) = 0xdead;
 222     hres = IVariantChangeType_ChangeType(change_type, &dst, &v, 0, VT_I4);
 223     ok(hres == DISP_E_BADVARTYPE, "ChangeType failed: %08x, expected DISP_E_BADVARTYPE\n", hres);
 224     ok(V_VT(&dst) == 0xdead, "V_VT(dst) = %d\n", V_VT(&dst));
 225
 226     /* Test conversion in place */
 227     V_VT(&v) = VT_BSTR;
 228     V_BSTR(&v) = str = a2bstr("test");
 229     hres = IVariantChangeType_ChangeType(change_type, &v, &v, 0, VT_BSTR);
 230     ok(hres == S_OK, "ChangeType failed: %08x\n", hres);
 231     ok(V_VT(&v) == VT_BSTR, "V_VT(v) = %d\n", V_VT(&v));
 232     ok(V_BSTR(&v) != str, "V_BSTR(v) == str\n");
 233     ok(!strcmp_wa(V_BSTR(&v), "test"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 234 }
 235
 236 static void test_caller(IServiceProvider *caller, IDispatch *arg_obj)
 237 {
 238     IVariantChangeType *change_type;
 239     HRESULT hres;
 240
 241     hres = IServiceProvider_QueryService(caller, &SID_VariantConversion, &IID_IVariantChangeType, (void**)&change_type);
 242     ok(hres == S_OK, "Could not get SID_VariantConversion service: %08x\n", hres);
 243
 244     ok(change_type == script_change_type, "change_type != script_change_type\n");
 245     test_change_types(change_type, arg_obj);
 246
 247     IVariantChangeType_Release(change_type);
 248 }
 249
 250 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 251 {
 252     if(IsEqualGUID(riid, &IID_IUnknown)) {
 253         *ppv = iface;
 254     }else if(IsEqualGUID(riid, &IID_IDispatch) || IsEqualGUID(riid, &IID_IDispatchEx)) {
 255         *ppv = iface;
 256     }else if(IsEqualGUID(&IID_IObjectSafety, riid)) {
 257         ok(0, "Unexpected IID_IObjectSafety query\n");
 258     }else {
 259         *ppv = NULL;
 260         return E_NOINTERFACE;
 261     }
 262
 263     return S_OK;
 264 }
 265
 266 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 267 {
 268     return 2;
 269 }
 270
 271 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 272 {
 273     return 1;
 274 }
 275
 276 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 277 {
 278     ok(0, "unexpected call\n");
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 283                                               LCID lcid, ITypeInfo **ppTInfo)
 284 {
 285     ok(0, "unexpected call\n");
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 290                                                 LPOLESTR *rgszNames, UINT cNames,
 291                                                 LCID lcid, DISPID *rgDispId)
 292 {
 293     ok(0, "unexpected call\n");
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 298                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 299                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 300 {
 301     ok(0, "unexpected call\n");
 302     return E_NOTIMPL;
 303 }
 304
 305 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 306 {
 307     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 312 {
 313     ok(0, "unexpected call\n");
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 318 {
 319     ok(0, "unexpected call\n");
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 324 {
 325     ok(0, "unexpected call\n");
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 330 {
 331     ok(0, "unexpected call\n");
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 336 {
 337     ok(0, "unexpected call\n");
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI Test_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 342 {
 343     if(!strcmp_wa(bstrName, "testArgConv")) {
 344         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 345         *pid = DISPID_TEST_TESTARGCONV;
 346         return S_OK;
 347     }
 348
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI Test_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 353         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 354 {
 355     ok(pspCaller != NULL, "pspCaller == NULL\n");
 356
 357     switch(id) {
 358     case DISPID_TEST_TESTARGCONV:
 359         CHECK_EXPECT(testArgConv);
 360
 361         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 362         ok(pdp != NULL, "pdp == NULL\n");
 363         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 364         ok(!pvarRes, "pvarRes != NULL\n");
 365         ok(pei != NULL, "pei == NULL\n");
 366
 367         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 368         ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 369
 370         test_caller(pspCaller, V_DISPATCH(pdp->rgvarg));
 371
 372         stored_obj = V_DISPATCH(pdp->rgvarg);
 373         IDispatch_AddRef(stored_obj);
 374         break;
 375
 376     default:
 377         ok(0, "unexpected call\n");
 378         return E_NOTIMPL;
 379     }
 380
 381     return S_OK;
 382 }
 383
 384 static IDispatchExVtbl testObjVtbl = {
 385     DispatchEx_QueryInterface,
 386     DispatchEx_AddRef,
 387     DispatchEx_Release,
 388     DispatchEx_GetTypeInfoCount,
 389     DispatchEx_GetTypeInfo,
 390     DispatchEx_GetIDsOfNames,
 391     DispatchEx_Invoke,
 392     Test_GetDispID,
 393     Test_InvokeEx,
 394     DispatchEx_DeleteMemberByName,
 395     DispatchEx_DeleteMemberByDispID,
 396     DispatchEx_GetMemberProperties,
 397     DispatchEx_GetMemberName,
 398     DispatchEx_GetNextDispID,
 399     DispatchEx_GetNameSpaceParent
 400 };
 401
 402 static IDispatchEx testObj = { &testObjVtbl };
 403
 404 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 405 {
 406     if(IsEqualGUID(&IID_IUnknown, riid)) {
 407         *ppv = iface;
 408     }else if(IsEqualGUID(&IID_IActiveScriptSite, riid)) {
 409         *ppv = iface;
 410     }else {
 411         *ppv = NULL;
 412         return E_NOINTERFACE;
 413     }
 414
 415     IUnknown_AddRef((IUnknown*)*ppv);
 416     return S_OK;
 417 }
 418
 419 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 420 {
 421     return 2;
 422 }
 423
 424 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 425 {
 426     return 1;
 427 }
 428
 429 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 430 {
 431     *plcid = GetUserDefaultLCID();
 432     return S_OK;
 433 }
 434
 435 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 436         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 437 {
 438     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
 439     ok(!ppti, "ppti != NULL\n");
 440     ok(!strcmp_wa(pstrName, "test"), "pstrName = %s\n", wine_dbgstr_w(pstrName));
 441
 442     *ppiunkItem = (IUnknown*)&testObj;
 443     return S_OK;
 444 }
 445
 446 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 447 {
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 452         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 453 {
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 458 {
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 463 {
 464     return E_NOTIMPL;
 465 }
 466
 467 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 468 {
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 473 {
 474     return E_NOTIMPL;
 475 }
 476
 477 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 478     ActiveScriptSite_QueryInterface,
 479     ActiveScriptSite_AddRef,
 480     ActiveScriptSite_Release,
 481     ActiveScriptSite_GetLCID,
 482     ActiveScriptSite_GetItemInfo,
 483     ActiveScriptSite_GetDocVersionString,
 484     ActiveScriptSite_OnScriptTerminate,
 485     ActiveScriptSite_OnStateChange,
 486     ActiveScriptSite_OnScriptError,
 487     ActiveScriptSite_OnEnterScript,
 488     ActiveScriptSite_OnLeaveScript
 489 };
 490
 491 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
 492
 493 #define parse_script_a(p,s) _parse_script_a(__LINE__,p,s)
 494 static void _parse_script_a(unsigned line, IActiveScriptParse *parser, const char *script)
 495 {
 496     BSTR str;
 497     HRESULT hres;
 498
 499     str = a2bstr(script);
 500     hres = IActiveScriptParse_ParseScriptText(parser, str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 501     SysFreeString(str);
 502     ok_(__FILE__,line)(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 503 }
 504
 505 static IActiveScriptParse *create_script(void)
 506 {
 507     IActiveScriptParse *parser;
 508     IActiveScript *script;
 509     HRESULT hres;
 510
 511     hres = CoCreateInstance(&CLSID_JScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 512             &IID_IActiveScript, (void**)&script);
 513     if(FAILED(hres))
 514         return NULL;
 515
 516     hres = IActiveScript_QueryInterface(script, &IID_IActiveScriptParse, (void**)&parser);
 517     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 518
 519     hres = IActiveScriptParse_InitNew(parser);
 520     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 521
 522     hres = IActiveScript_SetScriptSite(script, &ActiveScriptSite);
 523     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 524
 525     hres = IActiveScript_AddNamedItem(script, testW,
 526             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 527     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 528
 529     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_STARTED);
 530     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 531
 532     IActiveScript_Release(script);
 533
 534     return parser;
 535 }
 536
 537 static void run_scripts(void)
 538 {
 539     IActiveScriptParse *parser;
 540     HRESULT hres;
 541
 542     parser = create_script();
 543
 544     hres = IActiveScriptParse_QueryInterface(parser, &IID_IVariantChangeType, (void**)&script_change_type);
 545     ok(hres == S_OK, "Could not get IVariantChangeType iface: %08x\n", hres);
 546
 547     SET_EXPECT(testArgConv);
 548     parse_script_a(parser,
 549                    "var obj = {"
 550                    "    toString: function() { return 'strval'; },"
 551                    "    valueOf: function()  { return 10; }"
 552                    "};"
 553                    "testArgConv(obj);");
 554     CHECK_CALLED(testArgConv);
 555
 556     test_change_types(script_change_type, stored_obj);
 557     IDispatch_Release(stored_obj);
 558     IVariantChangeType_Release(script_change_type);
 559
 560     IActiveScriptParse_Release(parser);
 561 }
 562
 563 static BOOL check_jscript(void)
 564 {
 565     IActiveScriptProperty *script_prop;
 566     IActiveScriptParse *parser;
 567     BSTR str;
 568     HRESULT hres;
 569
 570     parser = create_script();
 571     if(!parser)
 572         return FALSE;
 573
 574     str = a2bstr("if(!('localeCompare' in String.prototype)) throw 1;");
 575     hres = IActiveScriptParse_ParseScriptText(parser, str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 576     SysFreeString(str);
 577
 578     if(hres == S_OK)
 579         hres = IActiveScriptParse_QueryInterface(parser, &IID_IActiveScriptProperty, (void**)&script_prop);
 580     IActiveScriptParse_Release(parser);
 581     if(hres == S_OK)
 582         IActiveScriptProperty_Release(script_prop);
 583
 584     return hres == S_OK;
 585 }
 586
 587 START_TEST(caller)
 588 {
 589     CoInitialize(NULL);
 590
 591     if(check_jscript())
 592         run_scripts();
 593     else
 594         win_skip("Broken (too old) jscript\n");
 595
 596     CoUninitialize();
 597 }