dlls/comctl32/tests/mru.c

   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 }