dlls/shell32/tests/shlexec.c

   1 /*
   2  * Unit test of the ShellExecute function.
   3  *
   4  * Copyright 2005 Francois Gouget for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* TODO:
  22  * - test the default verb selection
  23  * - test selection of an alternate class
  24  * - try running executables in more ways
  25  * - try passing arguments to executables
  26  * - ShellExecute("foo.shlexec") with no path should work if foo.shlexec is
  27  *   in the PATH
  28  * - test associations that use %l, %L or "%1" instead of %1
  29  * - we may want to test ShellExecuteEx() instead of ShellExecute()
  30  *   and then we could also check its return value
  31  * - ShellExecuteEx() also calls SetLastError() with meaningful values which
  32  *   we could check
  33  */
  34
  35 #include <stdio.h>
  36 #include <assert.h>
  37
  38 #include "wtypes.h"
  39 #include "winbase.h"
  40 #include "windef.h"
  41 #include "shellapi.h"
  42 #include "shlwapi.h"
  43 #include "wine/test.h"
  44
  45 #include "shell32_test.h"
  46
  47
  48 static char argv0[MAX_PATH];
  49 static int myARGC;
  50 static char** myARGV;
  51 static char tmpdir[MAX_PATH];
  52 static char child_file[MAX_PATH];
  53 static DLLVERSIONINFO dllver;
  54
  55
  56 /***
  57  *
  58  * ShellExecute wrappers
  59  *
  60  ***/
  61 static void dump_child();
  62
  63 static HANDLE hEvent;
  64 static void init_event(const char* child_file)
  65 {
  66     char* event_name;
  67     event_name=strrchr(child_file, '\\')+1;
  68     hEvent=CreateEvent(NULL, FALSE, FALSE, event_name);
  69 }
  70
  71 static void strcat_param(char* str, const char* param)
  72 {
  73     if (param!=NULL)
  74     {
  75         strcat(str, "\"");
  76         strcat(str, param);
  77         strcat(str, "\"");
  78     }
  79     else
  80     {
  81         strcat(str, "null");
  82     }
  83 }
  84
  85 static char shell_call[2048]="";
  86 static int shell_execute(LPCSTR operation, LPCSTR file, LPCSTR parameters, LPCSTR directory)
  87 {
  88     int rc;
  89
  90     strcpy(shell_call, "ShellExecute(");
  91     strcat_param(shell_call, operation);
  92     strcat(shell_call, ", ");
  93     strcat_param(shell_call, file);
  94     strcat(shell_call, ", ");
  95     strcat_param(shell_call, parameters);
  96     strcat(shell_call, ", ");
  97     strcat_param(shell_call, directory);
  98     strcat(shell_call, ")");
  99     if (winetest_debug > 1)
 100         trace("%s\n", shell_call);
 101
 102     DeleteFile(child_file);
 103     SetLastError(0xcafebabe);
 104
 105     /* FIXME: We cannot use ShellExecuteEx() here because if there is no
 106      * association it displays the 'Open With' dialog and I could not find
 107      * a flag to prevent this.
 108      */
 109     rc=(int)ShellExecute(NULL, operation, file, parameters, directory,
 110                          SW_SHOWNORMAL);
 111
 112     if (rc>=32)
 113     {
 114         int wait_rc;
 115         wait_rc=WaitForSingleObject(hEvent, 60000);
 116         ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject returned %d\n", wait_rc);
 117     }
 118     /* The child process may have changed the result file, so let profile
 119      * functions know about it
 120      */
 121     WritePrivateProfileStringA(NULL, NULL, NULL, child_file);
 122     if (rc>=32)
 123         dump_child();
 124
 125     return rc;
 126 }
 127
 128 static int shell_execute_ex(DWORD mask, LPCSTR operation, LPCSTR file,
 129                             LPCSTR parameters, LPCSTR directory)
 130 {
 131     SHELLEXECUTEINFO sei;
 132     BOOL success;
 133     int rc;
 134
 135     strcpy(shell_call, "ShellExecuteEx(");
 136     strcat_param(shell_call, operation);
 137     strcat(shell_call, ", ");
 138     strcat_param(shell_call, file);
 139     strcat(shell_call, ", ");
 140     strcat_param(shell_call, parameters);
 141     strcat(shell_call, ", ");
 142     strcat_param(shell_call, directory);
 143     strcat(shell_call, ")");
 144     if (winetest_debug > 1)
 145         trace("%s\n", shell_call);
 146
 147     sei.cbSize=sizeof(sei);
 148     sei.fMask=SEE_MASK_NOCLOSEPROCESS | mask;
 149     sei.hwnd=NULL;
 150     sei.lpVerb=operation;
 151     sei.lpFile=file;
 152     sei.lpParameters=parameters;
 153     sei.lpDirectory=directory;
 154     sei.nShow=SW_SHOWNORMAL;
 155     sei.hInstApp=NULL; /* Out */
 156     sei.lpIDList=NULL;
 157     sei.lpClass=NULL;
 158     sei.hkeyClass=NULL;
 159     sei.dwHotKey=0;
 160     U(sei).hIcon=NULL;
 161     sei.hProcess=NULL; /* Out */
 162
 163     DeleteFile(child_file);
 164     SetLastError(0xcafebabe);
 165     success=ShellExecuteEx(&sei);
 166     rc=(int)sei.hInstApp;
 167     ok((success && rc >= 32) || (!success && rc < 32),
 168        "%s rc=%d and hInstApp=%d is not allowed\n", shell_call, success, rc);
 169
 170     if (rc>=32)
 171     {
 172         int wait_rc;
 173         if (sei.hProcess!=NULL)
 174         {
 175             wait_rc=WaitForSingleObject(sei.hProcess, 60000);
 176             ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject(hProcess) returned %d\n", wait_rc);
 177         }
 178         wait_rc=WaitForSingleObject(hEvent, 60000);
 179         ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject returned %d\n", wait_rc);
 180     }
 181     /* The child process may have changed the result file, so let profile
 182      * functions know about it
 183      */
 184     WritePrivateProfileStringA(NULL, NULL, NULL, child_file);
 185     if (rc>=32)
 186         dump_child();
 187
 188     return rc;
 189 }
 190
 191
 192
 193 /***
 194  *
 195  * Functions to create / delete associations wrappers
 196  *
 197  ***/
 198
 199 static void create_test_association(const char* extension)
 200 {
 201     HKEY hkey, hkey_shell;
 202     char class[MAX_PATH];
 203     LONG rc;
 204
 205     sprintf(class, "shlexec%s", extension);
 206     rc=RegCreateKeyEx(HKEY_CLASSES_ROOT, extension, 0, NULL, 0, KEY_SET_VALUE,
 207                       NULL, &hkey, NULL);
 208     assert(rc==ERROR_SUCCESS);
 209     rc=RegSetValueEx(hkey, NULL, 0, REG_SZ, (LPBYTE) class, strlen(class)+1);
 210     assert(rc==ERROR_SUCCESS);
 211     CloseHandle(hkey);
 212
 213     rc=RegCreateKeyEx(HKEY_CLASSES_ROOT, class, 0, NULL, 0,
 214                       KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS, NULL, &hkey, NULL);
 215     assert(rc==ERROR_SUCCESS);
 216     rc=RegCreateKeyEx(hkey, "shell", 0, NULL, 0,
 217                       KEY_CREATE_SUB_KEY, NULL, &hkey_shell, NULL);
 218     assert(rc==ERROR_SUCCESS);
 219     CloseHandle(hkey);
 220     CloseHandle(hkey_shell);
 221 }
 222
 223 static void delete_test_association(const char* extension)
 224 {
 225     char class[MAX_PATH];
 226
 227     sprintf(class, "shlexec%s", extension);
 228     SHDeleteKey(HKEY_CLASSES_ROOT, class);
 229     SHDeleteKey(HKEY_CLASSES_ROOT, extension);
 230 }
 231
 232 static void create_test_verb(const char* extension, const char* verb,
 233                              const char* cmdtail)
 234 {
 235     HKEY hkey_shell, hkey_verb, hkey_cmd;
 236     char shell[MAX_PATH];
 237     char* cmd;
 238     LONG rc;
 239
 240     sprintf(shell, "shlexec%s\\shell", extension);
 241     rc=RegOpenKeyEx(HKEY_CLASSES_ROOT, shell, 0,
 242                     KEY_CREATE_SUB_KEY, &hkey_shell);
 243     assert(rc==ERROR_SUCCESS);
 244     rc=RegCreateKeyEx(hkey_shell, verb, 0, NULL, 0, KEY_CREATE_SUB_KEY,
 245                       NULL, &hkey_verb, NULL);
 246     assert(rc==ERROR_SUCCESS);
 247     rc=RegCreateKeyEx(hkey_verb, "command", 0, NULL, 0, KEY_SET_VALUE,
 248                       NULL, &hkey_cmd, NULL);
 249     assert(rc==ERROR_SUCCESS);
 250
 251     cmd=malloc(strlen(argv0)+10+strlen(child_file)+2+strlen(cmdtail)+1);
 252     sprintf(cmd,"%s shlexec \"%s\" %s", argv0, child_file, cmdtail);
 253     rc=RegSetValueEx(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE) cmd, strlen(cmd)+1);
 254     assert(rc==ERROR_SUCCESS);
 255
 256     free(cmd);
 257     CloseHandle(hkey_shell);
 258     CloseHandle(hkey_verb);
 259     CloseHandle(hkey_cmd);
 260 }
 261
 262
 263
 264 /***
 265  *
 266  * Functions to check that the child process was started just right
 267  * (borrowed from dlls/kernel32/tests/process.c)
 268  *
 269  ***/
 270
 271 static const char* encodeA(const char* str)
 272 {
 273     static char encoded[2*1024+1];
 274     char*       ptr;
 275     size_t      len,i;
 276
 277     if (!str) return "";
 278     len = strlen(str) + 1;
 279     if (len >= sizeof(encoded)/2)
 280     {
 281         fprintf(stderr, "string is too long!\n");
 282         assert(0);
 283     }
 284     ptr = encoded;
 285     for (i = 0; i < len; i++)
 286         sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]);
 287     ptr[2 * len] = '\0';
 288     return ptr;
 289 }
 290
 291 static unsigned decode_char(char c)
 292 {
 293     if (c >= '0' && c <= '9') return c - '0';
 294     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
 295     assert(c >= 'A' && c <= 'F');
 296     return c - 'A' + 10;
 297 }
 298
 299 static char* decodeA(const char* str)
 300 {
 301     static char decoded[1024];
 302     char*       ptr;
 303     size_t      len,i;
 304
 305     len = strlen(str) / 2;
 306     if (!len--) return NULL;
 307     if (len >= sizeof(decoded))
 308     {
 309         fprintf(stderr, "string is too long!\n");
 310         assert(0);
 311     }
 312     ptr = decoded;
 313     for (i = 0; i < len; i++)
 314         ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]);
 315     ptr[len] = '\0';
 316     return ptr;
 317 }
 318
 319 static void     childPrintf(HANDLE h, const char* fmt, ...)
 320 {
 321     va_list     valist;
 322     char        buffer[1024];
 323     DWORD       w;
 324
 325     va_start(valist, fmt);
 326     vsprintf(buffer, fmt, valist);
 327     va_end(valist);
 328     WriteFile(h, buffer, strlen(buffer), &w, NULL);
 329 }
 330
 331 static void doChild(int argc, char** argv)
 332 {
 333     char* filename;
 334     HANDLE hFile;
 335     int i;
 336
 337     filename=argv[2];
 338     hFile=CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 339     if (hFile == INVALID_HANDLE_VALUE)
 340         return;
 341
 342     /* Arguments */
 343     childPrintf(hFile, "[Arguments]\n");
 344     if (winetest_debug > 2)
 345         trace("argcA=%d\n", argc);
 346     childPrintf(hFile, "argcA=%d\n", argc);
 347     for (i = 0; i < argc; i++)
 348     {
 349         if (winetest_debug > 2)
 350             trace("argvA%d=%s\n", i, argv[i]);
 351         childPrintf(hFile, "argvA%d=%s\n", i, encodeA(argv[i]));
 352     }
 353     CloseHandle(hFile);
 354
 355     init_event(filename);
 356     SetEvent(hEvent);
 357     CloseHandle(hEvent);
 358 }
 359
 360 static char* getChildString(const char* sect, const char* key)
 361 {
 362     char        buf[1024];
 363     char*       ret;
 364
 365     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), child_file);
 366     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
 367     assert(!(strlen(buf) & 1));
 368     ret = decodeA(buf);
 369     return ret;
 370 }
 371
 372 static void dump_child()
 373 {
 374     if (winetest_debug > 1)
 375     {
 376         char key[18];
 377         char* str;
 378         int i, c;
 379
 380         c=GetPrivateProfileIntA("Arguments", "argcA", -1, child_file);
 381         trace("argcA=%d\n",c);
 382         for (i=0;i<c;i++)
 383         {
 384             sprintf(key, "argvA%d", i);
 385             str=getChildString("Arguments", key);
 386             trace("%s=%s\n", key, str);
 387         }
 388     }
 389 }
 390
 391 static int StrCmpPath(const char* s1, const char* s2)
 392 {
 393     if (!s1 && !s2) return 0;
 394     if (!s2) return 1;
 395     if (!s1) return -1;
 396     while (*s1)
 397     {
 398         if (!*s2)
 399         {
 400             if (*s1=='.')
 401                 s1++;
 402             return (*s1-*s2);
 403         }
 404         if ((*s1=='/' || *s1=='\\') && (*s2=='/' || *s2=='\\'))
 405         {
 406             while (*s1=='/' || *s1=='\\')
 407                 s1++;
 408             while (*s2=='/' || *s2=='\\')
 409                 s2++;
 410         }
 411         else if (toupper(*s1)==toupper(*s2))
 412         {
 413             s1++;
 414             s2++;
 415         }
 416         else
 417         {
 418             return (*s1-*s2);
 419         }
 420     }
 421     if (*s2=='.')
 422         s2++;
 423     if (*s2)
 424         return -1;
 425     return 0;
 426 }
 427
 428 static int _okChildString(const char* file, int line, const char* key, const char* expected)
 429 {
 430     char* result;
 431     result=getChildString("Arguments", key);
 432     return ok_(file, line)(lstrcmpiA(result, expected) == 0,
 433                "%s expected '%s', got '%s'\n", key, expected, result);
 434 }
 435
 436 static int _okChildPath(const char* file, int line, const char* key, const char* expected)
 437 {
 438     char* result;
 439     result=getChildString("Arguments", key);
 440     return ok_(file, line)(StrCmpPath(result, expected) == 0,
 441                "%s expected '%s', got '%s'\n", key, expected, result);
 442 }
 443
 444 static int _okChildInt(const char* file, int line, const char* key, int expected)
 445 {
 446     INT result;
 447     result=GetPrivateProfileIntA("Arguments", key, expected, child_file);
 448     return ok_(file, line)(result == expected,
 449                "%s expected %d, but got %d\n", key, expected, result);
 450 }
 451
 452 #define okChildString(key, expected) _okChildString(__FILE__, __LINE__, (key), (expected))
 453 #define okChildPath(key, expected) _okChildPath(__FILE__, __LINE__, (key), (expected))
 454 #define okChildInt(key, expected)    _okChildInt(__FILE__, __LINE__, (key), (expected))
 455
 456
 457
 458 /***
 459  *
 460  * Tests
 461  *
 462  ***/
 463
 464 static const char* testfiles[]=
 465 {
 466     "%s\\test file.shlexec",
 467     "%s\\%%nasty%% $file.shlexec",
 468     "%s\\test file.noassoc",
 469     "%s\\test file.noassoc.shlexec",
 470     "%s\\test file.shlexec.noassoc",
 471     "%s\\test_shortcut_shlexec.lnk",
 472     "%s\\test_shortcut_exe.lnk",
 473     NULL
 474 };
 475
 476 typedef struct
 477 {
 478     char* verb;
 479     char* basename;
 480     int rc;
 481     int todo;
 482 } filename_tests_t;
 483
 484 static filename_tests_t filename_tests[]=
 485 {
 486     /* Test bad / nonexistent filenames */
 487     {NULL,           "%s\\nonexistent.shlexec", ERROR_FILE_NOT_FOUND, 0x1},
 488     {NULL,           "%s\\nonexistent.noassoc", ERROR_FILE_NOT_FOUND, 0x1},
 489
 490     /* Standard tests */
 491     {NULL,           "%s\\test file.shlexec",   0, 0x0},
 492     {NULL,           "%s\\test file.shlexec.",  0, 0x0},
 493     {NULL,           "%s\\%%nasty%% $file.shlexec", 0, 0x0},
 494     {NULL,           "%s/test file.shlexec",    0, 0x0},
 495
 496     /* Test filenames with no association */
 497     {NULL,           "%s\\test file.noassoc",   SE_ERR_NOASSOC, 0x0},
 498
 499     /* Test double extensions */
 500     {NULL,           "%s\\test file.noassoc.shlexec", 0, 0},
 501     {NULL,           "%s\\test file.shlexec.noassoc", SE_ERR_NOASSOC, 0x0},
 502
 503     /* Test alternate verbs */
 504     {"LowerL",       "%s\\nonexistent.shlexec", ERROR_FILE_NOT_FOUND, 0x1},
 505     {"LowerL",       "%s\\test file.noassoc",   SE_ERR_NOASSOC, 0x0},
 506
 507     {"QuotedLowerL", "%s\\test file.shlexec",   0, 0x0},
 508     {"QuotedUpperL", "%s\\test file.shlexec",   0, 0x0},
 509
 510     {NULL, NULL, 0, 0}
 511 };
 512
 513 static filename_tests_t noquotes_tests[]=
 514 {
 515     /* Test unquoted '%1' thingies */
 516     {"NoQuotes",     "%s\\test file.shlexec",   0, 0xa},
 517     {"LowerL",       "%s\\test file.shlexec",   0, 0x0},
 518     {"UpperL",       "%s\\test file.shlexec",   0, 0x0},
 519
 520     {NULL, NULL, 0, 0}
 521 };
 522
 523 static void test_filename()
 524 {
 525     char filename[MAX_PATH];
 526     const filename_tests_t* test;
 527     char* c;
 528     int rc;
 529
 530     test=filename_tests;
 531     while (test->basename)
 532     {
 533         sprintf(filename, test->basename, tmpdir);
 534         if (strchr(filename, '/'))
 535         {
 536             c=filename;
 537             while (*c)
 538             {
 539                 if (*c=='\\')
 540                     *c='/';
 541                 c++;
 542             }
 543         }
 544         rc=shell_execute(test->verb, filename, NULL, NULL);
 545         if (rc>=32)
 546             rc=0;
 547         if ((test->todo & 0x1)==0)
 548         {
 549             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 550                rc, GetLastError());
 551         }
 552         else todo_wine
 553         {
 554             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 555                rc, GetLastError());
 556         }
 557         if (rc==0)
 558         {
 559             const char* verb;
 560             if ((test->todo & 0x2)==0)
 561             {
 562                 okChildInt("argcA", 5);
 563             }
 564             else todo_wine
 565             {
 566                 okChildInt("argcA", 5);
 567             }
 568             verb=(test->verb ? test->verb : "Open");
 569             if ((test->todo & 0x4)==0)
 570             {
 571                 okChildString("argvA3", verb);
 572             }
 573             else todo_wine
 574             {
 575                 okChildString("argvA3", verb);
 576             }
 577             if ((test->todo & 0x8)==0)
 578             {
 579                 okChildPath("argvA4", filename);
 580             }
 581             else todo_wine
 582             {
 583                 okChildPath("argvA4", filename);
 584             }
 585         }
 586         test++;
 587     }
 588
 589     test=noquotes_tests;
 590     while (test->basename)
 591     {
 592         sprintf(filename, test->basename, tmpdir);
 593         rc=shell_execute(test->verb, filename, NULL, NULL);
 594         if (rc>=32)
 595             rc=0;
 596         if ((test->todo & 0x1)==0)
 597         {
 598             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 599                rc, GetLastError());
 600         }
 601         else todo_wine
 602         {
 603             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 604                rc, GetLastError());
 605         }
 606         if (rc==0)
 607         {
 608             int count;
 609             const char* verb;
 610             char* str;
 611
 612             verb=(test->verb ? test->verb : "Open");
 613             if ((test->todo & 0x4)==0)
 614             {
 615                 okChildString("argvA3", verb);
 616             }
 617             else todo_wine
 618             {
 619                 okChildString("argvA3", verb);
 620             }
 621
 622             count=4;
 623             str=filename;
 624             while (1)
 625             {
 626                 char attrib[18];
 627                 char* space;
 628                 space=strchr(str, ' ');
 629                 if (space)
 630                     *space='\0';
 631                 sprintf(attrib, "argvA%d", count);
 632                 if ((test->todo & 0x8)==0)
 633                 {
 634                     okChildPath(attrib, str);
 635                 }
 636                 else todo_wine
 637                 {
 638                     okChildPath(attrib, str);
 639                 }
 640                 count++;
 641                 if (!space)
 642                     break;
 643                 str=space+1;
 644             }
 645             if ((test->todo & 0x2)==0)
 646             {
 647                 okChildInt("argcA", count);
 648             }
 649             else todo_wine
 650             {
 651                 okChildInt("argcA", count);
 652             }
 653         }
 654         test++;
 655     }
 656
 657     if (dllver.dwMajorVersion != 0)
 658     {
 659         /* The more recent versions of shell32.dll accept quoted filenames
 660          * while older ones (e.g. 4.00) don't. Still we want to test this
 661          * because IE 6 depends on the new behavior.
 662          * One day we may need to check the exact version of the dll but for
 663          * now making sure DllGetVersion() is present is sufficient.
 664          */
 665         sprintf(filename, "\"%s\\test file.shlexec\"", tmpdir);
 666         rc=shell_execute(NULL, filename, NULL, NULL);
 667         ok(rc>=32, "%s failed: rc=%d err=%ld\n", shell_call, rc,
 668            GetLastError());
 669         okChildInt("argcA", 5);
 670         okChildString("argvA3", "Open");
 671         sprintf(filename, "%s\\test file.shlexec", tmpdir);
 672         okChildPath("argvA4", filename);
 673     }
 674 }
 675
 676
 677 static filename_tests_t lnk_tests[]=
 678 {
 679     /* Pass bad / nonexistent filenames as a parameter */
 680     {NULL, "%s\\nonexistent.shlexec", 0, 0xa},
 681     {NULL, "%s\\nonexistent.noassoc", 0, 0xa},
 682
 683     /* Pass regular paths as a parameter */
 684     {NULL, "%s\\test file.shlexec",   0, 0xa},
 685     {NULL, "%s/%%nasty%% $file.shlexec", 0, 0xa},
 686
 687     /* Pass filenames with no association as a parameter */
 688     {NULL, "%s\\test file.noassoc",   0, 0xa},
 689
 690     {NULL, NULL, 0, 0}
 691 };
 692
 693 static void test_lnks()
 694 {
 695     char filename[MAX_PATH];
 696     char params[MAX_PATH];
 697     const filename_tests_t* test;
 698     int rc;
 699
 700     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
 701     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 702     ok(rc>=32, "%s failed: rc=%d err=%ld\n", shell_call, rc,
 703        GetLastError());
 704     okChildInt("argcA", 5);
 705     okChildString("argvA3", "Open");
 706     sprintf(filename, "%s\\test file.shlexec", tmpdir);
 707     okChildPath("argvA4", filename);
 708
 709     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 710     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 711     ok(rc>=32, "%s failed: rc=%d err=%ld\n", shell_call, rc,
 712        GetLastError());
 713     okChildInt("argcA", 4);
 714     okChildString("argvA3", "Lnk");
 715
 716     if (dllver.dwMajorVersion>=6)
 717     {
 718         char* c;
 719        /* Recent versions of shell32.dll accept '/'s in shortcut paths.
 720          * Older versions don't or are quite buggy in this regard.
 721          */
 722         sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 723         c=filename;
 724         while (*c)
 725         {
 726             if (*c=='\\')
 727                 *c='/';
 728             c++;
 729         }
 730         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 731         ok(rc>=32, "%s failed: rc=%d err=%ld\n", shell_call, rc,
 732            GetLastError());
 733         okChildInt("argcA", 4);
 734         okChildString("argvA3", "Lnk");
 735     }
 736
 737     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 738     test=lnk_tests;
 739     while (test->basename)
 740     {
 741         params[0]='\"';
 742         sprintf(params+1, test->basename, tmpdir);
 743         strcat(params,"\"");
 744         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, params,
 745                             NULL);
 746         if (rc>=32)
 747             rc=0;
 748         if ((test->todo & 0x1)==0)
 749         {
 750             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 751                rc, GetLastError());
 752         }
 753         else todo_wine
 754         {
 755             ok(rc==test->rc, "%s failed: rc=%d err=%ld\n", shell_call,
 756                rc, GetLastError());
 757         }
 758         if (rc==0)
 759         {
 760             if ((test->todo & 0x2)==0)
 761             {
 762                 okChildInt("argcA", 5);
 763             }
 764             else todo_wine
 765             {
 766                 okChildInt("argcA", 5);
 767             }
 768             if ((test->todo & 0x4)==0)
 769             {
 770                 okChildString("argvA3", "Lnk");
 771             }
 772             else todo_wine
 773             {
 774                 okChildString("argvA3", "Lnk");
 775             }
 776             sprintf(params, test->basename, tmpdir);
 777             if ((test->todo & 0x8)==0)
 778             {
 779                 okChildPath("argvA4", params);
 780             }
 781             else todo_wine
 782             {
 783                 okChildPath("argvA4", params);
 784             }
 785         }
 786         test++;
 787     }
 788 }
 789
 790
 791 static void test_exes()
 792 {
 793     char filename[MAX_PATH];
 794     char params[1024];
 795     int rc;
 796
 797     sprintf(params, "shlexec \"%s\" Exec", child_file);
 798
 799     /* We need NOZONECHECKS on Win2003 to block a dialog */
 800     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
 801                         NULL);
 802     ok(rc>=32, "%s returned %d\n", shell_call, rc);
 803     okChildInt("argcA", 4);
 804     okChildString("argvA3", "Exec");
 805
 806     sprintf(filename, "%s\\test file.noassoc", tmpdir);
 807     if (CopyFile(argv0, filename, FALSE))
 808     {
 809         rc=shell_execute(NULL, filename, params, NULL);
 810         todo_wine {
 811         ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%d\n", shell_call, rc);
 812         }
 813     }
 814 }
 815
 816
 817 static void init_test()
 818 {
 819     HMODULE hdll;
 820     HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO*);
 821     char filename[MAX_PATH];
 822     WCHAR lnkfile[MAX_PATH];
 823     char params[1024];
 824     const char* const * testfile;
 825     lnk_desc_t desc;
 826     DWORD rc;
 827     HRESULT r;
 828
 829     hdll=GetModuleHandleA("shell32.dll");
 830     pDllGetVersion=(void*)GetProcAddress(hdll, "DllGetVersion");
 831     if (pDllGetVersion)
 832     {
 833         dllver.cbSize=sizeof(dllver);
 834         pDllGetVersion(&dllver);
 835         trace("major=%ld minor=%ld build=%ld platform=%ld\n",
 836               dllver.dwMajorVersion, dllver.dwMinorVersion,
 837               dllver.dwBuildNumber, dllver.dwPlatformID);
 838     }
 839     else
 840     {
 841         memset(&dllver, 0, sizeof(dllver));
 842     }
 843
 844     r = CoInitialize(NULL);
 845     ok(SUCCEEDED(r), "CoInitialize failed (0x%08lx)\n", r);
 846     if (!SUCCEEDED(r))
 847         exit(1);
 848
 849     rc=GetModuleFileName(NULL, argv0, sizeof(argv0));
 850     assert(rc!=0 && rc<sizeof(argv0));
 851     if (GetFileAttributes(argv0)==INVALID_FILE_ATTRIBUTES)
 852     {
 853         strcat(argv0, ".so");
 854         ok(GetFileAttributes(argv0)!=INVALID_FILE_ATTRIBUTES,
 855            "unable to find argv0!\n");
 856     }
 857
 858     GetTempPathA(sizeof(tmpdir)/sizeof(*tmpdir), tmpdir);
 859     assert(GetTempFileNameA(tmpdir, "wt", 0, child_file)!=0);
 860     init_event(child_file);
 861
 862     /* Set up the test files */
 863     testfile=testfiles;
 864     while (*testfile)
 865     {
 866         HANDLE hfile;
 867
 868         sprintf(filename, *testfile, tmpdir);
 869         hfile=CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 870                      FILE_ATTRIBUTE_NORMAL, NULL);
 871         if (hfile==INVALID_HANDLE_VALUE)
 872         {
 873             trace("unable to create '%s': err=%ld\n", filename, GetLastError());
 874             assert(0);
 875         }
 876         CloseHandle(hfile);
 877         testfile++;
 878     }
 879
 880     /* Setup the test shortcuts */
 881     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
 882     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
 883     desc.description=NULL;
 884     desc.workdir=NULL;
 885     sprintf(filename, "%s\\test file.shlexec", tmpdir);
 886     desc.path=filename;
 887     desc.pidl=NULL;
 888     desc.arguments="ignored";
 889     desc.showcmd=0;
 890     desc.icon=NULL;
 891     desc.icon_id=0;
 892     desc.hotkey=0;
 893     create_lnk(lnkfile, &desc, 0);
 894
 895     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 896     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
 897     desc.description=NULL;
 898     desc.workdir=NULL;
 899     desc.path=argv0;
 900     desc.pidl=NULL;
 901     sprintf(params, "shlexec \"%s\" Lnk", child_file);
 902     desc.arguments=params;
 903     desc.showcmd=0;
 904     desc.icon=NULL;
 905     desc.icon_id=0;
 906     desc.hotkey=0;
 907     create_lnk(lnkfile, &desc, 0);
 908
 909     /* Create a basic association suitable for most tests */
 910     create_test_association(".shlexec");
 911     create_test_verb(".shlexec", "Open", "Open \"%1\"");
 912     create_test_verb(".shlexec", "NoQuotes", "NoQuotes %1");
 913     create_test_verb(".shlexec", "LowerL", "LowerL %l");
 914     create_test_verb(".shlexec", "QuotedLowerL", "QuotedLowerL \"%l\"");
 915     create_test_verb(".shlexec", "UpperL", "UpperL %L");
 916     create_test_verb(".shlexec", "QuotedUpperL", "QuotedUpperL \"%L\"");
 917 }
 918
 919 static void cleanup_test()
 920 {
 921     char filename[MAX_PATH];
 922     const char* const * testfile;
 923
 924     /* Delete the test files */
 925     testfile=testfiles;
 926     while (*testfile)
 927     {
 928         sprintf(filename, *testfile, tmpdir);
 929         DeleteFile(filename);
 930         testfile++;
 931     }
 932     DeleteFile(child_file);
 933
 934     /* Delete the test association */
 935     delete_test_association(".shlexec");
 936
 937     CloseHandle(hEvent);
 938
 939     CoUninitialize();
 940 }
 941
 942 START_TEST(shlexec)
 943 {
 944
 945     myARGC = winetest_get_mainargs(&myARGV);
 946     if (myARGC >= 3)
 947     {
 948         doChild(myARGC, myARGV);
 949         exit(0);
 950     }
 951
 952     init_test();
 953
 954     test_filename();
 955     test_lnks();
 956     test_exes();
 957
 958     cleanup_test();
 959 }