1 /*
2 * comctl32 MRU unit tests
3 *
4 * Copyright (C) 2004 Jon Griffiths <jon_p_griffiths@yahoo.com>
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 #include <stdarg.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winuser.h"
26 #include "winnls.h"
27 #include "winreg.h"
28 #include "commctrl.h"
29 #include "shlwapi.h"
30
31 #include "wine/test.h"
32
33 /* Keys for testing MRU functions */
34 #define REG_TEST_BASEKEYA "Software\\Wine"
35 #define REG_TEST_BASESUBKEYA "Test"
36 #define REG_TEST_KEYA REG_TEST_BASEKEYA "\\" REG_TEST_BASESUBKEYA
37 #define REG_TEST_SUBKEYA "MRUTest"
38 #define REG_TEST_FULLKEY REG_TEST_KEYA "\\" REG_TEST_SUBKEYA
39
40 /* Undocumented MRU structures & functions */
41 typedef struct tagCREATEMRULISTA
42 {
43 DWORD cbSize;
44 DWORD nMaxItems;
45 DWORD dwFlags;
46 HKEY hKey;
47 LPCSTR lpszSubKey;
48 PROC lpfnCompare;
49 } CREATEMRULISTA, *LPCREATEMRULISTA;
50
51 #define MRUF_STRING_LIST 0
52 #define MRUF_BINARY_LIST 1
53 #define MRUF_DELAYED_SAVE 2
54
55 #define LIST_SIZE 3 /* Max entries for each mru */
56
57 static CREATEMRULISTA mruA =
58 {
59 sizeof(CREATEMRULISTA),
60 LIST_SIZE,
61 0,
62 NULL,
63 REG_TEST_SUBKEYA,
64 NULL
65 };
66
67 static HMODULE hComctl32;
68 static HANDLE (WINAPI *pCreateMRUListA)(LPCREATEMRULISTA);
69 static void (WINAPI *pFreeMRUList)(HANDLE);
70 static INT (WINAPI *pAddMRUStringA)(HANDLE,LPCSTR);
71 static INT (WINAPI *pEnumMRUList)(HANDLE,INT,LPVOID,DWORD);
72 static INT (WINAPI *pEnumMRUListW)(HANDLE,INT,LPVOID,DWORD);
73 static HANDLE (WINAPI *pCreateMRUListLazyA)(LPCREATEMRULISTA, DWORD, DWORD, DWORD);
74 static INT (WINAPI *pFindMRUData)(HANDLE, LPCVOID, DWORD, LPINT);
75 static INT (WINAPI *pAddMRUData)(HANDLE, LPCVOID, DWORD);
76 /*
77 static INT (WINAPI *pFindMRUStringA)(HANDLE,LPCSTR,LPINT);
78 */
79
80
81 static void InitPointers(void)
82 {
83 pCreateMRUListA = (void*)GetProcAddress(hComctl32,(LPCSTR)151);
84 pFreeMRUList = (void*)GetProcAddress(hComctl32,(LPCSTR)152);
85 pAddMRUStringA = (void*)GetProcAddress(hComctl32,(LPCSTR)153);
86 pEnumMRUList = (void*)GetProcAddress(hComctl32,(LPCSTR)154);
87 pCreateMRUListLazyA = (void*)GetProcAddress(hComctl32,(LPCSTR)157);
88 pAddMRUData = (void*)GetProcAddress(hComctl32,(LPCSTR)167);
89 pFindMRUData = (void*)GetProcAddress(hComctl32,(LPCSTR)169);
90 pEnumMRUListW = (void*)GetProcAddress(hComctl32,(LPCSTR)403);
91 }
92
93 /* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
94 static LSTATUS mru_RegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
95 {
96 LONG ret;
97 DWORD dwMaxSubkeyLen, dwMaxValueLen;
98 DWORD dwMaxLen, dwSize;
99 CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
100 HKEY hSubKey = hKey;
101
102 if(lpszSubKey)
103 {
104 ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
105 if (ret) return ret;
106 }
107
108 /* Get highest length for keys, values */
109 ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
110 &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
111 if (ret) goto cleanup;
112
113 dwMaxSubkeyLen++;
114 dwMaxValueLen++;
115 dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
116 if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR))
117 {
118 /* Name too big: alloc a buffer for it */
119 if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR))))
120 {
121 ret = ERROR_NOT_ENOUGH_MEMORY;
122 goto cleanup;
123 }
124 }
125
126
127 /* Recursively delete all the subkeys */
128 while (TRUE)
129 {
130 dwSize = dwMaxLen;
131 if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
132 NULL, NULL, NULL)) break;
133
134 ret = mru_RegDeleteTreeA(hSubKey, lpszName);
135 if (ret) goto cleanup;
136 }
137
138 if (lpszSubKey)
139 ret = RegDeleteKeyA(hKey, lpszSubKey);
140 else
141 while (TRUE)
142 {
143 dwSize = dwMaxLen;
144 if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
145 NULL, NULL, NULL, NULL)) break;
146
147 ret = RegDeleteValueA(hKey, lpszName);
148 if (ret) goto cleanup;
149 }
150
151 cleanup:
152 /* Free buffer if allocated */
153 if (lpszName != szNameBuf)
154 HeapFree( GetProcessHeap(), 0, lpszName);
155 if(lpszSubKey)
156 RegCloseKey(hSubKey);
157 return ret;
158 }
159
160 static BOOL create_reg_entries(void)
161 {
162 HKEY hKey = NULL;
163
164 ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_FULLKEY, &hKey),
165 "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
166 if (!hKey) return FALSE;
167 RegCloseKey(hKey);
168 return TRUE;
169 }
170
171 static void delete_reg_entries(void)
172 {
173 HKEY hKey;
174
175 if (RegOpenKeyExA(HKEY_CURRENT_USER, REG_TEST_BASEKEYA, 0, KEY_ALL_ACCESS,
176 &hKey))
177 return;
178 mru_RegDeleteTreeA(hKey, REG_TEST_BASESUBKEYA);
179 RegCloseKey(hKey);
180 }
181
182 static void check_reg_entries(const char *mrulist, const char**items)
183 {
184 char buff[128];
185 HKEY hKey = NULL;
186 DWORD type, size, ret;
187 unsigned int i;
188
189 ok(!RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_FULLKEY, &hKey),
190 "Couldn't open test key \"%s\"\n", REG_TEST_FULLKEY);
191 if (!hKey) return;
192
193 type = REG_SZ;
194 size = sizeof(buff);
195 buff[0] = '\0';
196 ret = RegQueryValueExA(hKey, "MRUList", NULL, &type, (LPBYTE)buff, &size);
197
198 ok(!ret && buff[0], "Checking MRU: got %d from RegQueryValueExW\n", ret);
199 if(ret || !buff[0]) return;
200
201 ok(strcmp(buff, mrulist) == 0, "Checking MRU: Expected list %s, got %s\n",
202 mrulist, buff);
203 if(strcmp(buff, mrulist)) return;
204
205 for (i = 0; i < strlen(mrulist); i++)
206 {
207 char name[2];
208 name[0] = mrulist[i];
209 name[1] = '\0';
210 type = REG_SZ;
211 size = sizeof(buff);
212 buff[0] = '\0';
213 ret = RegQueryValueExA(hKey, name, NULL, &type, (LPBYTE)buff, &size);
214 ok(!ret && buff[0],
215 "Checking MRU item %d ('%c'): got %d from RegQueryValueExW\n",
216 i, mrulist[i], ret);
217 if(ret || !buff[0]) return;
218 ok(!strcmp(buff, items[mrulist[i]-'a']),
219 "Checking MRU item %d ('%c'): expected \"%s\", got \"%s\"\n",
220 i, mrulist[i], buff, items[mrulist[i] - 'a']);
221 }
222 }
223
224 static INT CALLBACK cmp_mru_strA(LPCVOID data1, LPCVOID data2)
225 {
226 return lstrcmpiA(data1, data2);
227 }
228
229 static HANDLE create_mruA(HKEY hKey, DWORD flags, PROC cmp)
230 {
231 mruA.dwFlags = flags;
232 mruA.lpfnCompare = cmp;
233 mruA.hKey = hKey;
234
235 SetLastError(0);
236 return pCreateMRUListA(&mruA);
237 }
238
239 static void test_MRUListA(void)
240 {
241 const char *checks[LIST_SIZE+1];
242 HANDLE hMRU;
243 HKEY hKey;
244 INT iRet;
245
246 if (!pCreateMRUListA || !pFreeMRUList || !pAddMRUStringA || !pEnumMRUList)
247 {
248 skip("MRU entry points not found\n");
249 return;
250 }
251
252 if (0)
253 {
254 /* Create (NULL) - crashes native */
255 hMRU = pCreateMRUListA(NULL);
256 }
257
258 /* Create (size too small) */
259 mruA.cbSize = sizeof(mruA) - 2;
260 hMRU = create_mruA(NULL, MRUF_STRING_LIST, (PROC)cmp_mru_strA);
261 ok (!hMRU && !GetLastError(),
262 "CreateMRUListA(too small) expected NULL,0 got %p,%d\n",
263 hMRU, GetLastError());
264 mruA.cbSize = sizeof(mruA);
265
266 /* Create (size too big) */
267 mruA.cbSize = sizeof(mruA) + 2;
268 hMRU = create_mruA(NULL, MRUF_STRING_LIST, (PROC)cmp_mru_strA);
269 ok (!hMRU && !GetLastError(),
270 "CreateMRUListA(too big) expected NULL,0 got %p,%d\n",
271 hMRU, GetLastError());
272 mruA.cbSize = sizeof(mruA);
273
274 /* Create (NULL hKey) */
275 hMRU = create_mruA(NULL, MRUF_STRING_LIST, (PROC)cmp_mru_strA);
276 ok (!hMRU && !GetLastError(),
277 "CreateMRUListA(NULL key) expected NULL,0 got %p,%d\n",
278 hMRU, GetLastError());
279
280 /* Create (NULL name) */
281 mruA.lpszSubKey = NULL;
282 hMRU = create_mruA(NULL, MRUF_STRING_LIST, (PROC)cmp_mru_strA);
283 ok (!hMRU && !GetLastError(),
284 "CreateMRUListA(NULL name) expected NULL,0 got %p,%d\n",
285 hMRU, GetLastError());
286 mruA.lpszSubKey = REG_TEST_SUBKEYA;
287
288 /* Create a string MRU */
289 ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
290 "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
291 if (!hKey)
292 return;
293 hMRU = create_mruA(hKey, MRUF_STRING_LIST, (PROC)cmp_mru_strA);
294 ok(hMRU && !GetLastError(),
295 "CreateMRUListA(string) expected non-NULL,0 got %p,%d\n",
296 hMRU, GetLastError());
297
298 if (hMRU)
299 {
300 char buffer[255];
301 checks[0] = "Test 1";
302 checks[1] = "Test 2";
303 checks[2] = "Test 3";
304 checks[3] = "Test 4";
305
306 /* Add (NULL list) */
307 SetLastError(0);
308 iRet = pAddMRUStringA(NULL, checks[0]);
309 ok(iRet == -1 && !GetLastError(),
310 "AddMRUStringA(NULL list) expected -1,0 got %d,%d\n",
311 iRet, GetLastError());
312
313 /* Add (NULL string) */
314 if (0)
315 {
316 /* Some native versions crash when passed NULL or fail to SetLastError() */
317 SetLastError(0);
318 iRet = pAddMRUStringA(hMRU, NULL);
319 ok(iRet == 0 && GetLastError() == ERROR_INVALID_PARAMETER,
320 "AddMRUStringA(NULL str) expected 0,ERROR_INVALID_PARAMETER got %d,%d\n",
321 iRet, GetLastError());
322 }
323
324 /* Add 3 strings. Check the registry is correct after each add */
325 SetLastError(0);
326 iRet = pAddMRUStringA(hMRU, checks[0]);
327 ok(iRet == 0 && !GetLastError(),
328 "AddMRUStringA(1) expected 0,0 got %d,%d\n",
329 iRet, GetLastError());
330 check_reg_entries("a", checks);
331
332 SetLastError(0);
333 iRet = pAddMRUStringA(hMRU, checks[1]);
334 ok(iRet == 1 && !GetLastError(),
335 "AddMRUStringA(2) expected 1,0 got %d,%d\n",
336 iRet, GetLastError());
337 check_reg_entries("ba", checks);
338
339 SetLastError(0);
340 iRet = pAddMRUStringA(hMRU, checks[2]);
341 ok(iRet == 2 && !GetLastError(),
342 "AddMRUStringA(2) expected 2,0 got %d,%d\n",
343 iRet, GetLastError());
344 check_reg_entries("cba", checks);
345
346 /* Add a duplicate of the 2nd string - it should move to the front,
347 * but keep the same index in the registry.
348 */
349 SetLastError(0);
350 iRet = pAddMRUStringA(hMRU, checks[1]);
351 ok(iRet == 1 && !GetLastError(),
352 "AddMRUStringA(re-add 1) expected 1,0 got %d,%d\n",
353 iRet, GetLastError());
354 check_reg_entries("bca", checks);
355
356 /* Add a new string - replaces the oldest string + moves to the front */
357 SetLastError(0);
358 iRet = pAddMRUStringA(hMRU, checks[3]);
359 ok(iRet == 0 && !GetLastError(),
360 "AddMRUStringA(add new) expected 0,0 got %d,%d\n",
361 iRet, GetLastError());
362 checks[0] = checks[3];
363 check_reg_entries("abc", checks);
364
365 /* NULL buffer = get list size */
366 iRet = pEnumMRUList(hMRU, 0, NULL, 0);
367 ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
368
369 /* negative item pos = get list size */
370 iRet = pEnumMRUList(hMRU, -1, NULL, 0);
371 ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
372
373 /* negative item pos = get list size */
374 iRet = pEnumMRUList(hMRU, -5, NULL, 0);
375 ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
376
377 /* negative item pos = get list size */
378 iRet = pEnumMRUList(hMRU, -1, buffer, 255);
379 ok(iRet == 3, "EnumMRUList expected %d, got %d\n", LIST_SIZE, iRet);
380
381 /* negative item pos = get list size */
382 iRet = pEnumMRUList(hMRU, -5, buffer, 255);
383 ok(iRet == 3, "EnumMRUList expected %d, got %d\n", LIST_SIZE, iRet);
384
385 /* check entry 0 */
386 buffer[0] = 0;
387 iRet = pEnumMRUList(hMRU, 0, buffer, 255);
388 todo_wine ok(iRet == lstrlen(checks[3]), "EnumMRUList expected %d, got %d\n", lstrlen(checks[3]), iRet);
389 ok(strcmp(buffer, checks[3]) == 0, "EnumMRUList expected %s, got %s\n", checks[3], buffer);
390
391 /* check entry 0 with a too small buffer */
392 buffer[0] = 0; /* overwritten with 'T' */
393 buffer[1] = 'A'; /* overwritten with 0 */
394 buffer[2] = 'A'; /* unchanged */
395 buffer[3] = 0; /* unchanged */
396 iRet = pEnumMRUList(hMRU, 0, buffer, 2);
397 todo_wine ok(iRet == lstrlen(checks[3]), "EnumMRUList expected %d, got %d\n", lstrlen(checks[3]), iRet);
398 todo_wine ok(strcmp(buffer, "T") == 0, "EnumMRUList expected %s, got %s\n", "T", buffer);
399 /* make sure space after buffer has old values */
400 ok(buffer[2] == 'A', "EnumMRUList expected %02x, got %02x\n", 'A', buffer[2]);
401
402 /* check entry 1 */
403 buffer[0] = 0;
404 iRet = pEnumMRUList(hMRU, 1, buffer, 255);
405 todo_wine ok(iRet == lstrlen(checks[1]), "EnumMRUList expected %d, got %d\n", lstrlen(checks[1]), iRet);
406 ok(strcmp(buffer, checks[1]) == 0, "EnumMRUList expected %s, got %s\n", checks[1], buffer);
407
408 /* check entry 2 */
409 buffer[0] = 0;
410 iRet = pEnumMRUList(hMRU, 2, buffer, 255);
411 todo_wine ok(iRet == lstrlen(checks[2]), "EnumMRUList expected %d, got %d\n", lstrlen(checks[2]), iRet);
412 ok(strcmp(buffer, checks[2]) == 0, "EnumMRUList expected %s, got %s\n", checks[2], buffer);
413
414 /* check out of bounds entry 3 */
415 strcpy(buffer, "dummy");
416 iRet = pEnumMRUList(hMRU, 3, buffer, 255);
417 ok(iRet == -1, "EnumMRUList expected %d, got %d\n", -1, iRet);
418 ok(strcmp(buffer, "dummy") == 0, "EnumMRUList expected unchanged buffer %s, got %s\n", "dummy", buffer);
419
420 /* Finished with this MRU */
421 pFreeMRUList(hMRU);
422 }
423
424 /* FreeMRUList(NULL) crashes on Win98 OSR0 */
425 }
426
427 static void test_CreateMRUListLazyA(void)
428 {
429 HANDLE hMRU;
430 HKEY hKey;
431 CREATEMRULISTA listA = { 0 };
432
433 if (!pCreateMRUListLazyA || !pFreeMRUList)
434 {
435 win_skip("CreateMRUListLazyA or FreeMRUList entry points not found\n");
436 return;
437 }
438
439 /* wrong size */
440 listA.cbSize = sizeof(listA) + 1;
441 hMRU = pCreateMRUListLazyA(&listA, 0, 0, 0);
442 ok(hMRU == NULL, "Expected NULL handle, got %p\n", hMRU);
443 listA.cbSize = 4;
444 hMRU = pCreateMRUListLazyA(&listA, 0, 0, 0);
445 ok(hMRU == NULL, "Expected NULL handle, got %p\n", hMRU);
446 /* NULL hKey */
447 listA.cbSize = sizeof(listA);
448 listA.hKey = NULL;
449 hMRU = pCreateMRUListLazyA(&listA, 0, 0, 0);
450 ok(hMRU == NULL, "Expected NULL handle, got %p\n", hMRU);
451 /* NULL subkey */
452 ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
453 "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
454 listA.cbSize = sizeof(listA);
455 listA.hKey = hKey;
456 listA.lpszSubKey = NULL;
457 hMRU = pCreateMRUListLazyA(&listA, 0, 0, 0);
458 ok(hMRU == NULL || broken(hMRU != NULL), /* Win9x */
459 "Expected NULL handle, got %p\n", hMRU);
460 if (hMRU) pFreeMRUList(hMRU);
461 }
462
463 static void test_EnumMRUList(void)
464 {
465 if (!pEnumMRUList || !pEnumMRUListW)
466 {
467 win_skip("EnumMRUListA/EnumMRUListW entry point not found\n");
468 return;
469 }
470
471 /* NULL handle */
472 if (0)
473 {
474 INT iRet;
475
476 /* crashes on NT4, passed on Win2k, XP, 2k3, Vista, 2k8 */
477 iRet = pEnumMRUList(NULL, 0, NULL, 0);
478 iRet = pEnumMRUListW(NULL, 0, NULL, 0);
479 }
480 }
481
482 static void test_FindMRUData(void)
483 {
484 INT iRet;
485
486 if (!pFindMRUData)
487 {
488 win_skip("FindMRUData entry point not found\n");
489 return;
490 }
491
492 /* NULL handle */
493 iRet = pFindMRUData(NULL, NULL, 0, NULL);
494 ok(iRet == -1, "FindMRUData expected -1, got %d\n", iRet);
495 }
496
497 static void test_AddMRUData(void)
498 {
499 INT iRet;
500
501 if (!pAddMRUData)
502 {
503 win_skip("AddMRUData entry point not found\n");
504 return;
505 }
506
507 /* NULL handle */
508 iRet = pFindMRUData(NULL, NULL, 0, NULL);
509 ok(iRet == -1, "AddMRUData expected -1, got %d\n", iRet);
510 }
511
512 START_TEST(mru)
513 {
514 hComctl32 = GetModuleHandleA("comctl32.dll");
515
516 delete_reg_entries();
517 if (!create_reg_entries())
518 return;
519
520 InitPointers();
521
522 test_MRUListA();
523 test_CreateMRUListLazyA();
524 test_EnumMRUList();
525 test_FindMRUData();
526 test_AddMRUData();
527
528 delete_reg_entries();
529 }
530
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.