git.oblomov.eu Git - wine/blob - dlls/vbscript/tests/run.c

   1 /*
   2  * Copyright 2011 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
  28 #include "wine/test.h"
  29
  30 extern const CLSID CLSID_VBScript;
  31
  32 #define DEFINE_EXPECT(func) \
  33     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  34
  35 #define SET_EXPECT(func) \
  36     expect_ ## func = TRUE
  37
  38 #define CHECK_EXPECT2(func) \
  39     do { \
  40         ok(expect_ ##func, "unexpected call " #func "\n"); \
  41         called_ ## func = TRUE; \
  42     }while(0)
  43
  44 #define CHECK_EXPECT(func) \
  45     do { \
  46         CHECK_EXPECT2(func); \
  47         expect_ ## func = FALSE; \
  48     }while(0)
  49
  50 #define CHECK_CALLED(func) \
  51     do { \
  52         ok(called_ ## func, "expected " #func "\n"); \
  53         expect_ ## func = called_ ## func = FALSE; \
  54     }while(0)
  55
  56 DEFINE_EXPECT(global_success_d);
  57 DEFINE_EXPECT(global_success_i);
  58 DEFINE_EXPECT(global_vbvar_d);
  59 DEFINE_EXPECT(global_vbvar_i);
  60 DEFINE_EXPECT(testobj_propget_d);
  61 DEFINE_EXPECT(testobj_propget_i);
  62 DEFINE_EXPECT(testobj_propput_d);
  63 DEFINE_EXPECT(testobj_propput_i);
  64 DEFINE_EXPECT(global_propargput_d);
  65 DEFINE_EXPECT(global_propargput_i);
  66 DEFINE_EXPECT(global_propargput1_d);
  67 DEFINE_EXPECT(global_propargput1_i);
  68 DEFINE_EXPECT(collectionobj_newenum_i);
  69 DEFINE_EXPECT(Next);
  70
  71 #define DISPID_GLOBAL_REPORTSUCCESS 1000
  72 #define DISPID_GLOBAL_TRACE         1001
  73 #define DISPID_GLOBAL_OK            1002
  74 #define DISPID_GLOBAL_GETVT         1003
  75 #define DISPID_GLOBAL_ISENGLANG     1004
  76 #define DISPID_GLOBAL_VBVAR         1005
  77 #define DISPID_GLOBAL_TESTOBJ       1006
  78 #define DISPID_GLOBAL_ISNULLDISP    1007
  79 #define DISPID_GLOBAL_TESTDISP      1008
  80 #define DISPID_GLOBAL_REFOBJ        1009
  81 #define DISPID_GLOBAL_COUNTER       1010
  82 #define DISPID_GLOBAL_PROPARGPUT    1011
  83 #define DISPID_GLOBAL_PROPARGPUT1   1012
  84 #define DISPID_GLOBAL_COLLOBJ       1013
  85
  86 #define DISPID_TESTOBJ_PROPGET      2000
  87 #define DISPID_TESTOBJ_PROPPUT      2001
  88
  89 #define DISPID_COLLOBJ_RESET        3000
  90
  91 static const WCHAR testW[] = {'t','e','s','t',0};
  92
  93 static BOOL strict_dispid_check;
  94 static const char *test_name = "(null)";
  95 static int test_counter;
  96
  97 static BSTR a2bstr(const char *str)
  98 {
  99     BSTR ret;
 100     int len;
 101
 102     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 103     ret = SysAllocStringLen(NULL, len-1);
 104     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 105
 106     return ret;
 107 }
 108
 109 static int strcmp_wa(LPCWSTR strw, const char *stra)
 110 {
 111     CHAR buf[512];
 112     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
 113     return lstrcmpA(buf, stra);
 114 }
 115
 116 static const char *vt2a(VARIANT *v)
 117 {
 118     if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
 119         static char buf[64];
 120         sprintf(buf, "%s*", vt2a(V_BYREF(v)));
 121         return buf;
 122     }
 123
 124     switch(V_VT(v)) {
 125     case VT_EMPTY:
 126         return "VT_EMPTY";
 127     case VT_NULL:
 128         return "VT_NULL";
 129     case VT_I2:
 130         return "VT_I2";
 131     case VT_I4:
 132         return "VT_I4";
 133     case VT_R8:
 134         return "VT_R8";
 135     case VT_BSTR:
 136         return "VT_BSTR";
 137     case VT_DISPATCH:
 138         return "VT_DISPATCH";
 139     case VT_BOOL:
 140         return "VT_BOOL";
 141     case VT_ARRAY|VT_VARIANT:
 142         return "VT_ARRAY|VT_VARIANT";
 143     default:
 144         ok(0, "unknown vt %d\n", V_VT(v));
 145         return NULL;
 146     }
 147 }
 148
 149 /* Returns true if the user interface is in English. Note that this does not
 150  * presume of the formatting of dates, numbers, etc.
 151  */
 152 static BOOL is_lang_english(void)
 153 {
 154     static HMODULE hkernel32 = NULL;
 155     static LANGID (WINAPI *pGetThreadUILanguage)(void) = NULL;
 156     static LANGID (WINAPI *pGetUserDefaultUILanguage)(void) = NULL;
 157
 158     if (!hkernel32)
 159     {
 160         hkernel32 = GetModuleHandleA("kernel32.dll");
 161         pGetThreadUILanguage = (void*)GetProcAddress(hkernel32, "GetThreadUILanguage");
 162         pGetUserDefaultUILanguage = (void*)GetProcAddress(hkernel32, "GetUserDefaultUILanguage");
 163     }
 164     if (pGetThreadUILanguage)
 165         return PRIMARYLANGID(pGetThreadUILanguage()) == LANG_ENGLISH;
 166     if (pGetUserDefaultUILanguage)
 167         return PRIMARYLANGID(pGetUserDefaultUILanguage()) == LANG_ENGLISH;
 168
 169     return PRIMARYLANGID(GetUserDefaultLangID()) == LANG_ENGLISH;
 170 }
 171
 172 static void test_disp(IDispatch *disp)
 173 {
 174     DISPID id, public_prop_id, public_prop2_id, public_func_id, public_sub_id, defvalget_id;
 175     DISPID named_args[5] = {DISPID_PROPERTYPUT};
 176     VARIANT v, args[5];
 177     DISPPARAMS dp = {args, named_args};
 178     IDispatchEx *dispex;
 179     EXCEPINFO ei = {0};
 180     BSTR str;
 181     HRESULT hres;
 182
 183     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 184     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
 185
 186     str = a2bstr("publicProp");
 187     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_prop_id);
 188     SysFreeString(str);
 189     ok(hres == S_OK, "GetDispID(publicProp) failed: %08x\n", hres);
 190
 191     str = a2bstr("PUBLICPROP");
 192     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
 193     SysFreeString(str);
 194     ok(hres == S_OK, "GetDispID(PUBLICPROP) failed: %08x\n", hres);
 195     ok(public_prop_id == id, "id = %d\n", public_prop_id);
 196
 197     str = a2bstr("publicPROP2");
 198     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_prop2_id);
 199     SysFreeString(str);
 200     ok(hres == S_OK, "GetDispID(publicProp2) failed: %08x\n", hres);
 201
 202     str = a2bstr("defValGet");
 203     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &defvalget_id);
 204     SysFreeString(str);
 205     ok(hres == S_OK, "GetDispID(defValGet) failed: %08x\n", hres);
 206     ok(defvalget_id == DISPID_VALUE, "id = %d\n", defvalget_id);
 207
 208     str = a2bstr("privateProp");
 209     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
 210     SysFreeString(str);
 211     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 212     ok(id == -1, "id = %d\n", id);
 213
 214     str = a2bstr("class_initialize");
 215     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
 216     SysFreeString(str);
 217     ok(hres == S_OK, "GetDispID(publicProp2) failed: %08x\n", hres);
 218
 219     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 220     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 221     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 222
 223     V_VT(args) = VT_BOOL;
 224     V_BOOL(args) = VARIANT_TRUE;
 225     dp.cArgs = dp.cNamedArgs = 1;
 226     V_VT(&v) = VT_BOOL;
 227     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYPUT, &dp, &v, &ei, NULL);
 228     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 229     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 230
 231     dp.cArgs = dp.cNamedArgs = 0;
 232     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 233     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 234     ok(V_VT(&v) == VT_BOOL, "V_VT(v) = %d\n", V_VT(&v));
 235     ok(V_BOOL(&v), "V_BOOL(v) = %x\n", V_BOOL(&v));
 236
 237     dp.cArgs = 1;
 238     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 239     ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
 240     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 241
 242     V_VT(args) = VT_BOOL;
 243     V_BOOL(args) = VARIANT_FALSE;
 244     dp.cArgs = 1;
 245     V_VT(&v) = VT_BOOL;
 246     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
 247     ok(hres == DISP_E_PARAMNOTOPTIONAL, "InvokeEx failed: %08x, expected DISP_E_PARAMNOTOPTIONAL\n", hres);
 248
 249     str = a2bstr("publicFunction");
 250     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_func_id);
 251     SysFreeString(str);
 252     ok(hres == S_OK, "GetDispID(publicFunction) failed: %08x\n", hres);
 253     ok(public_func_id != -1, "public_func_id = -1\n");
 254
 255     str = a2bstr("publicSub");
 256     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_sub_id);
 257     SysFreeString(str);
 258     ok(hres == S_OK, "GetDispID(publicSub) failed: %08x\n", hres);
 259     ok(public_sub_id != -1, "public_func_id = -1\n");
 260
 261     dp.cArgs = dp.cNamedArgs = 0;
 262     hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 263     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 264     ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
 265     ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
 266
 267     dp.cArgs = dp.cNamedArgs = 0;
 268     hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
 269     ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
 270     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 271
 272     dp.cArgs = dp.cNamedArgs = 0;
 273     hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
 274     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 275     ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
 276     ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
 277
 278     dp.cArgs = dp.cNamedArgs = 0;
 279     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 280     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 281     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 282
 283     dp.cArgs = dp.cNamedArgs = 0;
 284     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
 285     ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
 286     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 287
 288     dp.cArgs = dp.cNamedArgs = 0;
 289     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
 290     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 291     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 292
 293     V_VT(args) = VT_BOOL;
 294     V_BOOL(args) = VARIANT_TRUE;
 295     dp.cArgs = dp.cNamedArgs = 1;
 296     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
 297     ok(FAILED(hres), "InvokeEx succeeded: %08x\n", hres);
 298
 299     dp.cArgs = dp.cNamedArgs = 0;
 300     hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 301     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 302     ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
 303     ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
 304
 305     dp.cArgs = dp.cNamedArgs = 0;
 306     hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
 307     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 308     ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
 309     ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
 310
 311     dp.cArgs = dp.cNamedArgs = 0;
 312     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
 313     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 314     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 315
 316     dp.cArgs = dp.cNamedArgs = 0;
 317     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
 318     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 319     ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
 320
 321     str = a2bstr("privateSub");
 322     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
 323     SysFreeString(str);
 324     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateSub) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 325     ok(id == -1, "id = %d\n", id);
 326
 327     str = a2bstr("dynprop");
 328     hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive|fdexNameEnsure, &id);
 329     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 330     ok(id == -1, "id = %d\n", id);
 331     hres = IDispatchEx_GetDispID(dispex, str, fdexNameEnsure, &id);
 332     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 333     ok(id == -1, "id = %d\n", id);
 334     SysFreeString(str);
 335
 336     IDispatchEx_Release(dispex);
 337 }
 338
 339 #define test_grfdex(a,b) _test_grfdex(__LINE__,a,b)
 340 static void _test_grfdex(unsigned line, DWORD grfdex, DWORD expect)
 341 {
 342     ok_(__FILE__,line)(grfdex == expect, "grfdex = %x, expected %x\n", grfdex, expect);
 343 }
 344
 345 static const char *debugstr_guid(REFIID riid)
 346 {
 347     static char buf[50];
 348
 349     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 350             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 351             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 352             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 353
 354     return buf;
 355 }
 356
 357 static IDispatchEx enumDisp;
 358
 359 static HRESULT WINAPI EnumVARIANT_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv)
 360 {
 361     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IEnumVARIANT)) {
 362         *ppv = iface;
 363         return S_OK;
 364     }
 365
 366     if(IsEqualGUID(riid, &IID_IDispatch)) {
 367         *ppv = &enumDisp;
 368         return S_OK;
 369     }
 370
 371     ok(0, "unexpected call %s\n", debugstr_guid(riid));
 372     return E_NOINTERFACE;
 373 }
 374
 375 static ULONG WINAPI EnumVARIANT_AddRef(IEnumVARIANT *iface)
 376 {
 377     return 2;
 378 }
 379
 380 static ULONG WINAPI EnumVARIANT_Release(IEnumVARIANT *iface)
 381 {
 382     return 1;
 383 }
 384
 385 static unsigned next_cnt;
 386
 387 static HRESULT WINAPI EnumVARIANT_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 388 {
 389     if(strict_dispid_check)
 390         CHECK_EXPECT2(Next);
 391
 392     ok(celt == 1, "celt = %d\n", celt);
 393     ok(V_VT(rgVar) == VT_EMPTY, "V_VT(rgVar) = %d\n", V_VT(rgVar));
 394     ok(!pCeltFetched, "pCeltFetched = %p\n", pCeltFetched);
 395
 396     if(next_cnt++ < 3) {
 397         V_VT(rgVar) = VT_I2;
 398         V_I2(rgVar) = next_cnt;
 399         return S_OK;
 400     }
 401
 402     return S_FALSE;
 403 }
 404
 405 static HRESULT WINAPI EnumVARIANT_Skip(IEnumVARIANT *iface, ULONG celt)
 406 {
 407     ok(0, "unexpected call\n");
 408     return E_NOTIMPL;
 409 }
 410
 411 static HRESULT WINAPI EnumVARIANT_Reset(IEnumVARIANT *iface)
 412 {
 413     ok(0, "unexpected call\n");
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI EnumVARIANT_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 418 {
 419     ok(0, "unexpected call\n");
 420     return E_NOTIMPL;
 421 }
 422
 423 static const IEnumVARIANTVtbl EnumVARIANTVtbl = {
 424     EnumVARIANT_QueryInterface,
 425     EnumVARIANT_AddRef,
 426     EnumVARIANT_Release,
 427     EnumVARIANT_Next,
 428     EnumVARIANT_Skip,
 429     EnumVARIANT_Reset,
 430     EnumVARIANT_Clone
 431 };
 432
 433 static IEnumVARIANT enumObj = { &EnumVARIANTVtbl };
 434
 435 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 436 {
 437     *ppv = NULL;
 438
 439     if(IsEqualGUID(riid, &IID_IUnknown)
 440        || IsEqualGUID(riid, &IID_IDispatch)
 441        || IsEqualGUID(riid, &IID_IDispatchEx))
 442         *ppv = iface;
 443     else {
 444         trace("QI %s\n", debugstr_guid(riid));
 445         return E_NOINTERFACE;
 446     }
 447
 448     IUnknown_AddRef((IUnknown*)*ppv);
 449     return S_OK;
 450 }
 451
 452 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 453 {
 454     return 2;
 455 }
 456
 457 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 458 {
 459     return 1;
 460 }
 461
 462 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 463 {
 464     ok(0, "unexpected call\n");
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 469                                               LCID lcid, ITypeInfo **ppTInfo)
 470 {
 471     ok(0, "unexpected call\n");
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 476                                                 LPOLESTR *rgszNames, UINT cNames,
 477                                                 LCID lcid, DISPID *rgDispId)
 478 {
 479     ok(0, "unexpected call\n");
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 484                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 485                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 486 {
 487     ok(0, "unexpected call\n");
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 492 {
 493     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 498 {
 499     ok(0, "unexpected call\n");
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 504 {
 505     ok(0, "unexpected call\n");
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 510 {
 511     ok(0, "unexpected call\n");
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 516 {
 517     ok(0, "unexpected call\n");
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 522 {
 523     ok(0, "unexpected call\n");
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 528 {
 529     ok(0, "unexpected call\n");
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 534         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 535 {
 536     ok(0, "unexpected call %d\n", id);
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI testObj_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 541 {
 542     if(!strcmp_wa(bstrName, "propget")) {
 543         CHECK_EXPECT(testobj_propget_d);
 544         test_grfdex(grfdex, fdexNameCaseInsensitive);
 545         *pid = DISPID_TESTOBJ_PROPGET;
 546         return S_OK;
 547     }
 548     if(!strcmp_wa(bstrName, "propput")) {
 549         CHECK_EXPECT(testobj_propput_d);
 550         test_grfdex(grfdex, fdexNameCaseInsensitive);
 551         *pid = DISPID_TESTOBJ_PROPPUT;
 552         return S_OK;
 553     }
 554
 555     ok(0, "unexpected call %s\n", wine_dbgstr_w(bstrName));
 556     return DISP_E_UNKNOWNNAME;
 557 }
 558
 559 static HRESULT WINAPI testObj_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 560         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 561 {
 562     switch(id) {
 563     case DISPID_TESTOBJ_PROPGET:
 564         CHECK_EXPECT(testobj_propget_i);
 565
 566         ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
 567         ok(pdp != NULL, "pdp == NULL\n");
 568         ok(!pdp->rgvarg, "rgvarg == NULL\n");
 569         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 570         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 571         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 572         ok(pvarRes != NULL, "pvarRes == NULL\n");
 573         ok(pei != NULL, "pei == NULL\n");
 574
 575         V_VT(pvarRes) = VT_I2;
 576         V_I2(pvarRes) = 10;
 577         return S_OK;
 578     case DISPID_TESTOBJ_PROPPUT:
 579         CHECK_EXPECT(testobj_propput_i);
 580
 581         ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
 582         ok(pdp != NULL, "pdp == NULL\n");
 583         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 584         ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
 585         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 586         ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
 587         ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 588         ok(!pvarRes, "pvarRes != NULL\n");
 589         ok(pei != NULL, "pei == NULL\n");
 590
 591         ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 592         ok(V_I2(pdp->rgvarg) == 1, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
 593         return S_OK;
 594     }
 595
 596     ok(0, "unexpected call %d\n", id);
 597     return E_FAIL;
 598 }
 599
 600 static IDispatchExVtbl testObjVtbl = {
 601     DispatchEx_QueryInterface,
 602     DispatchEx_AddRef,
 603     DispatchEx_Release,
 604     DispatchEx_GetTypeInfoCount,
 605     DispatchEx_GetTypeInfo,
 606     DispatchEx_GetIDsOfNames,
 607     DispatchEx_Invoke,
 608     testObj_GetDispID,
 609     testObj_InvokeEx,
 610     DispatchEx_DeleteMemberByName,
 611     DispatchEx_DeleteMemberByDispID,
 612     DispatchEx_GetMemberProperties,
 613     DispatchEx_GetMemberName,
 614     DispatchEx_GetNextDispID,
 615     DispatchEx_GetNameSpaceParent
 616 };
 617
 618 static IDispatchEx testObj = { &testObjVtbl };
 619
 620 static HRESULT WINAPI enumDisp_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 621 {
 622     return IEnumVARIANT_QueryInterface(&enumObj, riid, ppv);
 623 }
 624
 625 static IDispatchExVtbl enumDispVtbl = {
 626     enumDisp_QueryInterface,
 627     DispatchEx_AddRef,
 628     DispatchEx_Release,
 629     DispatchEx_GetTypeInfoCount,
 630     DispatchEx_GetTypeInfo,
 631     DispatchEx_GetIDsOfNames,
 632     DispatchEx_Invoke,
 633     DispatchEx_GetDispID,
 634     DispatchEx_InvokeEx,
 635     DispatchEx_DeleteMemberByName,
 636     DispatchEx_DeleteMemberByDispID,
 637     DispatchEx_GetMemberProperties,
 638     DispatchEx_GetMemberName,
 639     DispatchEx_GetNextDispID,
 640     DispatchEx_GetNameSpaceParent
 641 };
 642
 643 static IDispatchEx enumDisp = { &enumDispVtbl };
 644
 645 static HRESULT WINAPI collectionObj_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 646 {
 647     if(!strcmp_wa(bstrName, "reset")) {
 648         *pid = DISPID_COLLOBJ_RESET;
 649         return S_OK;
 650     }
 651
 652     ok(0, "unexpected call %s\n", wine_dbgstr_w(bstrName));
 653     return DISP_E_UNKNOWNNAME;
 654 }
 655
 656 static HRESULT WINAPI collectionObj_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 657         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 658 {
 659     switch(id) {
 660     case DISPID_NEWENUM:
 661         if(strict_dispid_check)
 662             CHECK_EXPECT(collectionobj_newenum_i);
 663
 664         ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
 665         ok(pdp != NULL, "pdp == NULL\n");
 666         ok(!pdp->rgvarg, "rgvarg == NULL\n");
 667         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 668         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 669         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 670         ok(pvarRes != NULL, "pvarRes == NULL\n");
 671         ok(pei != NULL, "pei == NULL\n");
 672
 673         V_VT(pvarRes) = VT_UNKNOWN;
 674         V_UNKNOWN(pvarRes) = (IUnknown*)&enumObj;
 675         return S_OK;
 676     case DISPID_COLLOBJ_RESET:
 677         next_cnt = 0;
 678         return S_OK;
 679     }
 680
 681     ok(0, "unexpected call %d\n", id);
 682     return E_NOTIMPL;
 683 }
 684
 685 static IDispatchExVtbl collectionObjVtbl = {
 686     DispatchEx_QueryInterface,
 687     DispatchEx_AddRef,
 688     DispatchEx_Release,
 689     DispatchEx_GetTypeInfoCount,
 690     DispatchEx_GetTypeInfo,
 691     DispatchEx_GetIDsOfNames,
 692     DispatchEx_Invoke,
 693     collectionObj_GetDispID,
 694     collectionObj_InvokeEx,
 695     DispatchEx_DeleteMemberByName,
 696     DispatchEx_DeleteMemberByDispID,
 697     DispatchEx_GetMemberProperties,
 698     DispatchEx_GetMemberName,
 699     DispatchEx_GetNextDispID,
 700     DispatchEx_GetNameSpaceParent
 701 };
 702
 703 static IDispatchEx collectionObj = { &collectionObjVtbl };
 704
 705 static ULONG refobj_ref;
 706
 707 static ULONG WINAPI RefObj_AddRef(IDispatchEx *iface)
 708 {
 709     return ++refobj_ref;
 710 }
 711
 712 static ULONG WINAPI RefObj_Release(IDispatchEx *iface)
 713 {
 714     return --refobj_ref;
 715 }
 716
 717 static IDispatchExVtbl RefObjVtbl = {
 718     DispatchEx_QueryInterface,
 719     RefObj_AddRef,
 720     RefObj_Release,
 721     DispatchEx_GetTypeInfoCount,
 722     DispatchEx_GetTypeInfo,
 723     DispatchEx_GetIDsOfNames,
 724     DispatchEx_Invoke,
 725     DispatchEx_GetDispID,
 726     DispatchEx_InvokeEx,
 727     DispatchEx_DeleteMemberByName,
 728     DispatchEx_DeleteMemberByDispID,
 729     DispatchEx_GetMemberProperties,
 730     DispatchEx_GetMemberName,
 731     DispatchEx_GetNextDispID,
 732     DispatchEx_GetNameSpaceParent
 733 };
 734
 735 static IDispatchEx RefObj = { &RefObjVtbl };
 736
 737 static HRESULT WINAPI Global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 738 {
 739     if(!strcmp_wa(bstrName, "ok")) {
 740         test_grfdex(grfdex, fdexNameCaseInsensitive);
 741         *pid = DISPID_GLOBAL_OK;
 742         return S_OK;
 743     }
 744     if(!strcmp_wa(bstrName, "trace")) {
 745         test_grfdex(grfdex, fdexNameCaseInsensitive);
 746         *pid = DISPID_GLOBAL_TRACE;
 747         return S_OK;
 748     }
 749     if(!strcmp_wa(bstrName, "reportSuccess")) {
 750         CHECK_EXPECT(global_success_d);
 751         test_grfdex(grfdex, fdexNameCaseInsensitive);
 752         *pid = DISPID_GLOBAL_REPORTSUCCESS;
 753         return S_OK;
 754     }
 755     if(!strcmp_wa(bstrName, "getVT")) {
 756         test_grfdex(grfdex, fdexNameCaseInsensitive);
 757         *pid = DISPID_GLOBAL_GETVT;
 758         return S_OK;
 759     }
 760     if(!strcmp_wa(bstrName, "isEnglishLang")) {
 761         test_grfdex(grfdex, fdexNameCaseInsensitive);
 762         *pid = DISPID_GLOBAL_ISENGLANG;
 763         return S_OK;
 764     }
 765     if(!strcmp_wa(bstrName, "testObj")) {
 766         test_grfdex(grfdex, fdexNameCaseInsensitive);
 767         *pid = DISPID_GLOBAL_TESTOBJ;
 768         return S_OK;
 769     }
 770     if(!strcmp_wa(bstrName, "collectionObj")) {
 771         test_grfdex(grfdex, fdexNameCaseInsensitive);
 772         *pid = DISPID_GLOBAL_COLLOBJ;
 773         return S_OK;
 774     }
 775     if(!strcmp_wa(bstrName, "vbvar")) {
 776         CHECK_EXPECT(global_vbvar_d);
 777         test_grfdex(grfdex, fdexNameCaseInsensitive);
 778         *pid = DISPID_GLOBAL_VBVAR;
 779         return S_OK;
 780     }
 781     if(!strcmp_wa(bstrName, "isNullDisp")) {
 782         test_grfdex(grfdex, fdexNameCaseInsensitive);
 783         *pid = DISPID_GLOBAL_ISNULLDISP;
 784         return S_OK;
 785     }
 786     if(!strcmp_wa(bstrName, "testDisp")) {
 787         test_grfdex(grfdex, fdexNameCaseInsensitive);
 788         *pid = DISPID_GLOBAL_TESTDISP;
 789         return S_OK;
 790     }
 791     if(!strcmp_wa(bstrName, "RefObj")) {
 792         test_grfdex(grfdex, fdexNameCaseInsensitive);
 793         *pid = DISPID_GLOBAL_REFOBJ;
 794         return S_OK;
 795     }
 796     if(!strcmp_wa(bstrName, "propargput")) {
 797         CHECK_EXPECT(global_propargput_d);
 798         test_grfdex(grfdex, fdexNameCaseInsensitive);
 799         *pid = DISPID_GLOBAL_PROPARGPUT;
 800         return S_OK;
 801     }
 802     if(!strcmp_wa(bstrName, "propargput1")) {
 803         CHECK_EXPECT(global_propargput1_d);
 804         test_grfdex(grfdex, fdexNameCaseInsensitive);
 805         *pid = DISPID_GLOBAL_PROPARGPUT1;
 806         return S_OK;
 807     }
 808     if(!strcmp_wa(bstrName, "counter")) {
 809         test_grfdex(grfdex, fdexNameCaseInsensitive);
 810         *pid = DISPID_GLOBAL_COUNTER;
 811         return S_OK;
 812     }
 813
 814     if(strict_dispid_check && strcmp_wa(bstrName, "x"))
 815         ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 816     return DISP_E_UNKNOWNNAME;
 817 }
 818
 819 static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 820         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 821 {
 822     switch(id) {
 823     case DISPID_GLOBAL_OK: {
 824         VARIANT *b;
 825
 826         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 827         ok(pdp != NULL, "pdp == NULL\n");
 828         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 829         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 830         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 831         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 832         if(wFlags & INVOKE_PROPERTYGET)
 833             ok(pvarRes != NULL, "pvarRes == NULL\n");
 834         else
 835             ok(!pvarRes, "pvarRes != NULL\n");
 836         ok(pei != NULL, "pei == NULL\n");
 837
 838         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 839
 840         b = pdp->rgvarg+1;
 841         if(V_VT(b) == (VT_BYREF|VT_VARIANT))
 842             b = V_BYREF(b);
 843
 844         ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
 845
 846         ok(V_BOOL(b), "%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 847         return S_OK;
 848     }
 849
 850      case DISPID_GLOBAL_TRACE:
 851         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 852         ok(pdp != NULL, "pdp == NULL\n");
 853         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 854         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 855         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 856         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 857         ok(!pvarRes, "pvarRes != NULL\n");
 858         ok(pei != NULL, "pei == NULL\n");
 859
 860         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 861         if(V_VT(pdp->rgvarg) == VT_BSTR)
 862             trace("%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 863
 864         return S_OK;
 865
 866     case DISPID_GLOBAL_REPORTSUCCESS:
 867         CHECK_EXPECT(global_success_i);
 868
 869         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 870         ok(pdp != NULL, "pdp == NULL\n");
 871         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 872         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 873         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 874         ok(!pvarRes, "pvarRes != NULL\n");
 875         ok(pei != NULL, "pei == NULL\n");
 876
 877         return S_OK;
 878
 879     case DISPID_GLOBAL_GETVT:
 880         ok(pdp != NULL, "pdp == NULL\n");
 881         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 882         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 883         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 884         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 885         ok(pvarRes != NULL, "pvarRes == NULL\n");
 886         ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
 887         ok(pei != NULL, "pei == NULL\n");
 888
 889         V_VT(pvarRes) = VT_BSTR;
 890         V_BSTR(pvarRes) = a2bstr(vt2a(pdp->rgvarg));
 891         return S_OK;
 892
 893     case DISPID_GLOBAL_ISENGLANG:
 894         ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 895         ok(pdp != NULL, "pdp == NULL\n");
 896         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 897         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 898         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 899         ok(pvarRes != NULL, "pvarRes == NULL\n");
 900         ok(pei != NULL, "pei == NULL\n");
 901
 902         V_VT(pvarRes) = VT_BOOL;
 903         if(is_lang_english()) {
 904             V_BOOL(pvarRes) = VARIANT_TRUE;
 905         }else {
 906             skip("Skipping some tests in non-English UIs\n");
 907             V_BOOL(pvarRes) = VARIANT_FALSE;
 908         }
 909         return S_OK;
 910
 911     case DISPID_GLOBAL_VBVAR:
 912         CHECK_EXPECT(global_vbvar_i);
 913
 914         ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
 915         ok(pdp != NULL, "pdp == NULL\n");
 916         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 917         ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
 918         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 919         ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
 920         ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 921         ok(!pvarRes, "pvarRes != NULL\n");
 922         ok(pei != NULL, "pei == NULL\n");
 923
 924         ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 925         ok(V_I2(pdp->rgvarg) == 3, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
 926         return S_OK;
 927
 928     case DISPID_GLOBAL_TESTOBJ:
 929         ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
 930
 931         ok(pdp != NULL, "pdp == NULL\n");
 932         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 933         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 934         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 935         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 936         ok(pvarRes != NULL, "pvarRes == NULL\n");
 937         ok(pei != NULL, "pei == NULL\n");
 938
 939         V_VT(pvarRes) = VT_DISPATCH;
 940         V_DISPATCH(pvarRes) = (IDispatch*)&testObj;
 941         return S_OK;
 942
 943     case DISPID_GLOBAL_COLLOBJ:
 944         ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
 945
 946         ok(pdp != NULL, "pdp == NULL\n");
 947         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 948         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 949         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 950         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 951         ok(pvarRes != NULL, "pvarRes == NULL\n");
 952         ok(pei != NULL, "pei == NULL\n");
 953
 954         V_VT(pvarRes) = VT_DISPATCH;
 955         V_DISPATCH(pvarRes) = (IDispatch*)&collectionObj;
 956         return S_OK;
 957
 958     case DISPID_GLOBAL_REFOBJ:
 959         ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
 960
 961         ok(pdp != NULL, "pdp == NULL\n");
 962         ok(!pdp->rgvarg, "rgvarg == NULL\n");
 963         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 964         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 965         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 966         ok(pvarRes != NULL, "pvarRes == NULL\n");
 967         ok(pei != NULL, "pei == NULL\n");
 968
 969         IDispatchEx_AddRef(&RefObj);
 970         V_VT(pvarRes) = VT_DISPATCH;
 971         V_DISPATCH(pvarRes) = (IDispatch*)&RefObj;
 972         return S_OK;
 973
 974     case DISPID_GLOBAL_ISNULLDISP: {
 975         VARIANT *v;
 976
 977         ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 978         ok(pdp != NULL, "pdp == NULL\n");
 979         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 980         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 981         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 982         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 983         ok(pvarRes != NULL, "pvarRes == NULL\n");
 984         ok(pei != NULL, "pei == NULL\n");
 985
 986         v = pdp->rgvarg;
 987         if(V_VT(v) == (VT_VARIANT|VT_BYREF))
 988             v = V_VARIANTREF(v);
 989
 990         ok(V_VT(v) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 991         V_VT(pvarRes) = VT_BOOL;
 992         V_BOOL(pvarRes) = V_DISPATCH(v) ? VARIANT_FALSE : VARIANT_TRUE;
 993         return S_OK;
 994     }
 995
 996     case DISPID_GLOBAL_TESTDISP:
 997         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 998         ok(pdp != NULL, "pdp == NULL\n");
 999         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
1000         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
1001         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
1002         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
1003         ok(!pvarRes, "pvarRes != NULL\n");
1004         ok(pei != NULL, "pei == NULL\n");
1005
1006         ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
1007         test_disp(V_DISPATCH(pdp->rgvarg));
1008         return S_OK;
1009
1010     case DISPID_GLOBAL_PROPARGPUT:
1011         CHECK_EXPECT(global_propargput_i);
1012
1013         ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
1014         ok(pdp != NULL, "pdp == NULL\n");
1015         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
1016         ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
1017         ok(pdp->cArgs == 3, "cArgs = %d\n", pdp->cArgs);
1018         ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
1019         ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
1020         ok(!pvarRes, "pvarRes != NULL\n");
1021         ok(pei != NULL, "pei == NULL\n");
1022
1023         ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
1024         ok(V_I2(pdp->rgvarg) == 0, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
1025
1026         ok(V_VT(pdp->rgvarg+1) == VT_I2, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg+1));
1027         ok(V_I2(pdp->rgvarg+1) == 2, "V_I2(psp->rgvargs+1) = %d\n", V_I2(pdp->rgvarg+1));
1028
1029         ok(V_VT(pdp->rgvarg+2) == VT_I2, "V_VT(psp->rgvargs+2) = %d\n", V_VT(pdp->rgvarg+2));
1030         ok(V_I2(pdp->rgvarg+2) == 1, "V_I2(psp->rgvargs+2) = %d\n", V_I2(pdp->rgvarg+2));
1031         return S_OK;
1032
1033     case DISPID_GLOBAL_PROPARGPUT1:
1034         CHECK_EXPECT(global_propargput1_i);
1035
1036         ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
1037         ok(pdp != NULL, "pdp == NULL\n");
1038         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
1039         ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
1040         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
1041         ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
1042         ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
1043         ok(!pvarRes, "pvarRes != NULL\n");
1044         ok(pei != NULL, "pei == NULL\n");
1045
1046         ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
1047         ok(V_I2(pdp->rgvarg) == 0, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
1048
1049         ok(V_VT(pdp->rgvarg+1) == VT_I2, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg+1));
1050         ok(V_I2(pdp->rgvarg+1) == 1, "V_I2(psp->rgvargs+1) = %d\n", V_I2(pdp->rgvarg+1));
1051
1052         return S_OK;
1053
1054     case DISPID_GLOBAL_COUNTER:
1055         ok(pdp != NULL, "pdp == NULL\n");
1056         todo_wine ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
1057         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
1058         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
1059         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
1060         ok(pvarRes != NULL, "pvarRes == NULL\n");
1061         ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
1062         ok(pei != NULL, "pei == NULL\n");
1063
1064         V_VT(pvarRes) = VT_I2;
1065         V_I2(pvarRes) = test_counter++;
1066         return S_OK;
1067     }
1068
1069     ok(0, "unexpected call %d\n", id);
1070     return DISP_E_MEMBERNOTFOUND;
1071 }
1072
1073 static IDispatchExVtbl GlobalVtbl = {
1074     DispatchEx_QueryInterface,
1075     DispatchEx_AddRef,
1076     DispatchEx_Release,
1077     DispatchEx_GetTypeInfoCount,
1078     DispatchEx_GetTypeInfo,
1079     DispatchEx_GetIDsOfNames,
1080     DispatchEx_Invoke,
1081     Global_GetDispID,
1082     Global_InvokeEx,
1083     DispatchEx_DeleteMemberByName,
1084     DispatchEx_DeleteMemberByDispID,
1085     DispatchEx_GetMemberProperties,
1086     DispatchEx_GetMemberName,
1087     DispatchEx_GetNextDispID,
1088     DispatchEx_GetNameSpaceParent
1089 };
1090
1091 static IDispatchEx Global = { &GlobalVtbl };
1092
1093 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
1094 {
1095     *ppv = NULL;
1096
1097     if(IsEqualGUID(&IID_IUnknown, riid))
1098         *ppv = iface;
1099     else if(IsEqualGUID(&IID_IActiveScriptSite, riid))
1100         *ppv = iface;
1101     else
1102         return E_NOINTERFACE;
1103
1104     IUnknown_AddRef((IUnknown*)*ppv);
1105     return S_OK;
1106 }
1107
1108 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
1109 {
1110     return 2;
1111 }
1112
1113 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
1114 {
1115     return 1;
1116 }
1117
1118 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
1119 {
1120     *plcid = GetUserDefaultLCID();
1121     return S_OK;
1122 }
1123
1124 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
1125         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
1126 {
1127     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
1128     ok(!ppti, "ppti != NULL\n");
1129
1130     if(strcmp_wa(pstrName, "test"))
1131         ok(0, "unexpected pstrName %s\n", wine_dbgstr_w(pstrName));
1132
1133     *ppiunkItem = (IUnknown*)&Global;
1134     return S_OK;
1135 }
1136
1137 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
1138 {
1139     return E_NOTIMPL;
1140 }
1141
1142 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
1143         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
1144 {
1145     return E_NOTIMPL;
1146 }
1147
1148 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
1149 {
1150     return E_NOTIMPL;
1151 }
1152
1153 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
1154 {
1155     return E_NOTIMPL;
1156 }
1157
1158 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
1159 {
1160     return E_NOTIMPL;
1161 }
1162
1163 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
1164 {
1165     return E_NOTIMPL;
1166 }
1167
1168 #undef ACTSCPSITE_THIS
1169
1170 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
1171     ActiveScriptSite_QueryInterface,
1172     ActiveScriptSite_AddRef,
1173     ActiveScriptSite_Release,
1174     ActiveScriptSite_GetLCID,
1175     ActiveScriptSite_GetItemInfo,
1176     ActiveScriptSite_GetDocVersionString,
1177     ActiveScriptSite_OnScriptTerminate,
1178     ActiveScriptSite_OnStateChange,
1179     ActiveScriptSite_OnScriptError,
1180     ActiveScriptSite_OnEnterScript,
1181     ActiveScriptSite_OnLeaveScript
1182 };
1183
1184 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
1185
1186 static IActiveScript *create_script(void)
1187 {
1188     IActiveScript *script;
1189     HRESULT hres;
1190
1191     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1192             &IID_IActiveScript, (void**)&script);
1193     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1194
1195     return script;
1196 }
1197
1198 static HRESULT parse_script(DWORD flags, BSTR script_str)
1199 {
1200     IActiveScriptParse *parser;
1201     IActiveScript *engine;
1202     IDispatch *script_disp;
1203     LONG ref;
1204     HRESULT hres;
1205
1206     engine = create_script();
1207     if(!engine)
1208         return S_OK;
1209
1210     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
1211     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
1212     if (FAILED(hres))
1213     {
1214         IActiveScript_Release(engine);
1215         return hres;
1216     }
1217
1218     hres = IActiveScriptParse64_InitNew(parser);
1219     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
1220
1221     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
1222     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
1223
1224     hres = IActiveScript_AddNamedItem(engine, testW,
1225             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|flags);
1226     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
1227
1228     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
1229     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
1230
1231     hres = IActiveScript_GetScriptDispatch(engine, NULL, &script_disp);
1232     ok(hres == S_OK, "GetScriptDispatch failed: %08x\n", hres);
1233     ok(script_disp != NULL, "script_disp == NULL\n");
1234     ok(script_disp != (IDispatch*)&Global, "script_disp == Global\n");
1235
1236     test_counter = 0;
1237
1238     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
1239
1240     IActiveScript_Close(engine);
1241
1242     IDispatch_Release(script_disp);
1243     IActiveScript_Release(engine);
1244
1245     ref = IUnknown_Release(parser);
1246     ok(!ref, "ref=%d\n", ref);
1247     return hres;
1248 }
1249
1250 static void parse_script_af(DWORD flags, const char *src)
1251 {
1252     BSTR tmp;
1253     HRESULT hres;
1254
1255     tmp = a2bstr(src);
1256     hres = parse_script(flags, tmp);
1257     SysFreeString(tmp);
1258     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
1259 }
1260
1261 static void parse_script_a(const char *src)
1262 {
1263     parse_script_af(SCRIPTITEM_GLOBALMEMBERS, src);
1264 }
1265
1266 static void test_gc(void)
1267 {
1268     IActiveScriptParse *parser;
1269     IActiveScript *engine;
1270     BSTR src;
1271     HRESULT hres;
1272
1273     strict_dispid_check = FALSE;
1274
1275     engine = create_script();
1276     if(!engine)
1277         return;
1278
1279     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
1280     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
1281
1282     hres = IActiveScriptParse64_InitNew(parser);
1283     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
1284
1285     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
1286     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
1287
1288     hres = IActiveScript_AddNamedItem(engine, testW,
1289             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
1290     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
1291
1292     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
1293     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
1294
1295     src = a2bstr(
1296             "class C\n"
1297             "    Public ref\n"
1298             "    Public Sub Class_Terminate\n"
1299             "        Call reportSuccess()\n"
1300             "    End Sub\n"
1301             "End Class\n"
1302             "Dim x\n"
1303             "set x = new C\n"
1304             "set x.ref = x\n"
1305             "set x = nothing\n");
1306
1307     hres = IActiveScriptParse64_ParseScriptText(parser, src, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
1308     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
1309     SysFreeString(src);
1310
1311     SET_EXPECT(global_success_d);
1312     SET_EXPECT(global_success_i);
1313     IActiveScript_Close(engine);
1314     CHECK_CALLED(global_success_d);
1315     CHECK_CALLED(global_success_i);
1316
1317     IActiveScript_Release(engine);
1318     IUnknown_Release(parser);
1319 }
1320
1321 static HRESULT test_global_vars_ref(BOOL use_close)
1322 {
1323     IActiveScriptParse *parser;
1324     IActiveScript *engine;
1325     BSTR script_str;
1326     LONG ref;
1327     HRESULT hres;
1328
1329     engine = create_script();
1330     if(!engine)
1331         return S_OK;
1332
1333     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
1334     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
1335     if (FAILED(hres))
1336     {
1337         IActiveScript_Release(engine);
1338         return hres;
1339     }
1340
1341     hres = IActiveScriptParse64_InitNew(parser);
1342     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
1343
1344     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
1345     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
1346
1347     hres = IActiveScript_AddNamedItem(engine, testW, SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
1348     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
1349
1350     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
1351     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
1352
1353     refobj_ref = 0;
1354
1355     script_str = a2bstr("Dim x\nset x = RefObj\n");
1356     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
1357     SysFreeString(script_str);
1358
1359     ok(refobj_ref, "refobj_ref = 0\n");
1360
1361     if(use_close) {
1362         hres = IActiveScript_Close(engine);
1363         ok(hres == S_OK, "Close failed: %08x\n", hres);
1364     }else {
1365         hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_UNINITIALIZED);
1366         ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
1367     }
1368
1369     ok(!refobj_ref, "refobj_ref = %d\n", refobj_ref);
1370
1371     IActiveScript_Release(engine);
1372
1373     ref = IUnknown_Release(parser);
1374     ok(!ref, "ref=%d\n", ref);
1375     return hres;
1376 }
1377
1378 static BSTR get_script_from_file(const char *filename)
1379 {
1380     DWORD size, len;
1381     HANDLE file, map;
1382     const char *file_map;
1383     BSTR ret;
1384
1385     file = CreateFileA(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
1386     if(file == INVALID_HANDLE_VALUE) {
1387         trace("Could not open file: %u\n", GetLastError());
1388         return NULL;
1389     }
1390
1391     size = GetFileSize(file, NULL);
1392
1393     map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
1394     CloseHandle(file);
1395     if(map == INVALID_HANDLE_VALUE) {
1396         trace("Could not create file mapping: %u\n", GetLastError());
1397         return NULL;
1398     }
1399
1400     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
1401     CloseHandle(map);
1402     if(!file_map) {
1403         trace("MapViewOfFile failed: %u\n", GetLastError());
1404         return NULL;
1405     }
1406
1407     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
1408     ret = SysAllocStringLen(NULL, len);
1409     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
1410
1411     UnmapViewOfFile(file_map);
1412
1413     return ret;
1414 }
1415
1416 static void run_from_file(const char *filename)
1417 {
1418     BSTR script_str;
1419     HRESULT hres;
1420
1421     script_str = get_script_from_file(filename);
1422     if(!script_str)
1423         return;
1424
1425     strict_dispid_check = FALSE;
1426     hres = parse_script(SCRIPTITEM_GLOBALMEMBERS, script_str);
1427     SysFreeString(script_str);
1428     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
1429 }
1430
1431 static void run_from_res(const char *name)
1432 {
1433     const char *data;
1434     DWORD size, len;
1435     BSTR str;
1436     HRSRC src;
1437     HRESULT hres;
1438
1439     strict_dispid_check = FALSE;
1440     test_name = name;
1441
1442     src = FindResourceA(NULL, name, (LPCSTR)40);
1443     ok(src != NULL, "Could not find resource %s\n", name);
1444
1445     size = SizeofResource(NULL, src);
1446     data = LoadResource(NULL, src);
1447
1448     len = MultiByteToWideChar(CP_ACP, 0, data, size, NULL, 0);
1449     str = SysAllocStringLen(NULL, len);
1450     MultiByteToWideChar(CP_ACP, 0, data, size, str, len);
1451
1452     SET_EXPECT(global_success_d);
1453     SET_EXPECT(global_success_i);
1454     hres = parse_script(SCRIPTITEM_GLOBALMEMBERS, str);
1455     CHECK_CALLED(global_success_d);
1456     CHECK_CALLED(global_success_i);
1457
1458     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
1459     SysFreeString(str);
1460 }
1461
1462 static void run_tests(void)
1463 {
1464     strict_dispid_check = TRUE;
1465
1466     parse_script_a("");
1467     parse_script_a("' empty ;");
1468
1469     SET_EXPECT(global_success_d);
1470     SET_EXPECT(global_success_i);
1471     parse_script_a("reportSuccess");
1472     CHECK_CALLED(global_success_d);
1473     CHECK_CALLED(global_success_i);
1474
1475     SET_EXPECT(global_success_d);
1476     SET_EXPECT(global_success_i);
1477     parse_script_a("reportSuccess()");
1478     CHECK_CALLED(global_success_d);
1479     CHECK_CALLED(global_success_i);
1480
1481     SET_EXPECT(global_success_d);
1482     SET_EXPECT(global_success_i);
1483     parse_script_a("Call reportSuccess");
1484     CHECK_CALLED(global_success_d);
1485     CHECK_CALLED(global_success_i);
1486
1487     SET_EXPECT(global_success_d);
1488     SET_EXPECT(global_success_i);
1489     parse_script_a("test.reportSuccess()");
1490     CHECK_CALLED(global_success_d);
1491     CHECK_CALLED(global_success_i);
1492
1493     SET_EXPECT(global_vbvar_d);
1494     SET_EXPECT(global_vbvar_i);
1495     parse_script_a("Option Explicit\nvbvar = 3");
1496     CHECK_CALLED(global_vbvar_d);
1497     CHECK_CALLED(global_vbvar_i);
1498
1499     SET_EXPECT(global_vbvar_d);
1500     SET_EXPECT(global_vbvar_i);
1501     parse_script_a("Option Explicit\nvbvar() = 3");
1502     CHECK_CALLED(global_vbvar_d);
1503     CHECK_CALLED(global_vbvar_i);
1504
1505     SET_EXPECT(testobj_propget_d);
1506     SET_EXPECT(testobj_propget_i);
1507     parse_script_a("dim x\nx = testObj.propget");
1508     CHECK_CALLED(testobj_propget_d);
1509     CHECK_CALLED(testobj_propget_i);
1510
1511     SET_EXPECT(testobj_propput_d);
1512     SET_EXPECT(testobj_propput_i);
1513     parse_script_a("testObj.propput = 1");
1514     CHECK_CALLED(testobj_propput_d);
1515     CHECK_CALLED(testobj_propput_i);
1516
1517     SET_EXPECT(global_propargput_d);
1518     SET_EXPECT(global_propargput_i);
1519     parse_script_a("propargput(counter(), counter()) = counter()");
1520     CHECK_CALLED(global_propargput_d);
1521     CHECK_CALLED(global_propargput_i);
1522
1523     SET_EXPECT(global_propargput_d);
1524     SET_EXPECT(global_propargput_i);
1525     parse_script_a("test.propargput(counter(), counter()) = counter()");
1526     CHECK_CALLED(global_propargput_d);
1527     CHECK_CALLED(global_propargput_i);
1528
1529     SET_EXPECT(global_propargput1_d);
1530     SET_EXPECT(global_propargput1_i);
1531     parse_script_a("propargput1 (counter()) = counter()");
1532     CHECK_CALLED(global_propargput1_d);
1533     CHECK_CALLED(global_propargput1_i);
1534
1535     SET_EXPECT(global_propargput1_d);
1536     SET_EXPECT(global_propargput1_i);
1537     parse_script_a("test.propargput1(counter()) = counter()");
1538     CHECK_CALLED(global_propargput1_d);
1539     CHECK_CALLED(global_propargput1_i);
1540
1541     next_cnt = 0;
1542     SET_EXPECT(collectionobj_newenum_i);
1543     SET_EXPECT(Next);
1544     parse_script_a("for each x in collectionObj\nnext");
1545     CHECK_CALLED(collectionobj_newenum_i);
1546     CHECK_CALLED(Next);
1547     ok(next_cnt == 4, "next_cnt = %d\n", next_cnt);
1548
1549     parse_script_a("x = 1\n Call ok(x = 1, \"x = \" & x)");
1550
1551     parse_script_a("x = _    \n3");
1552
1553     test_global_vars_ref(TRUE);
1554     test_global_vars_ref(FALSE);
1555
1556     strict_dispid_check = FALSE;
1557
1558     parse_script_a("Sub testsub\n"
1559                    "x = 1\n"
1560                    "Call ok(x = 1, \"x = \" & x)\n"
1561                    "End Sub\n"
1562                    "Call testsub()");
1563
1564     run_from_res("lang.vbs");
1565     run_from_res("api.vbs");
1566
1567     test_gc();
1568 }
1569
1570 static BOOL check_vbscript(void)
1571 {
1572     IActiveScript *vbscript;
1573     HRESULT hres;
1574
1575     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1576             &IID_IActiveScript, (void**)&vbscript);
1577     if(SUCCEEDED(hres))
1578         IActiveScript_Release(vbscript);
1579
1580     return hres == S_OK;
1581 }
1582
1583 START_TEST(run)
1584 {
1585     int argc;
1586     char **argv;
1587
1588     argc = winetest_get_mainargs(&argv);
1589
1590     CoInitialize(NULL);
1591
1592     if(!check_vbscript()) {
1593         win_skip("Broken engine, probably too old\n");
1594     }else if(argc > 2) {
1595         run_from_file(argv[2]);
1596     }else {
1597         run_tests();
1598     }
1599
1600     CoUninitialize();
1601 }