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