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 SET_CALLED(func) \
  38     called_ ## func = TRUE
  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         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 175         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 176         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 177         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 178         ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
 179         ok(V_BOOL(pdp->rgvarg+1), "%s: %s\n", script_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 180         if(pVarResult)
 181             V_VT(pVarResult) = VT_EMPTY;
 182         break;
 183     case DISPID_TESTOBJ_TRACE:
 184         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 185         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 186         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 187         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 188         trace("%s: %s\n", script_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 189         if(pVarResult)
 190             V_VT(pVarResult) = VT_EMPTY;
 191         break;
 192     case DISPID_TESTOBJ_REPORTSUCCESS:
 193         CHECK_EXPECT(reportSuccess);
 194
 195         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 196         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 197         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 198         if(pVarResult)
 199             V_VT(pVarResult) = VT_EMPTY;
 200         break;
 201     case DISPID_TESTOBJ_WSCRIPTFULLNAME:
 202     {
 203         WCHAR fullName[MAX_PATH];
 204         DWORD res;
 205
 206         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 207         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 208         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 209         V_VT(pVarResult) = VT_BSTR;
 210         res = GetModuleFileNameExW(wscript_process, NULL, fullName, sizeof(fullName)/sizeof(WCHAR));
 211         if(res == 0)
 212             return E_FAIL;
 213         if(!(V_BSTR(pVarResult) = SysAllocString(fullName)))
 214             return E_OUTOFMEMORY;
 215         break;
 216     }
 217     case DISPID_TESTOBJ_WSCRIPTPATH:
 218     {
 219         WCHAR fullPath[MAX_PATH];
 220         DWORD res;
 221         const WCHAR *pos;
 222
 223         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 224         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 225         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 226         V_VT(pVarResult) = VT_BSTR;
 227         res = GetModuleFileNameExW(wscript_process, NULL, fullPath, sizeof(fullPath)/sizeof(WCHAR));
 228         if(res == 0)
 229             return E_FAIL;
 230         pos = mystrrchr(fullPath, '\\');
 231         if(!(V_BSTR(pVarResult) = SysAllocStringLen(fullPath, pos-fullPath)))
 232             return E_OUTOFMEMORY;
 233         break;
 234     }
 235     case DISPID_TESTOBJ_WSCRIPTSCRIPTNAME:
 236     {
 237         char fullPath[MAX_PATH];
 238         char *pos;
 239         long res;
 240
 241         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 242         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 243         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 244         V_VT(pVarResult) = VT_BSTR;
 245         res = GetFullPathNameA(script_name, sizeof(fullPath)/sizeof(WCHAR), fullPath, &pos);
 246         if(!res || res > sizeof(fullPath)/sizeof(WCHAR))
 247             return E_FAIL;
 248         if(!(V_BSTR(pVarResult) = SysAllocString(a2bstr(pos))))
 249             return E_OUTOFMEMORY;
 250         break;
 251     }
 252     case DISPID_TESTOBJ_WSCRIPTSCRIPTFULLNAME:
 253     {
 254         char fullPath[MAX_PATH];
 255         long res;
 256
 257         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 258         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 259         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 260         V_VT(pVarResult) = VT_BSTR;
 261         res = GetFullPathNameA(script_name, sizeof(fullPath)/sizeof(WCHAR), fullPath, NULL);
 262         if(!res || res > sizeof(fullPath)/sizeof(WCHAR))
 263             return E_FAIL;
 264         if(!(V_BSTR(pVarResult) = SysAllocString(a2bstr(fullPath))))
 265             return E_OUTOFMEMORY;
 266         break;
 267     }
 268     default:
 269         ok(0, "unexpected dispIdMember %d\n", dispIdMember);
 270         return E_NOTIMPL;
 271     }
 272
 273     return S_OK;
 274 }
 275
 276 static IDispatchVtbl testobj_vtbl = {
 277     Dispatch_QueryInterface,
 278     Dispatch_AddRef,
 279     Dispatch_Release,
 280     Dispatch_GetTypeInfoCount,
 281     Dispatch_GetTypeInfo,
 282     Dispatch_GetIDsOfNames,
 283     Dispatch_Invoke
 284 };
 285
 286 static IDispatch testobj = { &testobj_vtbl };
 287
 288 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 289 {
 290     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 291         *ppv = iface;
 292         return S_OK;
 293     }
 294
 295     *ppv = NULL;
 296     return E_NOINTERFACE;
 297 }
 298
 299 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 300 {
 301     return 2;
 302 }
 303
 304 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 305 {
 306     return 1;
 307 }
 308
 309 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 310 {
 311     ok(!outer, "outer = %p\n", outer);
 312     return IDispatch_QueryInterface(&testobj, riid, ppv);
 313 }
 314
 315 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 316 {
 317     return S_OK;
 318 }
 319
 320 static const IClassFactoryVtbl ClassFactoryVtbl = {
 321     ClassFactory_QueryInterface,
 322     ClassFactory_AddRef,
 323     ClassFactory_Release,
 324     ClassFactory_CreateInstance,
 325     ClassFactory_LockServer
 326 };
 327
 328 static IClassFactory testobj_cf = { &ClassFactoryVtbl };
 329
 330 static void run_test(const char *file_name)
 331 {
 332     SECURITY_ATTRIBUTES sa = {sizeof(sa), 0, TRUE};
 333     char command[MAX_PATH];
 334     STARTUPINFOA si = {sizeof(si)};
 335     PROCESS_INFORMATION pi;
 336     BOOL bres;
 337
 338     script_name = file_name;
 339     sprintf(command, "wscript.exe %s arg1 2 ar3", file_name);
 340
 341     SET_EXPECT(reportSuccess);
 342
 343     bres = CreateProcessA(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
 344     if(!bres) {
 345         win_skip("script.exe is not available\n");
 346         SET_CALLED(reportSuccess);
 347         return;
 348     }
 349
 350     wscript_process = pi.hProcess;
 351     WaitForSingleObject(pi.hProcess, INFINITE);
 352     CloseHandle(pi.hThread);
 353     CloseHandle(pi.hProcess);
 354
 355     CHECK_CALLED(reportSuccess);
 356 }
 357
 358 static BOOL WINAPI test_enum_proc(HMODULE module, LPCTSTR type, LPSTR name, LONG_PTR param)
 359 {
 360     const char *script_data, *ext;
 361     DWORD script_size, size;
 362     char file_name[MAX_PATH];
 363     HANDLE file;
 364     HRSRC src;
 365     BOOL res;
 366
 367     trace("running %s test...\n", name);
 368
 369     src = FindResourceA(NULL, name, type);
 370     ok(src != NULL, "Could not find resource %s: %u\n", name, GetLastError());
 371     if(!src)
 372         return TRUE;
 373
 374     script_data = LoadResource(NULL, src);
 375     script_size = SizeofResource(NULL, src);
 376     while(script_size && !script_data[script_size-1])
 377         script_size--;
 378
 379     ext = strrchr(name, '.');
 380     ok(ext != NULL, "no script extension\n");
 381     if(!ext)
 382       return TRUE;
 383
 384     sprintf(file_name, "test%s", ext);
 385
 386     file = CreateFileA(file_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 387             FILE_ATTRIBUTE_NORMAL, NULL);
 388     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
 389     if(file == INVALID_HANDLE_VALUE)
 390         return TRUE;
 391
 392     res = WriteFile(file, script_data, script_size, &size, NULL);
 393     CloseHandle(file);
 394     ok(res, "Could not write to file: %u\n", GetLastError());
 395     if(!res)
 396         return TRUE;
 397
 398     run_test(file_name);
 399
 400     DeleteFileA(file_name);
 401     return TRUE;
 402 }
 403
 404 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 405 {
 406     HKEY hkey;
 407     DWORD res;
 408
 409     if(!init) {
 410         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 411         return TRUE;
 412     }
 413
 414     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 415     if(res != ERROR_SUCCESS)
 416         return FALSE;
 417
 418     if(def_value)
 419         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 420
 421     RegCloseKey(hkey);
 422     return res == ERROR_SUCCESS;
 423 }
 424
 425 static BOOL init_registry(BOOL init)
 426 {
 427     return init_key("Wine.Test\\CLSID", TESTOBJ_CLSID, init);
 428 }
 429
 430 static BOOL register_activex(void)
 431 {
 432     DWORD regid;
 433     HRESULT hres;
 434
 435     if(!init_registry(TRUE)) {
 436         init_registry(FALSE);
 437         return FALSE;
 438     }
 439
 440     hres = CoRegisterClassObject(&CLSID_TestObj, (IUnknown *)&testobj_cf,
 441             CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &regid);
 442     ok(hres == S_OK, "Could not register script engine: %08x\n", hres);
 443     return TRUE;
 444 }
 445
 446 START_TEST(run)
 447 {
 448     char **argv;
 449     int argc;
 450
 451     CoInitializeEx(NULL, COINIT_MULTITHREADED);
 452     register_activex();
 453
 454     argc = winetest_get_mainargs(&argv);
 455     if(argc > 2)
 456         run_test(argv[2]);
 457     else
 458         EnumResourceNamesA(NULL, "TESTSCRIPT", test_enum_proc, 0);
 459
 460     init_registry(FALSE);
 461     CoUninitialize();
 462 }