git.oblomov.eu Git - wine/blob - 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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(void);
  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, 5000);
 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, 5000);
 176             ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject(hProcess) returned %d\n", wait_rc);
 177         }
 178         wait_rc=WaitForSingleObject(hEvent, 5000);
 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                              int rawcmd, 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     if (rawcmd)
 252     {
 253         rc=RegSetValueEx(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmdtail, strlen(cmdtail)+1);
 254     }
 255     else
 256     {
 257         cmd=malloc(strlen(argv0)+10+strlen(child_file)+2+strlen(cmdtail)+1);
 258         sprintf(cmd,"%s shlexec \"%s\" %s", argv0, child_file, cmdtail);
 259         rc=RegSetValueEx(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmd, strlen(cmd)+1);
 260         assert(rc==ERROR_SUCCESS);
 261         free(cmd);
 262     }
 263
 264     CloseHandle(hkey_shell);
 265     CloseHandle(hkey_verb);
 266     CloseHandle(hkey_cmd);
 267 }
 268
 269
 270
 271 /***
 272  *
 273  * Functions to check that the child process was started just right
 274  * (borrowed from dlls/kernel32/tests/process.c)
 275  *
 276  ***/
 277
 278 static const char* encodeA(const char* str)
 279 {
 280     static char encoded[2*1024+1];
 281     char*       ptr;
 282     size_t      len,i;
 283
 284     if (!str) return "";
 285     len = strlen(str) + 1;
 286     if (len >= sizeof(encoded)/2)
 287     {
 288         fprintf(stderr, "string is too long!\n");
 289         assert(0);
 290     }
 291     ptr = encoded;
 292     for (i = 0; i < len; i++)
 293         sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]);
 294     ptr[2 * len] = '\0';
 295     return ptr;
 296 }
 297
 298 static unsigned decode_char(char c)
 299 {
 300     if (c >= '0' && c <= '9') return c - '0';
 301     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
 302     assert(c >= 'A' && c <= 'F');
 303     return c - 'A' + 10;
 304 }
 305
 306 static char* decodeA(const char* str)
 307 {
 308     static char decoded[1024];
 309     char*       ptr;
 310     size_t      len,i;
 311
 312     len = strlen(str) / 2;
 313     if (!len--) return NULL;
 314     if (len >= sizeof(decoded))
 315     {
 316         fprintf(stderr, "string is too long!\n");
 317         assert(0);
 318     }
 319     ptr = decoded;
 320     for (i = 0; i < len; i++)
 321         ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]);
 322     ptr[len] = '\0';
 323     return ptr;
 324 }
 325
 326 static void     childPrintf(HANDLE h, const char* fmt, ...)
 327 {
 328     va_list     valist;
 329     char        buffer[1024];
 330     DWORD       w;
 331
 332     va_start(valist, fmt);
 333     vsprintf(buffer, fmt, valist);
 334     va_end(valist);
 335     WriteFile(h, buffer, strlen(buffer), &w, NULL);
 336 }
 337
 338 static void doChild(int argc, char** argv)
 339 {
 340     char* filename;
 341     HANDLE hFile;
 342     int i;
 343
 344     filename=argv[2];
 345     hFile=CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 346     if (hFile == INVALID_HANDLE_VALUE)
 347         return;
 348
 349     /* Arguments */
 350     childPrintf(hFile, "[Arguments]\r\n");
 351     if (winetest_debug > 2)
 352         trace("argcA=%d\n", argc);
 353     childPrintf(hFile, "argcA=%d\r\n", argc);
 354     for (i = 0; i < argc; i++)
 355     {
 356         if (winetest_debug > 2)
 357             trace("argvA%d=%s\n", i, argv[i]);
 358         childPrintf(hFile, "argvA%d=%s\r\n", i, encodeA(argv[i]));
 359     }
 360     CloseHandle(hFile);
 361
 362     init_event(filename);
 363     SetEvent(hEvent);
 364     CloseHandle(hEvent);
 365 }
 366
 367 static char* getChildString(const char* sect, const char* key)
 368 {
 369     char        buf[1024];
 370     char*       ret;
 371
 372     GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), child_file);
 373     if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
 374     assert(!(strlen(buf) & 1));
 375     ret = decodeA(buf);
 376     return ret;
 377 }
 378
 379 static void dump_child(void)
 380 {
 381     if (winetest_debug > 1)
 382     {
 383         char key[18];
 384         char* str;
 385         int i, c;
 386
 387         c=GetPrivateProfileIntA("Arguments", "argcA", -1, child_file);
 388         trace("argcA=%d\n",c);
 389         for (i=0;i<c;i++)
 390         {
 391             sprintf(key, "argvA%d", i);
 392             str=getChildString("Arguments", key);
 393             trace("%s=%s\n", key, str);
 394         }
 395     }
 396 }
 397
 398 static int StrCmpPath(const char* s1, const char* s2)
 399 {
 400     if (!s1 && !s2) return 0;
 401     if (!s2) return 1;
 402     if (!s1) return -1;
 403     while (*s1)
 404     {
 405         if (!*s2)
 406         {
 407             if (*s1=='.')
 408                 s1++;
 409             return (*s1-*s2);
 410         }
 411         if ((*s1=='/' || *s1=='\\') && (*s2=='/' || *s2=='\\'))
 412         {
 413             while (*s1=='/' || *s1=='\\')
 414                 s1++;
 415             while (*s2=='/' || *s2=='\\')
 416                 s2++;
 417         }
 418         else if (toupper(*s1)==toupper(*s2))
 419         {
 420             s1++;
 421             s2++;
 422         }
 423         else
 424         {
 425             return (*s1-*s2);
 426         }
 427     }
 428     if (*s2=='.')
 429         s2++;
 430     if (*s2)
 431         return -1;
 432     return 0;
 433 }
 434
 435 static int _okChildString(const char* file, int line, const char* key, const char* expected)
 436 {
 437     char* result;
 438     result=getChildString("Arguments", key);
 439     return ok_(file, line)(lstrcmpiA(result, expected) == 0,
 440                "%s expected '%s', got '%s'\n", key, expected, result);
 441 }
 442
 443 static int _okChildPath(const char* file, int line, const char* key, const char* expected)
 444 {
 445     char* result;
 446     result=getChildString("Arguments", key);
 447     return ok_(file, line)(StrCmpPath(result, expected) == 0,
 448                "%s expected '%s', got '%s'\n", key, expected, result);
 449 }
 450
 451 static int _okChildInt(const char* file, int line, const char* key, int expected)
 452 {
 453     INT result;
 454     result=GetPrivateProfileIntA("Arguments", key, expected, child_file);
 455     return ok_(file, line)(result == expected,
 456                "%s expected %d, but got %d\n", key, expected, result);
 457 }
 458
 459 #define okChildString(key, expected) _okChildString(__FILE__, __LINE__, (key), (expected))
 460 #define okChildPath(key, expected) _okChildPath(__FILE__, __LINE__, (key), (expected))
 461 #define okChildInt(key, expected)    _okChildInt(__FILE__, __LINE__, (key), (expected))
 462
 463
 464
 465 /***
 466  *
 467  * Tests
 468  *
 469  ***/
 470
 471 static const char* testfiles[]=
 472 {
 473     "%s\\test file.shlexec",
 474     "%s\\%%nasty%% $file.shlexec",
 475     "%s\\test file.noassoc",
 476     "%s\\test file.noassoc.shlexec",
 477     "%s\\test file.shlexec.noassoc",
 478     "%s\\test_shortcut_shlexec.lnk",
 479     "%s\\test_shortcut_exe.lnk",
 480     "%s\\test file.shl",
 481     "%s\\test file.shlfoo",
 482     "%s\\test file.sfe",
 483     NULL
 484 };
 485
 486 typedef struct
 487 {
 488     const char* verb;
 489     const char* basename;
 490     int todo;
 491     int rc;
 492 } filename_tests_t;
 493
 494 static filename_tests_t filename_tests[]=
 495 {
 496     /* Test bad / nonexistent filenames */
 497     {NULL,           "%s\\nonexistent.shlexec", 0x11, SE_ERR_FNF},
 498     {NULL,           "%s\\nonexistent.noassoc", 0x11, SE_ERR_FNF},
 499
 500     /* Standard tests */
 501     {NULL,           "%s\\test file.shlexec",   0x0, 33},
 502     {NULL,           "%s\\test file.shlexec.",  0x0, 33},
 503     {NULL,           "%s\\%%nasty%% $file.shlexec", 0x0, 33},
 504     {NULL,           "%s/test file.shlexec",    0x0, 33},
 505
 506     /* Test filenames with no association */
 507     {NULL,           "%s\\test file.noassoc",   0x0,  SE_ERR_NOASSOC},
 508
 509     /* Test double extensions */
 510     {NULL,           "%s\\test file.noassoc.shlexec", 0x0, 33},
 511     {NULL,           "%s\\test file.shlexec.noassoc", 0x0, SE_ERR_NOASSOC},
 512
 513     /* Test alternate verbs */
 514     {"LowerL",       "%s\\nonexistent.shlexec", 0x11, SE_ERR_FNF},
 515     {"LowerL",       "%s\\test file.noassoc",   0x0,  SE_ERR_NOASSOC},
 516
 517     {"QuotedLowerL", "%s\\test file.shlexec",   0x0, 33},
 518     {"QuotedUpperL", "%s\\test file.shlexec",   0x0, 33},
 519
 520     {NULL, NULL, 0}
 521 };
 522
 523 static filename_tests_t noquotes_tests[]=
 524 {
 525     /* Test unquoted '%1' thingies */
 526     {"NoQuotes",     "%s\\test file.shlexec",   0xa, 33},
 527     {"LowerL",       "%s\\test file.shlexec",   0xa, 33},
 528     {"UpperL",       "%s\\test file.shlexec",   0xa, 33},
 529
 530     {NULL, NULL, 0}
 531 };
 532
 533 static void test_filename(void)
 534 {
 535     char filename[MAX_PATH];
 536     const filename_tests_t* test;
 537     char* c;
 538     int rc;
 539
 540     test=filename_tests;
 541     while (test->basename)
 542     {
 543         sprintf(filename, test->basename, tmpdir);
 544         if (strchr(filename, '/'))
 545         {
 546             c=filename;
 547             while (*c)
 548             {
 549                 if (*c=='\\')
 550                     *c='/';
 551                 c++;
 552             }
 553         }
 554         rc=shell_execute(test->verb, filename, NULL, NULL);
 555         if (rc > 32)
 556             rc=33;
 557         if ((test->todo & 0x1)==0)
 558         {
 559             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 560                rc, GetLastError());
 561         }
 562         else todo_wine
 563         {
 564             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 565                rc, GetLastError());
 566         }
 567         if (rc == 33)
 568         {
 569             const char* verb;
 570             if ((test->todo & 0x2)==0)
 571             {
 572                 okChildInt("argcA", 5);
 573             }
 574             else todo_wine
 575             {
 576                 okChildInt("argcA", 5);
 577             }
 578             verb=(test->verb ? test->verb : "Open");
 579             if ((test->todo & 0x4)==0)
 580             {
 581                 okChildString("argvA3", verb);
 582             }
 583             else todo_wine
 584             {
 585                 okChildString("argvA3", verb);
 586             }
 587             if ((test->todo & 0x8)==0)
 588             {
 589                 okChildPath("argvA4", filename);
 590             }
 591             else todo_wine
 592             {
 593                 okChildPath("argvA4", filename);
 594             }
 595         }
 596         test++;
 597     }
 598
 599     test=noquotes_tests;
 600     while (test->basename)
 601     {
 602         sprintf(filename, test->basename, tmpdir);
 603         rc=shell_execute(test->verb, filename, NULL, NULL);
 604         if (rc > 32)
 605             rc=33;
 606         if ((test->todo & 0x1)==0)
 607         {
 608             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 609                rc, GetLastError());
 610         }
 611         else todo_wine
 612         {
 613             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 614                rc, GetLastError());
 615         }
 616         if (rc==0)
 617         {
 618             int count;
 619             const char* verb;
 620             char* str;
 621
 622             verb=(test->verb ? test->verb : "Open");
 623             if ((test->todo & 0x4)==0)
 624             {
 625                 okChildString("argvA3", verb);
 626             }
 627             else todo_wine
 628             {
 629                 okChildString("argvA3", verb);
 630             }
 631
 632             count=4;
 633             str=filename;
 634             while (1)
 635             {
 636                 char attrib[18];
 637                 char* space;
 638                 space=strchr(str, ' ');
 639                 if (space)
 640                     *space='\0';
 641                 sprintf(attrib, "argvA%d", count);
 642                 if ((test->todo & 0x8)==0)
 643                 {
 644                     okChildPath(attrib, str);
 645                 }
 646                 else todo_wine
 647                 {
 648                     okChildPath(attrib, str);
 649                 }
 650                 count++;
 651                 if (!space)
 652                     break;
 653                 str=space+1;
 654             }
 655             if ((test->todo & 0x2)==0)
 656             {
 657                 okChildInt("argcA", count);
 658             }
 659             else todo_wine
 660             {
 661                 okChildInt("argcA", count);
 662             }
 663         }
 664         test++;
 665     }
 666
 667     if (dllver.dwMajorVersion != 0)
 668     {
 669         /* The more recent versions of shell32.dll accept quoted filenames
 670          * while older ones (e.g. 4.00) don't. Still we want to test this
 671          * because IE 6 depends on the new behavior.
 672          * One day we may need to check the exact version of the dll but for
 673          * now making sure DllGetVersion() is present is sufficient.
 674          */
 675         sprintf(filename, "\"%s\\test file.shlexec\"", tmpdir);
 676         rc=shell_execute(NULL, filename, NULL, NULL);
 677         ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 678            GetLastError());
 679         okChildInt("argcA", 5);
 680         okChildString("argvA3", "Open");
 681         sprintf(filename, "%s\\test file.shlexec", tmpdir);
 682         okChildPath("argvA4", filename);
 683     }
 684 }
 685
 686 static void test_find_executable(void)
 687 {
 688     char filename[MAX_PATH];
 689     char command[MAX_PATH];
 690     const filename_tests_t* test;
 691     int rc;
 692
 693     create_test_association(".sfe");
 694     create_test_verb(".sfe", "Open", 1, "%1");
 695
 696     /* Don't test FindExecutable(..., NULL), it always crashes */
 697
 698     strcpy(command, "your word");
 699     rc=(int)FindExecutableA(NULL, NULL, command);
 700     ok(rc == SE_ERR_FNF || rc > 32 /* nt4 */, "FindExecutable(NULL) returned %d\n", rc);
 701     ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command);
 702
 703     strcpy(command, "your word");
 704     rc=(int)FindExecutableA(tmpdir, NULL, command);
 705     ok(rc == SE_ERR_NOASSOC /* >= win2000 */ || rc > 32 /* win98, nt4 */, "FindExecutable(NULL) returned %d\n", rc);
 706     ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command);
 707
 708     sprintf(filename, "%s\\test file.sfe", tmpdir);
 709     rc=(int)FindExecutableA(filename, NULL, command);
 710     ok(rc > 32, "FindExecutable(%s) returned %d\n", filename, rc);
 711     /* Depending on the platform, command could be '%1' or 'test file.sfe' */
 712
 713     rc=(int)FindExecutableA("test file.sfe", tmpdir, command);
 714     ok(rc > 32, "FindExecutable(%s) returned %d\n", filename, rc);
 715
 716     rc=(int)FindExecutableA("test file.sfe", NULL, command);
 717     todo_wine ok(rc == SE_ERR_FNF, "FindExecutable(%s) returned %d\n", filename, rc);
 718
 719     delete_test_association(".sfe");
 720
 721     create_test_association(".shl");
 722     create_test_verb(".shl", "Open", 0, "Open");
 723
 724     sprintf(filename, "%s\\test file.shl", tmpdir);
 725     rc=(int)FindExecutableA(filename, NULL, command);
 726     ok(rc == SE_ERR_FNF /* NT4 */ || rc > 32, "FindExecutable(%s) returned %d\n", filename, rc);
 727
 728     sprintf(filename, "%s\\test file.shlfoo", tmpdir);
 729     rc=(int)FindExecutableA(filename, NULL, command);
 730
 731     delete_test_association(".shl");
 732
 733     if (rc > 32)
 734     {
 735         /* On Windows XP and 2003 FindExecutable() is completely broken.
 736          * Probably what it does is convert the filename to 8.3 format,
 737          * which as a side effect converts the '.shlfoo' extension to '.shl',
 738          * and then tries to find an association for '.shl'. This means it
 739          * will normally fail on most extensions with more than 3 characters,
 740          * like '.mpeg', etc.
 741          * Also it means we cannot do any other test.
 742          */
 743         trace("FindExecutable() is broken -> skipping 4+ character extension tests\n");
 744         return;
 745     }
 746
 747     test=filename_tests;
 748     while (test->basename)
 749     {
 750         sprintf(filename, test->basename, tmpdir);
 751         if (strchr(filename, '/'))
 752         {
 753             char* c;
 754             c=filename;
 755             while (*c)
 756             {
 757                 if (*c=='\\')
 758                     *c='/';
 759                 c++;
 760             }
 761         }
 762         /* Win98 does not '\0'-terminate command! */
 763         memset(command, '\0', sizeof(command));
 764         rc=(int)FindExecutableA(filename, NULL, command);
 765         if (rc > 32)
 766             rc=33;
 767         if ((test->todo & 0x10)==0)
 768         {
 769             ok(rc==test->rc, "FindExecutable(%s) failed: rc=%d\n", filename, rc);
 770         }
 771         else todo_wine
 772         {
 773             ok(rc==test->rc, "FindExecutable(%s) failed: rc=%d\n", filename, rc);
 774         }
 775         if (rc > 32)
 776         {
 777             int equal;
 778             equal=strcmp(command, argv0) == 0 ||
 779                 /* NT4 returns an extra 0x8 character! */
 780                 (strlen(command) == strlen(argv0)+1 && strncmp(command, argv0, strlen(argv0)) == 0);
 781             if ((test->todo & 0x20)==0)
 782             {
 783                 ok(equal, "FindExecutable(%s) returned command='%s' instead of '%s'\n",
 784                    filename, command, argv0);
 785             }
 786             else todo_wine
 787             {
 788                 ok(equal, "FindExecutable(%s) returned command='%s' instead of '%s'\n",
 789                    filename, command, argv0);
 790             }
 791         }
 792         test++;
 793     }
 794 }
 795
 796
 797 static filename_tests_t lnk_tests[]=
 798 {
 799     /* Pass bad / nonexistent filenames as a parameter */
 800     {NULL, "%s\\nonexistent.shlexec",    0xa, 33},
 801     {NULL, "%s\\nonexistent.noassoc",    0xa, 33},
 802
 803     /* Pass regular paths as a parameter */
 804     {NULL, "%s\\test file.shlexec",      0xa, 33},
 805     {NULL, "%s/%%nasty%% $file.shlexec", 0xa, 33},
 806
 807     /* Pass filenames with no association as a parameter */
 808     {NULL, "%s\\test file.noassoc",      0xa, 33},
 809
 810     {NULL, NULL, 0}
 811 };
 812
 813 static void test_lnks(void)
 814 {
 815     char filename[MAX_PATH];
 816     char params[MAX_PATH];
 817     const filename_tests_t* test;
 818     int rc;
 819
 820     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
 821     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 822     ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 823        GetLastError());
 824     okChildInt("argcA", 5);
 825     okChildString("argvA3", "Open");
 826     sprintf(filename, "%s\\test file.shlexec", tmpdir);
 827     okChildPath("argvA4", filename);
 828
 829     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 830     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 831     ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 832        GetLastError());
 833     okChildInt("argcA", 4);
 834     okChildString("argvA3", "Lnk");
 835
 836     if (dllver.dwMajorVersion>=6)
 837     {
 838         char* c;
 839        /* Recent versions of shell32.dll accept '/'s in shortcut paths.
 840          * Older versions don't or are quite buggy in this regard.
 841          */
 842         sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 843         c=filename;
 844         while (*c)
 845         {
 846             if (*c=='\\')
 847                 *c='/';
 848             c++;
 849         }
 850         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 851         ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 852            GetLastError());
 853         okChildInt("argcA", 4);
 854         okChildString("argvA3", "Lnk");
 855     }
 856
 857     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 858     test=lnk_tests;
 859     while (test->basename)
 860     {
 861         params[0]='\"';
 862         sprintf(params+1, test->basename, tmpdir);
 863         strcat(params,"\"");
 864         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, params,
 865                             NULL);
 866         if (rc > 32)
 867             rc=33;
 868         if ((test->todo & 0x1)==0)
 869         {
 870             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 871                rc, GetLastError());
 872         }
 873         else todo_wine
 874         {
 875             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 876                rc, GetLastError());
 877         }
 878         if (rc==0)
 879         {
 880             if ((test->todo & 0x2)==0)
 881             {
 882                 okChildInt("argcA", 5);
 883             }
 884             else
 885             {
 886                 okChildInt("argcA", 5);
 887             }
 888             if ((test->todo & 0x4)==0)
 889             {
 890                 okChildString("argvA3", "Lnk");
 891             }
 892             else todo_wine
 893             {
 894                 okChildString("argvA3", "Lnk");
 895             }
 896             sprintf(params, test->basename, tmpdir);
 897             if ((test->todo & 0x8)==0)
 898             {
 899                 okChildPath("argvA4", params);
 900             }
 901             else
 902             {
 903                 okChildPath("argvA4", params);
 904             }
 905         }
 906         test++;
 907     }
 908 }
 909
 910
 911 static void test_exes(void)
 912 {
 913     char filename[MAX_PATH];
 914     char params[1024];
 915     int rc;
 916
 917     sprintf(params, "shlexec \"%s\" Exec", child_file);
 918
 919     /* We need NOZONECHECKS on Win2003 to block a dialog */
 920     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
 921                         NULL);
 922     ok(rc > 32, "%s returned %d\n", shell_call, rc);
 923     okChildInt("argcA", 4);
 924     okChildString("argvA3", "Exec");
 925
 926     sprintf(filename, "%s\\test file.noassoc", tmpdir);
 927     if (CopyFile(argv0, filename, FALSE))
 928     {
 929         rc=shell_execute(NULL, filename, params, NULL);
 930         todo_wine {
 931         ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%d\n", shell_call, rc);
 932         }
 933     }
 934 }
 935
 936 static void test_exes_long(void)
 937 {
 938     char filename[MAX_PATH];
 939     char params[2024];
 940     char longparam[MAX_PATH];
 941     int rc;
 942
 943     for (rc = 0; rc < MAX_PATH; rc++)
 944         longparam[rc]='a'+rc%26;
 945     longparam[MAX_PATH-1]=0;
 946
 947
 948     sprintf(params, "shlexec \"%s\" %s", child_file,longparam);
 949
 950     /* We need NOZONECHECKS on Win2003 to block a dialog */
 951     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
 952                         NULL);
 953     ok(rc > 32, "%s returned %d\n", shell_call, rc);
 954     okChildInt("argcA", 4);
 955     okChildString("argvA3", longparam);
 956
 957     sprintf(filename, "%s\\test file.noassoc", tmpdir);
 958     if (CopyFile(argv0, filename, FALSE))
 959     {
 960         rc=shell_execute(NULL, filename, params, NULL);
 961         todo_wine {
 962         ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%d\n", shell_call, rc);
 963         }
 964     }
 965 }
 966
 967
 968 static void init_test(void)
 969 {
 970     HMODULE hdll;
 971     HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO*);
 972     char filename[MAX_PATH];
 973     WCHAR lnkfile[MAX_PATH];
 974     char params[1024];
 975     const char* const * testfile;
 976     lnk_desc_t desc;
 977     DWORD rc;
 978     HRESULT r;
 979
 980     hdll=GetModuleHandleA("shell32.dll");
 981     pDllGetVersion=(void*)GetProcAddress(hdll, "DllGetVersion");
 982     if (pDllGetVersion)
 983     {
 984         dllver.cbSize=sizeof(dllver);
 985         pDllGetVersion(&dllver);
 986         trace("major=%d minor=%d build=%d platform=%d\n",
 987               dllver.dwMajorVersion, dllver.dwMinorVersion,
 988               dllver.dwBuildNumber, dllver.dwPlatformID);
 989     }
 990     else
 991     {
 992         memset(&dllver, 0, sizeof(dllver));
 993     }
 994
 995     r = CoInitialize(NULL);
 996     ok(SUCCEEDED(r), "CoInitialize failed (0x%08x)\n", r);
 997     if (!SUCCEEDED(r))
 998         exit(1);
 999
