git.oblomov.eu Git - wine/blob - dlls/shell32/tests/progman_dde.c

   1 /*
   2  * Unit test of the Program Manager DDE Interfaces
   3  *
   4  * Copyright 2009 Mikey Alexander
   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 /* DDE Program Manager Tests
  22  * - Covers basic CreateGroup, ShowGroup, DeleteGroup, AddItem, and DeleteItem
  23  *   functionality
  24  * - Todo: Handle CommonGroupFlag
  25  *         Better AddItem Tests (Lots of parameters to test)
  26  *         Tests for Invalid Characters in Names / Invalid Parameters
  27  */
  28
  29 #include <stdio.h>
  30 #include <wine/test.h>
  31 #include <winbase.h>
  32 #include "dde.h"
  33 #include "ddeml.h"
  34 #include "winuser.h"
  35 #include "shlobj.h"
  36
  37 /* Timeout on DdeClientTransaction Call */
  38 #define MS_TIMEOUT_VAL 1000
  39 /* # of times to poll for window creation */
  40 #define PDDE_POLL_NUM 150
  41 /* time to sleep between polls */
  42 #define PDDE_POLL_TIME 300
  43
  44 /* Call Info */
  45 #define DDE_TEST_MISC            0x00010000
  46 #define DDE_TEST_CREATEGROUP     0x00020000
  47 #define DDE_TEST_DELETEGROUP     0x00030000
  48 #define DDE_TEST_SHOWGROUP       0x00040000
  49 #define DDE_TEST_ADDITEM         0x00050000
  50 #define DDE_TEST_DELETEITEM      0x00060000
  51 #define DDE_TEST_COMPOUND        0x00070000
  52 #define DDE_TEST_CALLMASK        0x00ff0000
  53
  54 #define DDE_TEST_NUMMASK           0x0000ffff
  55
  56 static HRESULT (WINAPI *pSHGetLocalizedName)(LPCWSTR, LPWSTR, UINT, int *);
  57 static BOOL (WINAPI *pSHGetSpecialFolderPathA)(HWND, LPSTR, int, BOOL);
  58 static BOOL (WINAPI *pReadCabinetState)(CABINETSTATE *, int);
  59
  60 static void init_function_pointers(void)
  61 {
  62     HMODULE hmod;
  63
  64     hmod = GetModuleHandleA("shell32.dll");
  65     pSHGetLocalizedName = (void*)GetProcAddress(hmod, "SHGetLocalizedName");
  66     pSHGetSpecialFolderPathA = (void*)GetProcAddress(hmod, "SHGetSpecialFolderPathA");
  67     pReadCabinetState = (void*)GetProcAddress(hmod, "ReadCabinetState");
  68     if (!pReadCabinetState)
  69         pReadCabinetState = (void*)GetProcAddress(hmod, (LPSTR)651);
  70 }
  71
  72 static BOOL use_common(void)
  73 {
  74     HMODULE hmod;
  75     static BOOL (WINAPI *pIsNTAdmin)(DWORD, LPDWORD);
  76
  77     /* IsNTAdmin() is available on all platforms. */
  78     hmod = LoadLibraryA("advpack.dll");
  79     pIsNTAdmin = (void*)GetProcAddress(hmod, "IsNTAdmin");
  80
  81     if (!pIsNTAdmin(0, NULL))
  82     {
  83         /* We are definitely not an administrator */
  84         FreeLibrary(hmod);
  85         return FALSE;
  86     }
  87     FreeLibrary(hmod);
  88
  89     /* If we end up here we are on NT4+ as Win9x and WinMe don't have the
  90      * notion of administrators (as we need it).
  91      */
  92
  93     /* As of Vista  we should always use the users directory. Tests with the
  94      * real Administrator account on Windows 7 proved this.
  95      *
  96      * FIXME: We need a better way of identifying Vista+ as currently this check
  97      * also covers Wine and we don't know yet which behavior we want to follow.
  98      */
  99     if (pSHGetLocalizedName)
 100         return FALSE;
 101
 102     return TRUE;
 103 }
 104
 105 static BOOL full_title(void)
 106 {
 107     CABINETSTATE cs;
 108
 109     memset(&cs, 0, sizeof(cs));
 110     if (pReadCabinetState)
 111     {
 112         pReadCabinetState(&cs, sizeof(cs));
 113     }
 114     else
 115     {
 116         HKEY key;
 117         DWORD size;
 118
 119         win_skip("ReadCabinetState is not available, reading registry directly\n");
 120         RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", &key);
 121         size = sizeof(cs);
 122         RegQueryValueExA(key, "Settings", NULL, NULL, (LPBYTE)&cs, &size);
 123         RegCloseKey(key);
 124     }
 125
 126     return (cs.fFullPathTitle == -1);
 127 }
 128
 129 static char ProgramsDir[MAX_PATH];
 130
 131 static char Group1Title[MAX_PATH]  = "Group1";
 132 static char Group2Title[MAX_PATH]  = "Group2";
 133 static char Group3Title[MAX_PATH]  = "Group3";
 134 static char StartupTitle[MAX_PATH] = "Startup";
 135
 136 static void init_strings(void)
 137 {
 138     char startup[MAX_PATH];
 139     char commonprograms[MAX_PATH];
 140     char programs[MAX_PATH];
 141
 142     if (pSHGetSpecialFolderPathA)
 143     {
 144         pSHGetSpecialFolderPathA(NULL, programs, CSIDL_PROGRAMS, FALSE);
 145         pSHGetSpecialFolderPathA(NULL, commonprograms, CSIDL_COMMON_PROGRAMS, FALSE);
 146         pSHGetSpecialFolderPathA(NULL, startup, CSIDL_STARTUP, FALSE);
 147     }
 148     else
 149     {
 150         HKEY key;
 151         DWORD size;
 152
 153         /* Older Win9x and NT4 */
 154
 155         RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &key);
 156         size = sizeof(programs);
 157         RegQueryValueExA(key, "Programs", NULL, NULL, (LPBYTE)&programs, &size);
 158         size = sizeof(startup);
 159         RegQueryValueExA(key, "Startup", NULL, NULL, (LPBYTE)&startup, &size);
 160         RegCloseKey(key);
 161
 162         RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &key);
 163         size = sizeof(commonprograms);
 164         RegQueryValueExA(key, "Common Programs", NULL, NULL, (LPBYTE)&commonprograms, &size);
 165         RegCloseKey(key);
 166     }
 167
 168     /* ProgramsDir on Vista+ is always the users one (CSIDL_PROGRAMS). Before Vista
 169      * it depends on whether the user is an administrator (CSIDL_COMMON_PROGRAMS) or
 170      * not (CSIDL_PROGRAMS).
 171      */
 172     if (use_common())
 173         lstrcpyA(ProgramsDir, commonprograms);
 174     else
 175         lstrcpyA(ProgramsDir, programs);
 176
 177     if (full_title())
 178     {
 179         lstrcpyA(Group1Title, ProgramsDir);
 180         lstrcatA(Group1Title, "\\Group1");
 181         lstrcpyA(Group2Title, ProgramsDir);
 182         lstrcatA(Group2Title, "\\Group2");
 183         lstrcpyA(Group3Title, ProgramsDir);
 184         lstrcatA(Group3Title, "\\Group3");
 185
 186         lstrcpyA(StartupTitle, startup);
 187     }
 188     else
 189     {
 190         /* Vista has the nice habit of displaying the full path in English
 191          * and the short one localized. CSIDL_STARTUP on Vista gives us the
 192          * English version so we have to 'translate' this one.
 193          *
 194          * MSDN claims it should be used for files not folders but this one
 195          * suits our purposes just fine.
 196          */
 197         if (pSHGetLocalizedName)
 198         {
 199             WCHAR startupW[MAX_PATH];
 200             WCHAR module[MAX_PATH];
 201             WCHAR module_expanded[MAX_PATH];
 202             WCHAR localized[MAX_PATH];
 203             HRESULT hr;
 204             int id;
 205
 206             MultiByteToWideChar(CP_ACP, 0, startup, -1, startupW, sizeof(startupW)/sizeof(WCHAR));
 207             hr = pSHGetLocalizedName(startupW, module, MAX_PATH, &id);
 208             todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
 209             /* check to be removed when SHGetLocalizedName is implemented */
 210             if (hr == S_OK)
 211             {
 212                 ExpandEnvironmentStringsW(module, module_expanded, MAX_PATH);
 213                 LoadStringW(GetModuleHandleW(module_expanded), id, localized, MAX_PATH);
 214
 215                 WideCharToMultiByte(CP_ACP, 0, localized, -1, StartupTitle, sizeof(StartupTitle), NULL, NULL);
 216             }
 217             else
 218                 lstrcpyA(StartupTitle, (strrchr(startup, '\\') + 1));
 219         }
 220         else
 221         {
 222             lstrcpyA(StartupTitle, (strrchr(startup, '\\') + 1));
 223         }
 224     }
 225 }
 226
 227 static HDDEDATA CALLBACK DdeCallback(UINT type, UINT format, HCONV hConv, HSZ hsz1, HSZ hsz2,
 228                                      HDDEDATA hDDEData, ULONG_PTR data1, ULONG_PTR data2)
 229 {
 230     trace("Callback: type=%i, format=%i\n", type, format);
 231     return NULL;
 232 }
 233
 234 /*
 235  * Encoded String for Error Messages so that inner failures can determine
 236  * what test is failing.  Format is: [Code:TestNum]
 237  */
 238 static const char * GetStringFromTestParams(int testParams)
 239 {
 240     int testNum;
 241     static char testParamString[64];
 242     const char *callId;
 243
 244     testNum = testParams & DDE_TEST_NUMMASK;
 245     switch (testParams & DDE_TEST_CALLMASK)
 246     {
 247     default:
 248     case DDE_TEST_MISC:
 249         callId = "MISC";
 250         break;
 251     case DDE_TEST_CREATEGROUP:
 252         callId = "C_G";
 253         break;
 254     case DDE_TEST_DELETEGROUP:
 255         callId = "D_G";
 256         break;
 257     case DDE_TEST_SHOWGROUP:
 258         callId = "S_G";
 259         break;
 260     case DDE_TEST_ADDITEM:
 261         callId = "A_I";
 262         break;
 263     case DDE_TEST_DELETEITEM:
 264         callId = "D_I";
 265         break;
 266     case DDE_TEST_COMPOUND:
 267         callId = "CPD";
 268         break;
 269     }
 270
 271     sprintf(testParamString, "  [%s:%i]", callId, testNum);
 272     return testParamString;
 273 }
 274
 275 /* Transfer DMLERR's into text readable strings for Error Messages */
 276 #define DMLERR_TO_STR(x) case x: return#x;
 277 static const char * GetStringFromError(UINT err)
 278 {
 279     switch (err)
 280     {
 281     DMLERR_TO_STR(DMLERR_NO_ERROR);
 282     DMLERR_TO_STR(DMLERR_ADVACKTIMEOUT);
 283     DMLERR_TO_STR(DMLERR_BUSY);
 284     DMLERR_TO_STR(DMLERR_DATAACKTIMEOUT);
 285     DMLERR_TO_STR(DMLERR_DLL_NOT_INITIALIZED);
 286     DMLERR_TO_STR(DMLERR_DLL_USAGE);
 287     DMLERR_TO_STR(DMLERR_EXECACKTIMEOUT);
 288     DMLERR_TO_STR(DMLERR_INVALIDPARAMETER);
 289     DMLERR_TO_STR(DMLERR_LOW_MEMORY);
 290     DMLERR_TO_STR(DMLERR_MEMORY_ERROR);
 291     DMLERR_TO_STR(DMLERR_NOTPROCESSED);
 292     DMLERR_TO_STR(DMLERR_NO_CONV_ESTABLISHED);
 293     DMLERR_TO_STR(DMLERR_POKEACKTIMEOUT);
 294     DMLERR_TO_STR(DMLERR_POSTMSG_FAILED);
 295     DMLERR_TO_STR(DMLERR_REENTRANCY);
 296     DMLERR_TO_STR(DMLERR_SERVER_DIED);
 297     DMLERR_TO_STR(DMLERR_SYS_ERROR);
 298     DMLERR_TO_STR(DMLERR_UNADVACKTIMEOUT);
 299     DMLERR_TO_STR(DMLERR_UNFOUND_QUEUE_ID);
 300     default:
 301         return "Unknown DML Error";
 302     }
 303 }
 304
 305 /* Helper Function to Transfer DdeGetLastError into a String */
 306 static const char * GetDdeLastErrorStr(DWORD instance)
 307 {
 308     UINT err = DdeGetLastError(instance);
 309
 310     return GetStringFromError(err);
 311 }
 312
 313 /* Execute a Dde Command and return the error & result */
 314 /* Note: Progman DDE always returns a pointer to 0x00000001 on a successful result */
 315 static void DdeExecuteCommand(DWORD instance, HCONV hConv, const char *strCmd, HDDEDATA *hData, UINT *err, int testParams)
 316 {
 317     HDDEDATA command;
 318
 319     command = DdeCreateDataHandle(instance, (LPBYTE) strCmd, strlen(strCmd)+1, 0, 0L, 0, 0);
 320     ok (command != NULL, "DdeCreateDataHandle Error %s.%s\n",
 321         GetDdeLastErrorStr(instance), GetStringFromTestParams(testParams));
 322     *hData = DdeClientTransaction((void *) command,
 323                                   -1,
 324                                   hConv,
 325                                   0,
 326                                   0,
 327                                   XTYP_EXECUTE,
 328                                   MS_TIMEOUT_VAL,
 329                                   NULL);
 330
 331     /* hData is technically a pointer, but for Program Manager,
 332      * it is NULL (error) or 1 (success)
 333      * TODO: Check other versions of Windows to verify 1 is returned.
 334      * While it is unlikely that anyone is actually testing that the result is 1
 335      * if all versions of windows return 1, Wine should also.
 336      */
 337     if (*hData == NULL)
 338     {
 339         *err = DdeGetLastError(instance);
 340     }
 341     else
 342     {
 343         *err = DMLERR_NO_ERROR;
 344         todo_wine
 345         {
 346             ok(*hData == (HDDEDATA) 1, "Expected HDDEDATA Handle == 1, actually %p.%s\n",
 347                *hData, GetStringFromTestParams(testParams));
 348         }
 349     }
 350     DdeFreeDataHandle(command);
 351 }
 352
 353 /*
 354  * Check if Window is onscreen with the appropriate name.
 355  *
 356  * Windows are not created synchronously.  So we do not know
 357  * when and if the window will be created/shown on screen.
 358  * This function implements a polling mechanism to determine
 359  * creation.
 360  * A more complicated method would be to use SetWindowsHookEx.
 361  * Since polling worked fine in my testing, no reason to implement
 362  * the other.  Comments about other methods of determining when
 363  * window creation happened were not encouraging (not including
 364  * SetWindowsHookEx).
 365  */
 366 static void CheckWindowCreated(const char *winName, int closeWindow, int testParams)
 367 {
 368     HWND window = NULL;
 369     int i;
 370
 371     /* Poll for Window Creation */
 372     for (i = 0; window == NULL && i < PDDE_POLL_NUM; i++)
 373     {
 374         Sleep(PDDE_POLL_TIME);
 375         window = FindWindowA(NULL, winName);
 376     }
 377     ok (window != NULL, "Window \"%s\" was not created in %i seconds - assumed failure.%s\n",
 378         winName, PDDE_POLL_NUM*PDDE_POLL_TIME/1000, GetStringFromTestParams(testParams));
 379
 380     /* Close Window as desired. */
 381     if (window != NULL && closeWindow)
 382     {
 383         SendMessageA(window, WM_SYSCOMMAND, SC_CLOSE, 0);
 384     }
 385 }
 386
 387 /* Check for Existence (or non-existence) of a file or group
 388  *   When testing for existence of a group, groupName is not needed
 389  */
 390 static void CheckFileExistsInProgramGroups(const char *nameToCheck, int shouldExist, int isGroup,
 391                                            const char *groupName, int testParams)
 392 {
 393     char path[MAX_PATH];
 394     DWORD attributes;
 395     int len;
 396
 397     lstrcpyA(path, ProgramsDir);
 398
 399     len = strlen(path) + strlen(nameToCheck)+1;
 400     if (groupName != NULL)
 401     {
 402         len += strlen(groupName)+1;
 403     }
 404     ok (len <= MAX_PATH, "Path Too Long.%s\n", GetStringFromTestParams(testParams));
 405     if (len <= MAX_PATH)
 406     {
 407         if (groupName != NULL)
 408         {
 409             strcat(path, "\\");
 410             strcat(path, groupName);
 411         }
 412         strcat(path, "\\");
 413         strcat(path, nameToCheck);
 414         attributes = GetFileAttributes(path);
 415         if (!shouldExist)
 416         {
 417             ok (attributes == INVALID_FILE_ATTRIBUTES , "File exists and shouldn't %s.%s\n",
 418                 path, GetStringFromTestParams(testParams));
 419         } else {
 420             if (attributes == INVALID_FILE_ATTRIBUTES)
 421             {
 422                 ok (FALSE, "Created File %s doesn't exist.%s\n", path, GetStringFromTestParams(testParams));
 423             } else if (isGroup) {
 424                 ok (attributes & FILE_ATTRIBUTE_DIRECTORY, "%s is not a folder (attr=%x).%s\n",
 425                     path, attributes, GetStringFromTestParams(testParams));
 426             } else {
 427                 ok (attributes & FILE_ATTRIBUTE_ARCHIVE, "Created File %s has wrong attributes (%x).%s\n",
 428                     path, attributes, GetStringFromTestParams(testParams));
 429             }
 430         }
 431     }
 432 }
 433
 434 /* Create Group Test.
 435  *   command and expected_result.
 436  *   if expected_result is DMLERR_NO_ERROR, test
 437  *        1. group was created
 438  *        2. window is open
 439  */
 440 static void CreateGroupTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 441                             const char *groupName, const char *windowTitle, int testParams)
 442 {
 443     HDDEDATA hData;
 444     UINT error;
 445
 446     /* Execute Command & Check Result */
 447     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 448     todo_wine
 449     {
 450         ok (expected_result == error, "CreateGroup %s: Expected Error %s, received %s.%s\n",
 451             groupName, GetStringFromError(expected_result), GetStringFromError(error),
 452             GetStringFromTestParams(testParams));
 453     }
 454
 455     /* No Error */
 456     if (error == DMLERR_NO_ERROR)
 457     {
 458
 459         /* Check if Group Now Exists */
 460         CheckFileExistsInProgramGroups(groupName, TRUE, TRUE, NULL, testParams);
 461         /* Check if Window is Open (polling) */
 462         CheckWindowCreated(windowTitle, TRUE, testParams);
 463     }
 464 }
 465
 466 /* Show Group Test.
 467  *   DDE command, expected_result, and the group name to check for existence
 468  *   if expected_result is DMLERR_NO_ERROR, test
 469  *        1. window is open
 470  */
 471 static void ShowGroupTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 472                           const char *groupName, const char *windowTitle, int closeAfterShowing, int testParams)
 473 {
 474     HDDEDATA hData;
 475     UINT error;
 476
 477     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 478 /* todo_wine...  Is expected to fail, wine stubbed functions DO fail */
 479 /* TODO REMOVE THIS CODE!!! */
 480     if (expected_result == DMLERR_NOTPROCESSED)
 481     {
 482         ok (expected_result == error, "ShowGroup %s: Expected Error %s, received %s.%s\n",
 483             groupName, GetStringFromError(expected_result), GetStringFromError(error),
 484             GetStringFromTestParams(testParams));
 485     } else {
 486         todo_wine
 487         {
 488             ok (expected_result == error, "ShowGroup %s: Expected Error %s, received %s.%s\n",
 489                 groupName, GetStringFromError(expected_result), GetStringFromError(error),
 490                 GetStringFromTestParams(testParams));
 491         }
 492     }
 493
 494     if (error == DMLERR_NO_ERROR)
 495     {
 496         /* Check if Window is Open (polling) */
 497         CheckWindowCreated(windowTitle, closeAfterShowing, testParams);
 498     }
 499 }
 500
 501 /* Delete Group Test.
 502  *   DDE command, expected_result, and the group name to check for existence
 503  *   if expected_result is DMLERR_NO_ERROR, test
 504  *        1. group does not exist
 505  */
 506 static void DeleteGroupTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 507                             const char *groupName, int testParams)
 508 {
 509     HDDEDATA hData;
 510     UINT error;
 511
 512     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 513     todo_wine
 514     {
 515         ok (expected_result == error, "DeleteGroup %s: Expected Error %s, received %s.%s\n",
 516             groupName, GetStringFromError(expected_result), GetStringFromError(error),
 517             GetStringFromTestParams(testParams));
 518     }
 519
 520     if (error == DMLERR_NO_ERROR)
 521     {
 522         /* Check that Group does not exist */
 523         CheckFileExistsInProgramGroups(groupName, FALSE, TRUE, NULL, testParams);
 524     }
 525 }
 526
 527 /* Add Item Test
 528  *   DDE command, expected result, and group and file name where it should exist.
 529  *   checks to make sure error code matches expected error code
 530  *   checks to make sure item exists if successful
 531  */
 532 static void AddItemTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 533                         const char *fileName, const char *groupName, int testParams)
 534 {
 535     HDDEDATA hData;
 536     UINT error;
 537
 538     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 539     todo_wine
 540     {
 541         ok (expected_result == error, "AddItem %s: Expected Error %s, received %s.%s\n",
 542             fileName, GetStringFromError(expected_result), GetStringFromError(error),
 543             GetStringFromTestParams(testParams));
 544     }
 545
 546     if (error == DMLERR_NO_ERROR)
 547     {
 548         /* Check that File exists */
 549         CheckFileExistsInProgramGroups(fileName, TRUE, FALSE, groupName, testParams);
 550     }
 551 }
 552
 553 /* Delete Item Test.
 554  *   DDE command, expected result, and group and file name where it should exist.
 555  *   checks to make sure error code matches expected error code
 556  *   checks to make sure item does not exist if successful
 557  */
 558 static void DeleteItemTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 559                            const char *fileName, const char *groupName, int testParams)
 560 {
 561     HDDEDATA hData;
 562     UINT error;
 563
 564     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 565     todo_wine
 566     {
 567         ok (expected_result == error, "DeleteItem %s: Expected Error %s, received %s.%s\n",
 568             fileName, GetStringFromError(expected_result), GetStringFromError(error),
 569             GetStringFromTestParams(testParams));
 570     }
 571
 572     if (error == DMLERR_NO_ERROR)
 573     {
 574         /* Check that File does not exist */
 575         CheckFileExistsInProgramGroups(fileName, FALSE, FALSE, groupName, testParams);
 576     }
 577 }
 578
 579 /* Compound Command Test.
 580  *   not really generic, assumes command of the form:
 581  *          [CreateGroup ...][AddItem ...][AddItem ...]
 582  *   All samples I've seen using Compound were of this form (CreateGroup,
 583  *   AddItems) so this covers minimum expected functionality.
 584  */
 585 static void CompoundCommandTest(DWORD instance, HCONV hConv, const char *command, UINT expected_result,
 586                                 const char *groupName, const char *windowTitle, const char *fileName1,
 587                                 const char *fileName2, int testParams)
 588 {
 589     HDDEDATA hData;
 590     UINT error;
 591
 592     DdeExecuteCommand(instance, hConv, command, &hData, &error, testParams);
 593     todo_wine
 594     {
 595         ok (expected_result == error, "Compound String %s: Expected Error %s, received %s.%s\n",
 596             command, GetStringFromError(expected_result), GetStringFromError(error),
 597             GetStringFromTestParams(testParams));
 598     }
 599
 600     if (error == DMLERR_NO_ERROR)
 601     {
 602         /* Check that File exists */
 603         CheckFileExistsInProgramGroups(groupName, TRUE, TRUE, NULL, testParams);
 604         CheckWindowCreated(windowTitle, FALSE, testParams);
 605         CheckFileExistsInProgramGroups(fileName1, TRUE, FALSE, groupName, testParams);
 606         CheckFileExistsInProgramGroups(fileName2, TRUE, FALSE, groupName, testParams);
 607     }
 608 }
 609
 610 static void CreateAddItemText(char *itemtext, const char *cmdline, const char *name)
 611 {
 612     lstrcpyA(itemtext, "[AddItem(");
 613     lstrcatA(itemtext, cmdline);
 614     lstrcatA(itemtext, ",");
 615     lstrcatA(itemtext, name);
 616     lstrcatA(itemtext, ")]");
 617 }
 618
 619 /* 1st set of tests */
 620 static int DdeTestProgman(DWORD instance, HCONV hConv)
 621 {
 622     HDDEDATA hData;
 623     UINT error;
 624     int testnum;
 625     char temppath[MAX_PATH];
 626     char f1g1[MAX_PATH], f2g1[MAX_PATH], f3g1[MAX_PATH], f1g3[MAX_PATH], f2g3[MAX_PATH];
 627     char itemtext[MAX_PATH + 20];
 628     char comptext[2 * (MAX_PATH + 20) + 21];
 629
 630     testnum = 1;
 631     /* Invalid Command */
 632     DdeExecuteCommand(instance, hConv, "[InvalidCommand()]", &hData, &error, DDE_TEST_MISC|testnum++);
 633     ok (error == DMLERR_NOTPROCESSED, "InvalidCommand(), expected error %s, received %s.\n",
 634         GetStringFromError(DMLERR_NOTPROCESSED), GetStringFromError(error));
 635
 636     /* On Vista+ the files have to exist when adding a link */
 637     GetTempPathA(MAX_PATH, temppath);
 638     GetTempFileNameA(temppath, "dde", 0, f1g1);
 639     GetTempFileNameA(temppath, "dde", 0, f2g1);
 640     GetTempFileNameA(temppath, "dde", 0, f3g1);
 641     GetTempFileNameA(temppath, "dde", 0, f1g3);
 642     GetTempFileNameA(temppath, "dde", 0, f2g3);
 643
 644     /* CreateGroup Tests (including AddItem, DeleteItem) */
 645     CreateGroupTest(instance, hConv, "[CreateGroup(Group1)]", DMLERR_NO_ERROR, "Group1", Group1Title, DDE_TEST_CREATEGROUP|testnum++);
 646     CreateAddItemText(itemtext, f1g1, "f1g1Name");
 647     AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f1g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
 648     CreateAddItemText(itemtext, f2g1, "f2g1Name");
 649     AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f2g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
 650     DeleteItemTest(instance, hConv, "[DeleteItem(f2g1Name)]", DMLERR_NO_ERROR, "f2g1Name.lnk", "Group1", DDE_TEST_DELETEITEM|testnum++);
 651     CreateAddItemText(itemtext, f3g1, "f3g1Name");
 652     AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f3g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
 653     CreateGroupTest(instance, hConv, "[CreateGroup(Group2)]", DMLERR_NO_ERROR, "Group2", Group2Title, DDE_TEST_CREATEGROUP|testnum++);
 654     /* Create Group that already exists - same instance */
 655     CreateGroupTest(instance, hConv, "[CreateGroup(Group1)]", DMLERR_NO_ERROR, "Group1", Group1Title, DDE_TEST_CREATEGROUP|testnum++);
 656
 657     /* ShowGroup Tests */
 658     ShowGroupTest(instance, hConv, "[ShowGroup(Group1)]", DMLERR_NOTPROCESSED, "Group1", Group1Title, TRUE, DDE_TEST_SHOWGROUP|testnum++);
 659     DeleteItemTest(instance, hConv, "[DeleteItem(f3g1Name)]", DMLERR_NO_ERROR, "f3g1Name.lnk", "Group1", DDE_TEST_DELETEITEM|testnum++);
 660     ShowGroupTest(instance, hConv, "[ShowGroup(Startup,0)]", DMLERR_NO_ERROR, "Startup", StartupTitle, TRUE, DDE_TEST_SHOWGROUP|testnum++);
 661     ShowGroupTest(instance, hConv, "[ShowGroup(Group1,0)]", DMLERR_NO_ERROR, "Group1", Group1Title, FALSE, DDE_TEST_SHOWGROUP|testnum++);
 662
 663     /* DeleteGroup Test - Note that Window is Open for this test */
 664     DeleteGroupTest(instance, hConv, "[DeleteGroup(Group1)]", DMLERR_NO_ERROR, "Group1", DDE_TEST_DELETEGROUP|testnum++);
 665
 666     /* Compound Execute String Command */
 667     lstrcpyA(comptext, "[CreateGroup(Group3)]");
 668     CreateAddItemText(itemtext, f1g3, "f1g3Name");
 669     lstrcatA(comptext, itemtext);
 670     CreateAddItemText(itemtext, f2g3, "f2g3Name");
 671     lstrcatA(comptext, itemtext);
 672     CompoundCommandTest(instance, hConv, comptext, DMLERR_NO_ERROR, "Group3", Group3Title, "f1g3Name.lnk", "f2g3Name.lnk", DDE_TEST_COMPOUND|testnum++);
 673
 674     DeleteGroupTest(instance, hConv, "[DeleteGroup(Group3)]", DMLERR_NO_ERROR, "Group3", DDE_TEST_DELETEGROUP|testnum++);
 675
 676     /* Full Parameters of Add Item */
 677     /* AddItem(CmdLine[,Name[,IconPath[,IconIndex[,xPos,yPos[,DefDir[,HotKey[,fMinimize[fSeparateSpace]]]]]]]) */
 678
 679     DeleteFileA(f1g1);
 680     DeleteFileA(f2g1);
 681     DeleteFileA(f3g1);
 682     DeleteFileA(f1g3);
 683     DeleteFileA(f2g3);
 684
 685     return testnum;
 686 }
 687
 688 /* 2nd set of tests - 2nd connection */
 689 static void DdeTestProgman2(DWORD instance, HCONV hConv, int testnum)
 690 {
 691     /* Create Group that already exists on a separate connection */
 692     CreateGroupTest(instance, hConv, "[CreateGroup(Group2)]", DMLERR_NO_ERROR, "Group2", Group2Title, DDE_TEST_CREATEGROUP|testnum++);
 693     DeleteGroupTest(instance, hConv, "[DeleteGroup(Group2)]", DMLERR_NO_ERROR, "Group2", DDE_TEST_DELETEGROUP|testnum++);
 694 }
 695
 696 START_TEST(progman_dde)
 697 {
 698     DWORD instance = 0;
 699     UINT err;
 700     HSZ hszProgman;
 701     HCONV hConv;
 702     int testnum;
 703
 704     init_function_pointers();
 705     init_strings();
 706
 707     /* Initialize DDE Instance */
 708     err = DdeInitialize(&instance, DdeCallback, APPCMD_CLIENTONLY, 0);
 709     ok (err == DMLERR_NO_ERROR, "DdeInitialize Error %s\n", GetStringFromError(err));
 710
 711     /* Create Connection */
 712     hszProgman = DdeCreateStringHandle(instance, "PROGMAN", CP_WINANSI);
 713     ok (hszProgman != NULL, "DdeCreateStringHandle Error %s\n", GetDdeLastErrorStr(instance));
 714     hConv = DdeConnect(instance, hszProgman, hszProgman, NULL);
 715     ok (DdeFreeStringHandle(instance, hszProgman), "DdeFreeStringHandle failure\n");
 716     /* Seeing failures on early versions of Windows Connecting to progman, exit if connection fails */
 717     if (hConv == NULL)
 718     {
 719         ok (DdeUninitialize(instance), "DdeUninitialize failed\n");
 720         return;
 721     }
 722
 723     /* Run Tests */
 724     testnum = DdeTestProgman(instance, hConv);
 725
 726     /* Cleanup & Exit */
 727     ok (DdeDisconnect(hConv), "DdeDisonnect Error %s\n", GetDdeLastErrorStr(instance));
 728     ok (DdeUninitialize(instance), "DdeUninitialize failed\n");
 729
 730     /* 2nd Instance (Followup Tests) */
 731     /* Initialize DDE Instance */
 732     instance = 0;
 733     err = DdeInitialize(&instance, DdeCallback, APPCMD_CLIENTONLY, 0);
 734     ok (err == DMLERR_NO_ERROR, "DdeInitialize Error %s\n", GetStringFromError(err));
 735
 736     /* Create Connection */
 737     hszProgman = DdeCreateStringHandle(instance, "PROGMAN", CP_WINANSI);
 738     ok (hszProgman != NULL, "DdeCreateStringHandle Error %s\n", GetDdeLastErrorStr(instance));
 739     hConv = DdeConnect(instance, hszProgman, hszProgman, NULL);
 740     ok (hConv != NULL, "DdeConnect Error %s\n", GetDdeLastErrorStr(instance));
 741     ok (DdeFreeStringHandle(instance, hszProgman), "DdeFreeStringHandle failure\n");
 742
 743     /* Run Tests */
 744     DdeTestProgman2(instance, hConv, testnum);
 745
 746     /* Cleanup & Exit */
 747     ok (DdeDisconnect(hConv), "DdeDisonnect Error %s\n", GetDdeLastErrorStr(instance));
 748     ok (DdeUninitialize(instance), "DdeUninitialize failed\n");
 749 }