projects / reactos.git / blob
? search:


5b22387320e3f11fb8d88c448138fa83395539df
[reactos.git] / rostests / winetests / shell32 / 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, BOOL 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, BOOL shouldExist, BOOL 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 = GetFileAttributesA(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, BOOL 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 = DdeInitializeA(&instance, DdeCallback, APPCMD_CLIENTONLY, 0);
709 ok (err == DMLERR_NO_ERROR, "DdeInitialize Error %s\n", GetStringFromError(err));
710
711 /* Create Connection */
712 hszProgman = DdeCreateStringHandleA(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 = DdeInitializeA(&instance, DdeCallback, APPCMD_CLIENTONLY, 0);
734 ok (err == DMLERR_NO_ERROR, "DdeInitialize Error %s\n", GetStringFromError(err));
735
736 /* Create Connection */
737 hszProgman = DdeCreateStringHandleA(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 }
A free Windows-compatible Operating System