1000     rc=GetModuleFileName(NULL, argv0, sizeof(argv0));
1001     assert(rc!=0 && rc<sizeof(argv0));
1002     if (GetFileAttributes(argv0)==INVALID_FILE_ATTRIBUTES)
1003     {
1004         strcat(argv0, ".so");
1005         ok(GetFileAttributes(argv0)!=INVALID_FILE_ATTRIBUTES,
1006            "unable to find argv0!\n");
1007     }
1008
1009     GetTempPathA(sizeof(tmpdir)/sizeof(*tmpdir), tmpdir);
1010     assert(GetTempFileNameA(tmpdir, "wt", 0, child_file)!=0);
1011     init_event(child_file);
1012
1013     /* Set up the test files */
1014     testfile=testfiles;
1015     while (*testfile)
1016     {
1017         HANDLE hfile;
1018
1019         sprintf(filename, *testfile, tmpdir);
1020         hfile=CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1021                      FILE_ATTRIBUTE_NORMAL, NULL);
1022         if (hfile==INVALID_HANDLE_VALUE)
1023         {
1024             trace("unable to create '%s': err=%d\n", filename, GetLastError());
1025             assert(0);
1026         }
1027         CloseHandle(hfile);
1028         testfile++;
1029     }
1030
1031     /* Setup the test shortcuts */
1032     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
1033     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
1034     desc.description=NULL;
1035     desc.workdir=NULL;
1036     sprintf(filename, "%s\\test file.shlexec", tmpdir);
1037     desc.path=filename;
1038     desc.pidl=NULL;
1039     desc.arguments="ignored";
1040     desc.showcmd=0;
1041     desc.icon=NULL;
1042     desc.icon_id=0;
1043     desc.hotkey=0;
1044     create_lnk(lnkfile, &desc, 0);
1045
1046     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
1047     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
1048     desc.description=NULL;
1049     desc.workdir=NULL;
1050     desc.path=argv0;
1051     desc.pidl=NULL;
1052     sprintf(params, "shlexec \"%s\" Lnk", child_file);
1053     desc.arguments=params;
1054     desc.showcmd=0;
1055     desc.icon=NULL;
1056     desc.icon_id=0;
1057     desc.hotkey=0;
1058     create_lnk(lnkfile, &desc, 0);
1059
1060     /* Create a basic association suitable for most tests */
1061     create_test_association(".shlexec");
1062     create_test_verb(".shlexec", "Open", 0, "Open \"%1\"");
1063     create_test_verb(".shlexec", "NoQuotes", 0, "NoQuotes %1");
1064     create_test_verb(".shlexec", "LowerL", 0, "LowerL %l");
1065     create_test_verb(".shlexec", "QuotedLowerL", 0, "QuotedLowerL \"%l\"");
1066     create_test_verb(".shlexec", "UpperL", 0, "UpperL %L");
1067     create_test_verb(".shlexec", "QuotedUpperL", 0, "QuotedUpperL \"%L\"");
1068 }
1069
1070 static void cleanup_test(void)
1071 {
1072     char filename[MAX_PATH];
1073     const char* const * testfile;
1074
1075     /* Delete the test files */
1076     testfile=testfiles;
1077     while (*testfile)
1078     {
1079         sprintf(filename, *testfile, tmpdir);
1080         DeleteFile(filename);
1081         testfile++;
1082     }
1083     DeleteFile(child_file);
1084
1085     /* Delete the test association */
1086     delete_test_association(".shlexec");
1087
1088     CloseHandle(hEvent);
1089
1090     CoUninitialize();
1091 }
1092
1093 START_TEST(shlexec)
1094 {
1095
1096     myARGC = winetest_get_mainargs(&myARGV);
1097     if (myARGC >= 3)
1098     {
1099         doChild(myARGC, myARGV);
1100         exit(0);
1101     }
1102
1103     init_test();
1104
1105     test_filename();
1106     test_find_executable();
1107     test_lnks();
1108     test_exes();
1109     test_exes_long();
1110
1111     cleanup_test();
1112 }