git.oblomov.eu Git - wine/blob - programs/wscript/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 <initguid.h>
  25 #include <windows.h>
  26 #include <psapi.h>
  27 #include <oaidl.h>
  28
  29 #include "wine/test.h"
  30
  31 #define DEFINE_EXPECT(func) \
  32     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  33
  34 #define SET_EXPECT(func) \
  35     expect_ ## func = TRUE
  36
  37 #define CLEAR_CALLED(func) \
  38     expect_ ## func = called_ ## func = FALSE
  39
  40 #define CHECK_EXPECT2(func) \
  41     do { \
  42         ok(expect_ ##func, "unexpected call " #func "\n"); \
  43         called_ ## func = TRUE; \
  44     }while(0)
  45
  46 #define CHECK_EXPECT(func) \
  47     do { \
  48         CHECK_EXPECT2(func); \
  49         expect_ ## func = FALSE; \
  50     }while(0)
  51
  52 #define CHECK_CALLED(func) \
  53     do { \
  54         ok(called_ ## func, "expected " #func "\n"); \
  55         expect_ ## func = called_ ## func = FALSE; \
  56     }while(0)
  57
  58 DEFINE_EXPECT(reportSuccess);
  59
  60 #define DISPID_TESTOBJ_OK                        10000
  61 #define DISPID_TESTOBJ_TRACE                     10001
  62 #define DISPID_TESTOBJ_REPORTSUCCESS             10002
  63 #define DISPID_TESTOBJ_WSCRIPTFULLNAME           10003
  64 #define DISPID_TESTOBJ_WSCRIPTPATH               10004
  65 #define DISPID_TESTOBJ_WSCRIPTSCRIPTNAME         10005
  66 #define DISPID_TESTOBJ_WSCRIPTSCRIPTFULLNAME     10006
  67
  68 #define TESTOBJ_CLSID "{178fc166-f585-4e24-9c13-4bb7faf80646}"
  69
  70 static const GUID CLSID_TestObj =
  71     {0x178fc166,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
  72
  73 static const char *script_name;
  74 static HANDLE wscript_process;
  75
  76 static int strcmp_wa(LPCWSTR strw, const char *stra)
  77 {
  78     WCHAR buf[512];
  79     MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(WCHAR));
  80     return lstrcmpW(strw, buf);
  81 }
  82
  83 static const WCHAR* mystrrchr(const WCHAR *str, WCHAR ch)
  84 {
  85     const WCHAR *pos = NULL, *current = str;
  86     while(*current != 0) {
  87         if(*current == ch)
  88             pos = current;
  89         ++current;
  90     }
  91     return pos;
  92 }
  93
  94 static BSTR a2bstr(const char *str)
  95 {
  96     BSTR ret;
  97     int len;
  98
  99     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 100     ret = SysAllocStringLen(NULL, len-1);
 101     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 102
 103     return ret;
 104 }
 105
 106 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 107 {
 108     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDispatch)) {
 109         *ppv = iface;
 110         return S_OK;
 111     }
 112
 113     *ppv = NULL;
 114     return E_NOINTERFACE;
 115 }
 116
 117 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 118 {
 119     return 2;
 120 }
 121
 122 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 123 {
 124     return 1;
 125 }
 126
 127 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 128 {
 129     ok(0, "unexpected call\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 134         LCID lcid, ITypeInfo **ppTInfo)
 135 {
 136     ok(0, "unexpected call\n");
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid,
 141         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 142 {
 143     unsigned i;
 144
 145     for(i=0; i<cNames; i++) {
 146         if(!strcmp_wa(rgszNames[i], "ok")) {
 147             rgDispId[i] = DISPID_TESTOBJ_OK;
 148         }else if(!strcmp_wa(rgszNames[i], "trace")) {
 149             rgDispId[i] = DISPID_TESTOBJ_TRACE;
 150         }else if(!strcmp_wa(rgszNames[i], "reportSuccess")) {
 151             rgDispId[i] = DISPID_TESTOBJ_REPORTSUCCESS;
 152         }else if(!strcmp_wa(rgszNames[i], "wscriptFullName")) {
 153             rgDispId[i] = DISPID_TESTOBJ_WSCRIPTFULLNAME;
 154         }else if(!strcmp_wa(rgszNames[i], "wscriptPath")) {
 155             rgDispId[i] = DISPID_TESTOBJ_WSCRIPTPATH;
 156         }else if(!strcmp_wa(rgszNames[i], "wscriptScriptName")) {
 157             rgDispId[i] = DISPID_TESTOBJ_WSCRIPTSCRIPTNAME;
 158         }else if(!strcmp_wa(rgszNames[i], "wscriptScriptFullName")) {
 159             rgDispId[i] = DISPID_TESTOBJ_WSCRIPTSCRIPTFULLNAME;
 160         }else {
 161             ok(0, "unexpected name %s\n", wine_dbgstr_w(rgszNames[i]));
 162             return DISP_E_UNKNOWNNAME;
 163         }
 164     }
 165
 166     return S_OK;
 167 }
 168
 169 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 170                                       WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 171 {
 172     switch(dispIdMember) {
 173     case DISPID_TESTOBJ_OK: {
 174         VARIANT *expr, *msg;
 175
 176         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 177         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 178         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 179
 180         expr = pdp->rgvarg+1;
 181         if(V_VT(expr) == (VT_VARIANT|VT_BYREF))
 182             expr = V_VARIANTREF(expr);
 183
 184         msg = pdp->rgvarg;
 185         if(V_VT(msg) == (VT_VARIANT|VT_BYREF))
 186             msg = V_VARIANTREF(msg);
 187
 188         ok(V_VT(msg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(msg));
 189         ok(V_VT(expr) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(expr));
 190         ok(V_BOOL(expr), "%s: %s\n", script_name, wine_dbgstr_w(V_BSTR(msg)));
 191         if(pVarResult)
 192             V_VT(pVarResult) = VT_EMPTY;
 193         break;
 194     }
 195     case DISPID_TESTOBJ_TRACE:
 196         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 197         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 198         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 199         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 200         trace("%s: %s\n", script_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 201         if(pVarResult)
 202             V_VT(pVarResult) = VT_EMPTY;
 203         break;
 204     case DISPID_TESTOBJ_REPORTSUCCESS:
 205         CHECK_EXPECT(reportSuccess);
 206
 207         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 208         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 209         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 210         if(pVarResult)
 211             V_VT(pVarResult) = VT_EMPTY;
 212         break;
 213     case DISPID_TESTOBJ_WSCRIPTFULLNAME:
 214     {
 215         WCHAR fullName[MAX_PATH];
 216         DWORD res;
 217
 218         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 219         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 220         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 221         V_VT(pVarResult) = VT_BSTR;
 222         res = GetModuleFileNameExW(wscript_process, NULL, fullName, sizeof(fullName)/sizeof(WCHAR));
 223         if(res == 0)
 224             return E_FAIL;
 225         if(!(V_BSTR(pVarResult) = SysAllocString(fullName)))
 226             return E_OUTOFMEMORY;
 227         break;
 228     }
 229     case DISPID_TESTOBJ_WSCRIPTPATH:
 230     {
 231         WCHAR fullPath[MAX_PATH];
 232         DWORD res;
 233         const WCHAR *pos;
 234
 235         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 236         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 237         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 238         V_VT(pVarResult) = VT_BSTR;
 239         res = GetModuleFileNameExW(wscript_process, NULL, fullPath, sizeof(fullPath)/sizeof(WCHAR));
 240         if(res == 0)
 241             return E_FAIL;
 242         pos = mystrrchr(fullPath, '\\');
 243         if(!(V_BSTR(pVarResult) = SysAllocStringLen(fullPath, pos-fullPath)))
 244             return E_OUTOFMEMORY;
 245         break;
 246     }
 247     case DISPID_TESTOBJ_WSCRIPTSCRIPTNAME:
 248     {
 249         char fullPath[MAX_PATH];
 250         char *pos;
 251         long res;
 252
 253         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 254         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 255         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 256         V_VT(pVarResult) = VT_BSTR;
 257         res = GetFullPathNameA(script_name, sizeof(fullPath)/sizeof(WCHAR), fullPath, &pos);
 258         if(!res || res > sizeof(fullPath)/sizeof(WCHAR))
 259             return E_FAIL;
 260         if(!(V_BSTR(pVarResult) = SysAllocString(a2bstr(pos))))
 261             return E_OUTOFMEMORY;
 262         break;
 263     }
 264     case DISPID_TESTOBJ_WSCRIPTSCRIPTFULLNAME:
 265     {
 266         char fullPath[MAX_PATH];
 267         long res;
 268
 269         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 270         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 271         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 272         V_VT(pVarResult) = VT_BSTR;
 273         res = GetFullPathNameA(script_name, sizeof(fullPath)/sizeof(WCHAR), fullPath, NULL);
 274         if(!res || res > sizeof(fullPath)/sizeof(WCHAR))
 275             return E_FAIL;
 276         if(!(V_BSTR(pVarResult) = SysAllocString(a2bstr(fullPath))))
 277             return E_OUTOFMEMORY;
 278         break;
 279     }
 280     default:
 281         ok(0, "unexpected dispIdMember %d\n", dispIdMember);
 282         return E_NOTIMPL;
 283     }
 284
 285     return S_OK;
 286 }
 287
 288 static IDispatchVtbl testobj_vtbl = {
 289     Dispatch_QueryInterface,
 290     Dispatch_AddRef,
 291     Dispatch_Release,
 292     Dispatch_GetTypeInfoCount,
 293     Dispatch_GetTypeInfo,
 294     Dispatch_GetIDsOfNames,
 295     Dispatch_Invoke
 296 };
 297
 298 static IDispatch testobj = { &testobj_vtbl };
 299
 300 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 301 {
 302     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 303         *ppv = iface;
 304         return S_OK;
 305     }
 306
 307     *ppv = NULL;
 308     return E_NOINTERFACE;
 309 }
 310
 311 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 312 {
 313     return 2;
 314 }
 315
 316 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 317 {
 318     return 1;
 319 }
 320
 321 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 322 {
 323     ok(!outer, "outer = %p\n", outer);
 324     return IDispatch_QueryInterface(&testobj, riid, ppv);
 325 }
 326
 327 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 328 {
 329     return S_OK;
 330 }
 331
 332 static const IClassFactoryVtbl ClassFactoryVtbl = {
 333     ClassFactory_QueryInterface,
 334     ClassFactory_AddRef,
 335     ClassFactory_Release,
 336     ClassFactory_CreateInstance,
 337     ClassFactory_LockServer
 338 };
 339
 340 static IClassFactory testobj_cf = { &ClassFactoryVtbl };
 341
 342 static void run_test(const char *file_name)
 343 {
 344     char command[MAX_PATH];
 345     STARTUPINFOA si = {sizeof(si)};
 346     PROCESS_INFORMATION pi;
 347     BOOL bres;
 348
 349     script_name = file_name;
 350     sprintf(command, "wscript.exe %s arg1 2 ar3", file_name);
 351
 352     SET_EXPECT(reportSuccess);
 353
 354     bres = CreateProcessA(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
 355     if(!bres) {
 356         win_skip("script.exe is not available\n");
 357         CLEAR_CALLED(reportSuccess);
 358         return;
 359     }
 360
 361     wscript_process = pi.hProcess;
 362     WaitForSingleObject(pi.hProcess, INFINITE);
 363     CloseHandle(pi.hThread);
 364     CloseHandle(pi.hProcess);
 365
 366     CHECK_CALLED(reportSuccess);
 367 }
 368
 369 static BOOL WINAPI test_enum_proc(HMODULE module, LPCTSTR type, LPSTR name, LONG_PTR param)
 370 {
 371     const char *script_data, *ext;
 372     DWORD script_size, size;
 373     char file_name[MAX_PATH];
 374     HANDLE file;
 375     HRSRC src;
 376     BOOL res;
 377
 378     trace("running %s test...\n", name);
 379
 380     src = FindResourceA(NULL, name, type);
 381     ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError());
 382     if(!src)
 383         return TRUE;
 384
 385     script_data = LoadResource(NULL, src);
 386     script_size = SizeofResource(NULL, src);
 387     while(script_size && !script_data[script_size-1])
 388         script_size--;
 389
 390     ext = strrchr(name, '.');
 391     ok(ext != NULL, "no script extension\n");
 392     if(!ext)
 393       return TRUE;
 394
 395     sprintf(file_name, "test%s", ext);
 396
 397     file = CreateFileA(file_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 398             FILE_ATTRIBUTE_NORMAL, NULL);
 399     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
 400     if(file == INVALID_HANDLE_VALUE)
 401         return TRUE;
 402
 403     res = WriteFile(file, script_data, script_size, &size, NULL);
 404     CloseHandle(file);
 405     ok(res, "Could not write to file: %u\n", GetLastError());
 406     if(!res)
 407         return TRUE;
 408
 409     run_test(file_name);
 410
 411     DeleteFileA(file_name);
 412     return TRUE;
 413 }
 414
 415 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 416 {
 417     HKEY hkey;
 418     DWORD res;
 419
 420     if(!init) {
 421         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 422         return TRUE;
 423     }
 424
 425     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 426     if(res != ERROR_SUCCESS)
 427         return FALSE;
 428
 429     if(def_value)
 430         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 431
 432     RegCloseKey(hkey);
 433     return res == ERROR_SUCCESS;
 434 }
 435
 436 static BOOL init_registry(BOOL init)
 437 {
 438     return init_key("Wine.Test\\CLSID", TESTOBJ_CLSID, init);
 439 }
 440
 441 static BOOL register_activex(void)
 442 {
 443     DWORD regid;
 444     HRESULT hres;
 445
 446     if(!init_registry(TRUE)) {
 447         init_registry(FALSE);
 448         return FALSE;
 449     }
 450
 451     hres = CoRegisterClassObject(&CLSID_TestObj, (IUnknown *)&testobj_cf,
 452             CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &regid);
 453     ok(hres == S_OK, "Could not register script engine: %08x\n", hres);
 454     return TRUE;
 455 }
 456
 457 START_TEST(run)
 458 {
 459     char **argv;
 460     int argc;
 461
 462     CoInitializeEx(NULL, COINIT_MULTITHREADED);
 463     register_activex();
 464
 465     argc = winetest_get_mainargs(&argv);
 466     if(argc > 2)
 467         run_test(argv[2]);
 468     else
 469         EnumResourceNamesA(NULL, "TESTSCRIPT", test_enum_proc, 0);
 470
 471     init_registry(FALSE);
 472     CoUninitialize();
 473 }