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]\n");
 351     if (winetest_debug > 2)
 352         trace("argcA=%d\n", argc);
 353     childPrintf(hFile, "argcA=%d\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\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",   0x20, 33},
 502     {NULL,           "%s\\test file.shlexec.",  0x20, 33},
 503     {NULL,           "%s\\%%nasty%% $file.shlexec", 0x20, 33},
 504     {NULL,           "%s/test file.shlexec",    0x20, 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", 0x20, 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",   0x20, 33},
 518     {"QuotedUpperL", "%s\\test file.shlexec",   0x20, 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, "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     todo_wine ok(rc == SE_ERR_FNF || rc > 32, "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 > 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         rc=(int)FindExecutableA(filename, NULL, command);
 763         if (rc > 32)
 764             rc=33;
 765         if ((test->todo & 0x10)==0)
 766         {
 767             ok(rc==test->rc, "FindExecutable(%s) failed: rc=%d\n", filename, rc);
 768         }
 769         else todo_wine
 770         {
 771             ok(rc==test->rc, "FindExecutable(%s) failed: rc=%d\n", filename, rc);
 772         }
 773         if (rc > 32)
 774         {
 775             if ((test->todo & 0x20)==0)
 776             {
 777                 ok(strcmp(command, argv0) == 0, "FindExecutable(%s) returned command='%s' instead of '%s'\n",
 778                    filename, command, argv0);
 779             }
 780             else todo_wine
 781             {
 782                 ok(strcmp(command, argv0) == 0, "FindExecutable(%s) returned command='%s' instead of '%s'\n",
 783                    filename, command, argv0);
 784             }
 785         }
 786         test++;
 787     }
 788 }
 789
 790
 791 static filename_tests_t lnk_tests[]=
 792 {
 793     /* Pass bad / nonexistent filenames as a parameter */
 794     {NULL, "%s\\nonexistent.shlexec",    0xa, 33},
 795     {NULL, "%s\\nonexistent.noassoc",    0xa, 33},
 796
 797     /* Pass regular paths as a parameter */
 798     {NULL, "%s\\test file.shlexec",      0xa, 33},
 799     {NULL, "%s/%%nasty%% $file.shlexec", 0xa, 33},
 800
 801     /* Pass filenames with no association as a parameter */
 802     {NULL, "%s\\test file.noassoc",      0xa, 33},
 803
 804     {NULL, NULL, 0}
 805 };
 806
 807 static void test_lnks(void)
 808 {
 809     char filename[MAX_PATH];
 810     char params[MAX_PATH];
 811     const filename_tests_t* test;
 812     int rc;
 813
 814     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
 815     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 816     ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 817        GetLastError());
 818     okChildInt("argcA", 5);
 819     okChildString("argvA3", "Open");
 820     sprintf(filename, "%s\\test file.shlexec", tmpdir);
 821     okChildPath("argvA4", filename);
 822
 823     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 824     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 825     ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 826        GetLastError());
 827     okChildInt("argcA", 4);
 828     okChildString("argvA3", "Lnk");
 829
 830     if (dllver.dwMajorVersion>=6)
 831     {
 832         char* c;
 833        /* Recent versions of shell32.dll accept '/'s in shortcut paths.
 834          * Older versions don't or are quite buggy in this regard.
 835          */
 836         sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 837         c=filename;
 838         while (*c)
 839         {
 840             if (*c=='\\')
 841                 *c='/';
 842             c++;
 843         }
 844         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL);
 845         ok(rc > 32, "%s failed: rc=%d err=%d\n", shell_call, rc,
 846            GetLastError());
 847         okChildInt("argcA", 4);
 848         okChildString("argvA3", "Lnk");
 849     }
 850
 851     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
 852     test=lnk_tests;
 853     while (test->basename)
 854     {
 855         params[0]='\"';
 856         sprintf(params+1, test->basename, tmpdir);
 857         strcat(params,"\"");
 858         rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, params,
 859                             NULL);
 860         if (rc > 32)
 861             rc=33;
 862         if ((test->todo & 0x1)==0)
 863         {
 864             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 865                rc, GetLastError());
 866         }
 867         else todo_wine
 868         {
 869             ok(rc==test->rc, "%s failed: rc=%d err=%d\n", shell_call,
 870                rc, GetLastError());
 871         }
 872         if (rc==0)
 873         {
 874             if ((test->todo & 0x2)==0)
 875             {
 876                 okChildInt("argcA", 5);
 877             }
 878             else
 879             {
 880                 okChildInt("argcA", 5);
 881             }
 882             if ((test->todo & 0x4)==0)
 883             {
 884                 okChildString("argvA3", "Lnk");
 885             }
 886             else todo_wine
 887             {
 888                 okChildString("argvA3", "Lnk");
 889             }
 890             sprintf(params, test->basename, tmpdir);
 891             if ((test->todo & 0x8)==0)
 892             {
 893                 okChildPath("argvA4", params);
 894             }
 895             else
 896             {
 897                 okChildPath("argvA4", params);
 898             }
 899         }
 900         test++;
 901     }
 902 }
 903
 904
 905 static void test_exes(void)
 906 {
 907     char filename[MAX_PATH];
 908     char params[1024];
 909     int rc;
 910
 911     sprintf(params, "shlexec \"%s\" Exec", child_file);
 912
 913     /* We need NOZONECHECKS on Win2003 to block a dialog */
 914     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
 915                         NULL);
 916     ok(rc > 32, "%s returned %d\n", shell_call, rc);
 917     okChildInt("argcA", 4);
 918     okChildString("argvA3", "Exec");
 919
 920     sprintf(filename, "%s\\test file.noassoc", tmpdir);
 921     if (CopyFile(argv0, filename, FALSE))
 922     {
 923         rc=shell_execute(NULL, filename, params, NULL);
 924         todo_wine {
 925         ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%d\n", shell_call, rc);
 926         }
 927     }
 928 }
 929
 930 static void test_exes_long(void)
 931 {
 932     char filename[MAX_PATH];
 933     char params[2024];
 934     char longparam[MAX_PATH];
 935     int rc;
 936
 937     for (rc = 0; rc < MAX_PATH; rc++)
 938         longparam[rc]='a'+rc%26;
 939     longparam[MAX_PATH-1]=0;
 940
 941
 942     sprintf(params, "shlexec \"%s\" %s", child_file,longparam);
 943
 944     /* We need NOZONECHECKS on Win2003 to block a dialog */
 945     rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
 946                         NULL);
 947     ok(rc > 32, "%s returned %d\n", shell_call, rc);
 948     okChildInt("argcA", 4);
 949     okChildString("argvA3", longparam);
 950
 951     sprintf(filename, "%s\\test file.noassoc", tmpdir);
 952     if (CopyFile(argv0, filename, FALSE))
 953     {
 954         rc=shell_execute(NULL, filename, params, NULL);
 955         todo_wine {
 956         ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%d\n", shell_call, rc);
 957         }
 958     }
 959 }
 960
 961
 962 static void init_test(void)
 963 {
 964     HMODULE hdll;
 965     HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO*);
 966     char filename[MAX_PATH];
 967     WCHAR lnkfile[MAX_PATH];
 968     char params[1024];
 969     const char* const * testfile;
 970     lnk_desc_t desc;
 971     DWORD rc;
 972     HRESULT r;
 973
 974     hdll=GetModuleHandleA("shell32.dll");
 975     pDllGetVersion=(void*)GetProcAddress(hdll, "DllGetVersion");
 976     if (pDllGetVersion)
 977     {
 978         dllver.cbSize=sizeof(dllver);
 979         pDllGetVersion(&dllver);
 980         trace("major=%d minor=%d build=%d platform=%d\n",
 981               dllver.dwMajorVersion, dllver.dwMinorVersion,
 982               dllver.dwBuildNumber, dllver.dwPlatformID);
 983     }
 984     else
 985     {
 986         memset(&dllver, 0, sizeof(dllver));
 987     }
 988
 989     r = CoInitialize(NULL);
 990     ok(SUCCEEDED(r), "CoInitialize failed (0x%08x)\n", r);
 991     if (!SUCCEEDED(r))
 992         exit(1);
 993
 994     rc=GetModuleFileName(NULL, argv0, sizeof(argv0));
 995     assert(rc!=0 && rc<sizeof(argv0));
 996     if (GetFileAttributes(argv0)==INVALID_FILE_ATTRIBUTES)
 997     {
 998         strcat(argv0, ".so");
 999         ok(GetFileAttributes(argv0)!=INVALID_FILE_ATTRIBUTES,
1000            "unable to find argv0!\n");
1001     }
1002
1003     GetTempPathA(sizeof(tmpdir)/sizeof(*tmpdir), tmpdir);
1004     assert(GetTempFileNameA(tmpdir, "wt", 0, child_file)!=0);
1005     init_event(child_file);
1006
1007     /* Set up the test files */
1008     testfile=testfiles;
1009     while (*testfile)
1010     {
1011         HANDLE hfile;
1012
1013         sprintf(filename, *testfile, tmpdir);
1014         hfile=CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1015                      FILE_ATTRIBUTE_NORMAL, NULL);
1016         if (hfile==INVALID_HANDLE_VALUE)
1017         {
1018             trace("unable to create '%s': err=%d\n", filename, GetLastError());
1019             assert(0);
1020         }
1021         CloseHandle(hfile);
1022         testfile++;
1023     }
1024
1025     /* Setup the test shortcuts */
1026     sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
1027     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
1028     desc.description=NULL;
1029     desc.workdir=NULL;
1030     sprintf(filename, "%s\\test file.shlexec", tmpdir);
1031     desc.path=filename;
1032     desc.pidl=NULL;
1033     desc.arguments="ignored";
1034     desc.showcmd=0;
1035     desc.icon=NULL;
1036     desc.icon_id=0;
1037     desc.hotkey=0;
1038     create_lnk(lnkfile, &desc, 0);
1039
1040     sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
1041     MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
1042     desc.description=NULL;
1043     desc.workdir=NULL;
1044     desc.path=argv0;
1045     desc.pidl=NULL;
1046     sprintf(params, "shlexec \"%s\" Lnk", child_file);
1047     desc.arguments=params;
1048     desc.showcmd=0;
1049     desc.icon=NULL;
1050     desc.icon_id=0;
1051     desc.hotkey=0;
1052     create_lnk(lnkfile, &desc, 0);
1053
1054     /* Create a basic association suitable for most tests */
1055     create_test_association(".shlexec");
1056     create_test_verb(".shlexec", "Open", 0, "Open \"%1\"");
1057     create_test_verb(".shlexec", "NoQuotes", 0, "NoQuotes %1");
1058     create_test_verb(".shlexec", "LowerL", 0, "LowerL %l");
1059     create_test_verb(".shlexec", "QuotedLowerL", 0, "QuotedLowerL \"%l\"");
1060     create_test_verb(".shlexec", "UpperL", 0, "UpperL %L");
1061     create_test_verb(".shlexec", "QuotedUpperL", 0, "QuotedUpperL \"%L\"");
1062 }
1063
1064 static void cleanup_test(void)
1065 {
1066     char filename[MAX_PATH];
1067     const char* const * testfile;
1068
1069     /* Delete the test files */
1070     testfile=testfiles;
1071     while (*testfile)
1072     {
1073         sprintf(filename, *testfile, tmpdir);
1074         DeleteFile(filename);
1075         testfile++;
1076     }
1077     DeleteFile(child_file);
1078
1079     /* Delete the test association */
1080     delete_test_association(".shlexec");
1081
1082     CloseHandle(hEvent);
1083
1084     CoUninitialize();
1085 }
1086
1087 START_TEST(shlexec)
1088 {
1089
1090     myARGC = winetest_get_mainargs(&myARGV);
1091     if (myARGC >= 3)
1092     {
1093         doChild(myARGC, myARGV);
1094         exit(0);
1095     }
1096
1097     init_test();
1098
1099     test_filename();
1100     test_find_executable();
1101     test_lnks();
1102     test_exes();
1103     test_exes_long();
1104
1105     cleanup_test();
1106 }