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/heap.h"
  32 #include "wine/test.h"
  33
  34 /* Keys for testing MRU functions */
  35 #define REG_TEST_BASEKEYA    "Software\\Wine"
  36 #define REG_TEST_BASESUBKEYA "Test"
  37 #define REG_TEST_KEYA    REG_TEST_BASEKEYA "\\" REG_TEST_BASESUBKEYA
  38 #define REG_TEST_SUBKEYA "MRUTest"
  39 #define REG_TEST_FULLKEY REG_TEST_KEYA "\\" REG_TEST_SUBKEYA
  40
  41 /* Undocumented MRU functions */
  42 typedef struct tagMRUINFOA
  43 {
  44     DWORD   cbSize;
  45     UINT    uMax;
  46     UINT    fFlags;
  47     HKEY    hKey;
  48     LPCSTR  lpszSubKey;
  49     int (CALLBACK *lpfnCompare)(LPCSTR, LPCSTR);
  50 } MRUINFOA;
  51
  52 typedef struct tagMRUINFOW
  53 {
  54     DWORD   cbSize;
  55     UINT    uMax;
  56     UINT    fFlags;
  57     HKEY    hKey;
  58     LPCWSTR lpszSubKey;
  59     int (CALLBACK *lpfnCompare)(LPCWSTR, LPCWSTR);
  60 } MRUINFOW;
  61
  62 #define MRU_STRING     0  /* this one's invented */
  63 #define MRU_BINARY     1
  64 #define MRU_CACHEWRITE 2
  65
  66 #define LIST_SIZE 3 /* Max entries for each mru */
  67
  68 static HMODULE hComctl32;
  69 static HANDLE (WINAPI *pCreateMRUListA)(MRUINFOA*);
  70 static void   (WINAPI *pFreeMRUList)(HANDLE);
  71 static INT    (WINAPI *pAddMRUStringA)(HANDLE,LPCSTR);
  72 static INT    (WINAPI *pEnumMRUListA)(HANDLE,INT,LPVOID,DWORD);
  73 static INT    (WINAPI *pEnumMRUListW)(HANDLE,INT,LPVOID,DWORD);
  74 static HANDLE (WINAPI *pCreateMRUListLazyA)(MRUINFOA*, DWORD, DWORD, DWORD);
  75 static HANDLE (WINAPI *pCreateMRUListLazyW)(MRUINFOW*, DWORD, DWORD, DWORD);
  76 static INT    (WINAPI *pFindMRUData)(HANDLE, LPCVOID, DWORD, LPINT);
  77 static INT    (WINAPI *pAddMRUData)(HANDLE, LPCVOID, DWORD);
  78 static HANDLE (WINAPI *pCreateMRUListW)(MRUINFOW*);
  79
  80 static void init_functions(void)
  81 {
  82     hComctl32 = LoadLibraryA("comctl32.dll");
  83
  84 #define X2(f, ord) p##f = (void*)GetProcAddress(hComctl32, (const char *)ord);
  85     X2(CreateMRUListA, 151);
  86     X2(FreeMRUList, 152);
  87     X2(AddMRUStringA, 153);
  88     X2(EnumMRUListA, 154);
  89     X2(CreateMRUListLazyA, 157);
  90     X2(AddMRUData, 167);
  91     X2(FindMRUData, 169);
  92     X2(CreateMRUListW, 400);
  93     X2(EnumMRUListW, 403);
  94     X2(CreateMRUListLazyW, 404);
  95 #undef X2
  96 }
  97
  98 /* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
  99 static LSTATUS mru_RegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
 100 {
 101     LONG ret;
 102     DWORD dwMaxSubkeyLen, dwMaxValueLen;
 103     DWORD dwMaxLen, dwSize;
 104     CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 105     HKEY hSubKey = hKey;
 106
 107     if(lpszSubKey)
 108     {
 109         ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 110         if (ret) return ret;
 111     }
 112
 113     /* Get highest length for keys, values */
 114     ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
 115             &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
 116     if (ret) goto cleanup;
 117
 118     dwMaxSubkeyLen++;
 119     dwMaxValueLen++;
 120     dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 121     if (dwMaxLen > ARRAY_SIZE(szNameBuf))
 122     {
 123         /* Name too big: alloc a buffer for it */
 124         if (!(lpszName = heap_alloc(dwMaxLen * sizeof(CHAR))))
 125         {
 126             ret = ERROR_NOT_ENOUGH_MEMORY;
 127             goto cleanup;
 128         }
 129     }
 130
 131
 132     /* Recursively delete all the subkeys */
 133     while (TRUE)
 134     {
 135         dwSize = dwMaxLen;
 136         if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
 137                           NULL, NULL, NULL)) break;
 138
 139         ret = mru_RegDeleteTreeA(hSubKey, lpszName);
 140         if (ret) goto cleanup;
 141     }
 142
 143     if (lpszSubKey)
 144         ret = RegDeleteKeyA(hKey, lpszSubKey);
 145     else
 146         while (TRUE)
 147         {
 148             dwSize = dwMaxLen;
 149             if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
 150                   NULL, NULL, NULL, NULL)) break;
 151
 152             ret = RegDeleteValueA(hKey, lpszName);
 153             if (ret) goto cleanup;
 154         }
 155
 156 cleanup:
 157     /* Free buffer if allocated */
 158     if (lpszName != szNameBuf)
 159         heap_free(lpszName);
 160     if(lpszSubKey)
 161         RegCloseKey(hSubKey);
 162     return ret;
 163 }
 164
 165 static BOOL create_reg_entries(void)
 166 {
 167     HKEY hKey = NULL;
 168
 169     ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_FULLKEY, &hKey),
 170        "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
 171     if (!hKey) return FALSE;
 172     RegCloseKey(hKey);
 173     return TRUE;
 174 }
 175
 176 static void delete_reg_entries(void)
 177 {
 178     HKEY hKey;
 179
 180     if (RegOpenKeyExA(HKEY_CURRENT_USER, REG_TEST_BASEKEYA, 0, KEY_ALL_ACCESS,
 181                       &hKey))
 182         return;
 183     mru_RegDeleteTreeA(hKey, REG_TEST_BASESUBKEYA);
 184     RegCloseKey(hKey);
 185 }
 186
 187 static void check_reg_entries(const char *mrulist, const char**items)
 188 {
 189     char buff[128];
 190     HKEY hKey = NULL;
 191     DWORD type, size, ret;
 192     unsigned int i;
 193
 194     ok(!RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_FULLKEY, &hKey),
 195        "Couldn't open test key \"%s\"\n", REG_TEST_FULLKEY);
 196     if (!hKey) return;
 197
 198     type = REG_SZ;
 199     size = sizeof(buff);
 200     buff[0] = '\0';
 201     ret = RegQueryValueExA(hKey, "MRUList", NULL, &type, (LPBYTE)buff, &size);
 202
 203     ok(!ret && buff[0], "Checking MRU: got %ld from RegQueryValueExW\n", ret);
 204     if(ret || !buff[0]) return;
 205
 206     ok(strcmp(buff, mrulist) == 0, "Checking MRU: Expected list %s, got %s\n",
 207        mrulist, buff);
 208     if(strcmp(buff, mrulist)) return;
 209
 210     for (i = 0; i < strlen(mrulist); i++)
 211     {
 212         char name[2];
 213         name[0] = mrulist[i];
 214         name[1] = '\0';
 215         type = REG_SZ;
 216         size = sizeof(buff);
 217         buff[0] = '\0';
 218         ret = RegQueryValueExA(hKey, name, NULL, &type, (LPBYTE)buff, &size);
 219         ok(!ret && buff[0],
 220            "Checking MRU item %d ('%c'): got %ld from RegQueryValueExW\n",
 221            i, mrulist[i], ret);
 222         if(ret || !buff[0]) return;
 223         ok(!strcmp(buff, items[mrulist[i]-'a']),
 224            "Checking MRU item %d ('%c'): expected \"%s\", got \"%s\"\n",
 225            i, mrulist[i], buff, items[mrulist[i] - 'a']);
 226     }
 227 }
 228
 229 static int CALLBACK cmp_mru_strA(LPCSTR data1, LPCSTR data2)
 230 {
 231     return lstrcmpiA(data1, data2);
 232 }
 233
 234 static void test_MRUListA(void)
 235 {
 236     const char *checks[LIST_SIZE+1];
 237     MRUINFOA infoA;
 238     HANDLE hMRU;
 239     HKEY hKey;
 240     INT iRet;
 241
 242     if (!pCreateMRUListA || !pFreeMRUList || !pAddMRUStringA || !pEnumMRUListA)
 243     {
 244         win_skip("MRU entry points not found\n");
 245         return;
 246     }
 247
 248     if (0)
 249     {
 250     /* Create (NULL) - crashes native */
 251     hMRU = pCreateMRUListA(NULL);
 252     }
 253
 254     /* size too small */
 255     infoA.cbSize = sizeof(infoA) - 2;
 256     infoA.uMax = LIST_SIZE;
 257     infoA.fFlags = MRU_STRING;
 258     infoA.hKey = NULL;
 259     infoA.lpszSubKey = REG_TEST_SUBKEYA;
 260     infoA.lpfnCompare = cmp_mru_strA;
 261
 262     SetLastError(0);
 263     hMRU = pCreateMRUListA(&infoA);
 264     ok (!hMRU && !GetLastError(),
 265         "CreateMRUListA(too small) expected NULL,0 got %p,%ld\n",
 266         hMRU, GetLastError());
 267
 268     /* size too big */
 269     infoA.cbSize = sizeof(infoA) + 2;
 270     infoA.uMax = LIST_SIZE;
 271     infoA.fFlags = MRU_STRING;
 272     infoA.hKey = NULL;
 273     infoA.lpszSubKey = REG_TEST_SUBKEYA;
 274     infoA.lpfnCompare = cmp_mru_strA;
 275
 276     SetLastError(0);
 277     hMRU = pCreateMRUListA(&infoA);
 278     ok (!hMRU && !GetLastError(),
 279         "CreateMRUListA(too big) expected NULL,0 got %p,%ld\n",
 280         hMRU, GetLastError());
 281
 282     /* NULL hKey */
 283     infoA.cbSize = sizeof(infoA);
 284     infoA.uMax = LIST_SIZE;
 285     infoA.fFlags = MRU_STRING;
 286     infoA.hKey = NULL;
 287     infoA.lpszSubKey = REG_TEST_SUBKEYA;
 288     infoA.lpfnCompare = cmp_mru_strA;
 289
 290     SetLastError(0);
 291     hMRU = pCreateMRUListA(&infoA);
 292     ok (!hMRU && !GetLastError(),
 293         "CreateMRUListA(NULL key) expected NULL,0 got %p,%ld\n",
 294         hMRU, GetLastError());
 295
 296     /* NULL subkey name */
 297     infoA.cbSize = sizeof(infoA);
 298     infoA.uMax = LIST_SIZE;
 299     infoA.fFlags = MRU_STRING;
 300     infoA.hKey = NULL;
 301     infoA.lpszSubKey = NULL;
 302     infoA.lpfnCompare = cmp_mru_strA;
 303
 304     SetLastError(0);
 305     hMRU = pCreateMRUListA(&infoA);
 306     ok (!hMRU && !GetLastError(),
 307         "CreateMRUListA(NULL name) expected NULL,0 got %p,%ld\n",
 308         hMRU, GetLastError());
 309
 310     /* Create a string MRU */
 311     ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
 312        "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
 313     if (!hKey) return;
 314
 315     infoA.cbSize = sizeof(infoA);
 316     infoA.uMax = LIST_SIZE;
 317     infoA.fFlags = MRU_STRING;
 318     infoA.hKey = hKey;
 319     infoA.lpszSubKey = REG_TEST_SUBKEYA;
 320     infoA.lpfnCompare = cmp_mru_strA;
 321
 322     hMRU = pCreateMRUListA(&infoA);
 323     ok(hMRU && !GetLastError(),
 324        "CreateMRUListA(string) expected non-NULL,0 got %p,%ld\n",
 325        hMRU, GetLastError());
 326
 327     if (hMRU)
 328     {
 329         char buffer[255];
 330         checks[0] = "Test 1";
 331         checks[1] = "Test 2";
 332         checks[2] = "Test 3";
 333         checks[3] = "Test 4";
 334
 335         /* Add (NULL list) */
 336         SetLastError(0);
 337         iRet = pAddMRUStringA(NULL, checks[0]);
 338         ok(iRet == -1 && !GetLastError(),
 339            "AddMRUStringA(NULL list) expected -1,0 got %d,%ld\n",
 340            iRet, GetLastError());
 341
 342         /* Add (NULL string) */
 343         SetLastError(0);
 344         iRet = pAddMRUStringA(hMRU, NULL);
 345         todo_wine ok(iRet == 0 && !GetLastError(),
 346            "AddMRUStringA(NULL str) expected 0,0 got %d,%ld\n",
 347            iRet, GetLastError());
 348
 349         /* Add 3 strings. Check the registry is correct after each add */
 350         SetLastError(0);
 351         iRet = pAddMRUStringA(hMRU, checks[0]);
 352         ok(iRet == 0 && !GetLastError(),
 353            "AddMRUStringA(1) expected 0,0 got %d,%ld\n",
 354            iRet, GetLastError());
 355         check_reg_entries("a", checks);
 356
 357         SetLastError(0);
 358         iRet = pAddMRUStringA(hMRU, checks[1]);
 359         ok(iRet == 1 && !GetLastError(),
 360            "AddMRUStringA(2) expected 1,0 got %d,%ld\n",
 361            iRet, GetLastError());
 362         check_reg_entries("ba", checks);
 363
 364         SetLastError(0);
 365         iRet = pAddMRUStringA(hMRU, checks[2]);
 366         ok(iRet == 2 && !GetLastError(),
 367            "AddMRUStringA(2) expected 2,0 got %d,%ld\n",
 368            iRet, GetLastError());
 369         check_reg_entries("cba", checks);
 370
 371         /* Add a duplicate of the 2nd string - it should move to the front,
 372          * but keep the same index in the registry.
 373          */
 374         SetLastError(0);
 375         iRet = pAddMRUStringA(hMRU, checks[1]);
 376         ok(iRet == 1 && !GetLastError(),
 377            "AddMRUStringA(re-add 1) expected 1,0 got %d,%ld\n",
 378            iRet, GetLastError());
 379         check_reg_entries("bca", checks);
 380
 381         /* Add a new string - replaces the oldest string + moves to the front */
 382         SetLastError(0);
 383         iRet = pAddMRUStringA(hMRU, checks[3]);
 384         ok(iRet == 0 && !GetLastError(),
 385            "AddMRUStringA(add new) expected 0,0 got %d,%ld\n",
 386            iRet, GetLastError());
 387         checks[0] = checks[3];
 388         check_reg_entries("abc", checks);
 389
 390         /* NULL buffer = get list size */
 391         iRet = pEnumMRUListA(hMRU, 0, NULL, 0);
 392         ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
 393
 394         /* negative item pos = get list size */
 395         iRet = pEnumMRUListA(hMRU, -1, NULL, 0);
 396         ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
 397
 398         /* negative item pos = get list size */
 399         iRet = pEnumMRUListA(hMRU, -5, NULL, 0);
 400         ok(iRet == 3 || iRet == -1 /* Vista */, "EnumMRUList expected %d or -1, got %d\n", LIST_SIZE, iRet);
 401
 402         /* negative item pos = get list size */
 403         iRet = pEnumMRUListA(hMRU, -1, buffer, 255);
 404         ok(iRet == 3, "EnumMRUList expected %d, got %d\n", LIST_SIZE, iRet);
 405
 406         /* negative item pos = get list size */
 407         iRet = pEnumMRUListA(hMRU, -5, buffer, 255);
 408         ok(iRet == 3, "EnumMRUList expected %d, got %d\n", LIST_SIZE, iRet);
 409
 410         /* check entry 0 */
 411         buffer[0] = 0;
 412         iRet = pEnumMRUListA(hMRU, 0, buffer, 255);
 413         ok(iRet == lstrlenA(checks[3]), "EnumMRUList expected %d, got %d\n", lstrlenA(checks[3]), iRet);
 414         ok(strcmp(buffer, checks[3]) == 0, "EnumMRUList expected %s, got %s\n", checks[3], buffer);
 415
 416         /* check entry 0 with a too small buffer */
 417         buffer[0] = 0;   /* overwritten with 'T' */
 418         buffer[1] = 'A'; /* overwritten with 0   */
 419         buffer[2] = 'A'; /* unchanged */
 420         buffer[3] = 0;   /* unchanged */
 421         iRet = pEnumMRUListA(hMRU, 0, buffer, 2);
 422         ok(iRet == lstrlenA(checks[3]), "EnumMRUList expected %d, got %d\n", lstrlenA(checks[3]), iRet);
 423         ok(strcmp(buffer, "T") == 0, "EnumMRUList expected %s, got %s\n", "T", buffer);
 424         /* make sure space after buffer has old values */
 425         ok(buffer[2] == 'A', "EnumMRUList expected %02x, got %02x\n", 'A', buffer[2]);
 426
 427         /* check entry 1 */
 428         buffer[0] = 0;
 429         iRet = pEnumMRUListA(hMRU, 1, buffer, 255);
 430         ok(iRet == lstrlenA(checks[1]), "EnumMRUList expected %d, got %d\n", lstrlenA(checks[1]), iRet);
 431         ok(strcmp(buffer, checks[1]) == 0, "EnumMRUList expected %s, got %s\n", checks[1], buffer);
 432
 433         /* check entry 2 */
 434         buffer[0] = 0;
 435         iRet = pEnumMRUListA(hMRU, 2, buffer, 255);
 436         ok(iRet == lstrlenA(checks[2]), "EnumMRUList expected %d, got %d\n", lstrlenA(checks[2]), iRet);
 437         ok(strcmp(buffer, checks[2]) == 0, "EnumMRUList expected %s, got %s\n", checks[2], buffer);
 438
 439         /* check out of bounds entry 3 */
 440         strcpy(buffer, "dummy");
 441         iRet = pEnumMRUListA(hMRU, 3, buffer, 255);
 442         ok(iRet == -1, "EnumMRUList expected %d, got %d\n", -1, iRet);
 443         ok(strcmp(buffer, "dummy") == 0, "EnumMRUList expected unchanged buffer %s, got %s\n", "dummy", buffer);
 444
 445         /* Finished with this MRU */
 446         pFreeMRUList(hMRU);
 447     }
 448
 449     pFreeMRUList(NULL); /* should not crash */
 450 }
 451
 452 typedef struct {
 453     MRUINFOA mruA;
 454     BOOL ret;
 455 } create_lazya_t;
 456
 457 static const create_lazya_t create_lazyA[] = {
 458     {{ sizeof(MRUINFOA) + 1, 0, 0, HKEY_CURRENT_USER, NULL, NULL }, FALSE },
 459     {{ sizeof(MRUINFOA) - 1, 0, 0, HKEY_CURRENT_USER, NULL, NULL }, FALSE },
 460     {{ sizeof(MRUINFOA) + 1, 0, 0, HKEY_CURRENT_USER, "WineTest", NULL }, TRUE },
 461     {{ sizeof(MRUINFOA) - 1, 0, 0, HKEY_CURRENT_USER, "WineTest", NULL }, TRUE },
 462     {{ sizeof(MRUINFOA), 0, 0, HKEY_CURRENT_USER, "WineTest", NULL }, TRUE },
 463     {{ sizeof(MRUINFOA), 0, 0, HKEY_CURRENT_USER, NULL, NULL }, FALSE },
 464     {{ sizeof(MRUINFOA), 0, 0, NULL, "WineTest", NULL }, FALSE },
 465     {{ 0, 0, 0, NULL, "WineTest", NULL }, FALSE },
 466     {{ 0, 0, 0, HKEY_CURRENT_USER, "WineTest", NULL }, TRUE }
 467 };
 468
 469 static void test_CreateMRUListLazyA(void)
 470 {
 471     int i;
 472
 473     if (!pCreateMRUListLazyA || !pFreeMRUList)
 474     {
 475         win_skip("CreateMRUListLazyA or FreeMRUList entry points not found\n");
 476         return;
 477     }
 478
 479     for (i = 0; i < ARRAY_SIZE(create_lazyA); i++)
 480     {
 481         const create_lazya_t *ptr = &create_lazyA[i];
 482         HANDLE hMRU;
 483
 484         hMRU = pCreateMRUListLazyA((MRUINFOA*)&ptr->mruA, 0, 0, 0);
 485         if (ptr->ret)
 486         {
 487             ok(hMRU != NULL, "%d: got %p\n", i, hMRU);
 488             pFreeMRUList(hMRU);
 489         }
 490         else
 491             ok(hMRU == NULL, "%d: got %p\n", i, hMRU);
 492     }
 493 }
 494
 495 static void test_EnumMRUList(void)
 496 {
 497     if (!pEnumMRUListA || !pEnumMRUListW)
 498     {
 499         win_skip("EnumMRUListA/EnumMRUListW entry point not found\n");
 500         return;
 501     }
 502
 503     /* NULL handle - should not crash */
 504     pEnumMRUListA(NULL, 0, NULL, 0);
 505     pEnumMRUListW(NULL, 0, NULL, 0);
 506 }
 507
 508 static void test_FindMRUData(void)
 509 {
 510     INT iRet;
 511
 512     if (!pFindMRUData)
 513     {
 514         win_skip("FindMRUData entry point not found\n");
 515         return;
 516     }
 517
 518     /* NULL handle */
 519     iRet = pFindMRUData(NULL, NULL, 0, NULL);
 520     ok(iRet == -1, "FindMRUData expected -1, got %d\n", iRet);
 521 }
 522
 523 static void test_AddMRUData(void)
 524 {
 525     INT iRet;
 526
 527     if (!pAddMRUData)
 528     {
 529         win_skip("AddMRUData entry point not found\n");
 530         return;
 531     }
 532
 533     /* NULL handle */
 534     iRet = pFindMRUData(NULL, NULL, 0, NULL);
 535     ok(iRet == -1, "AddMRUData expected -1, got %d\n", iRet);
 536 }
 537
 538 static void test_CreateMRUListW(void)
 539 {
 540     MRUINFOW infoW;
 541     void *named;
 542     HKEY hKey;
 543     HANDLE hMru;
 544
 545     if (!pCreateMRUListW)
 546     {
 547         win_skip("CreateMRUListW entry point not found\n");
 548         return;
 549     }
 550
 551     /* exported by name too on recent versions */
 552     named = GetProcAddress(hComctl32, "CreateMRUListW");
 553     if (named)
 554         ok(named == pCreateMRUListW, "got %p, expected %p\n", named, pCreateMRUListW);
 555
 556     ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
 557        "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
 558
 559     infoW.cbSize = sizeof(infoW);
 560     infoW.uMax = 1;
 561     infoW.fFlags = 0;
 562     infoW.lpszSubKey = L"MRUTest";
 563     infoW.hKey = hKey;
 564     infoW.lpfnCompare = NULL;
 565
 566     hMru = pCreateMRUListW(&infoW);
 567     ok(hMru != NULL, "got %p\n", hMru);
 568     pFreeMRUList(hMru);
 569
 570     /* smaller size */
 571     infoW.cbSize = sizeof(infoW) - 1;
 572     infoW.uMax = 1;
 573     infoW.fFlags = 0;
 574     infoW.lpszSubKey = L"MRUTest";
 575     infoW.hKey = hKey;
 576     infoW.lpfnCompare = NULL;
 577
 578     hMru = pCreateMRUListW(&infoW);
 579     ok(hMru != NULL, "got %p\n", hMru);
 580     pFreeMRUList(hMru);
 581
 582     /* increased size */
 583     infoW.cbSize = sizeof(infoW) + 1;
 584     infoW.uMax = 1;
 585     infoW.fFlags = 0;
 586     infoW.lpszSubKey = L"MRUTest";
 587     infoW.hKey = hKey;
 588     infoW.lpfnCompare = NULL;
 589
 590     hMru = pCreateMRUListW(&infoW);
 591     ok(hMru != NULL, "got %p\n", hMru);
 592     pFreeMRUList(hMru);
 593
 594     /* zero size */
 595     infoW.cbSize = 0;
 596     infoW.uMax = 1;
 597     infoW.fFlags = 0;
 598     infoW.lpszSubKey = L"MRUTest";
 599     infoW.hKey = hKey;
 600     infoW.lpfnCompare = NULL;
 601
 602     hMru = pCreateMRUListW(&infoW);
 603     ok(hMru != NULL, "got %p\n", hMru);
 604     pFreeMRUList(hMru);
 605
 606     /* NULL hKey */
 607     infoW.cbSize = sizeof(infoW);
 608     infoW.uMax = 1;
 609     infoW.fFlags = 0;
 610     infoW.lpszSubKey = L"MRUTest";
 611     infoW.hKey = NULL;
 612     infoW.lpfnCompare = NULL;
 613
 614     hMru = pCreateMRUListW(&infoW);
 615     ok(hMru == NULL, "got %p\n", hMru);
 616
 617     RegCloseKey(hKey);
 618 }
 619
 620 static void test_CreateMRUListLazyW(void)
 621 {
 622     MRUINFOW infoW;
 623     void *named;
 624     HKEY hKey;
 625     HANDLE hMru;
 626
 627     if (!pCreateMRUListLazyW)
 628     {
 629         win_skip("CreateMRUListLazyW entry point not found\n");
 630         return;
 631     }
 632
 633     /* check that it's not exported by name */
 634     named = GetProcAddress(hComctl32, "CreateMRUListLazyW");
 635     ok(named == NULL, "got %p\n", named);
 636
 637     ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
 638        "Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
 639
 640     infoW.cbSize = sizeof(infoW);
 641     infoW.uMax = 1;
 642     infoW.fFlags = 0;
 643     infoW.lpszSubKey = L"MRUTest";
 644     infoW.hKey = hKey;
 645     infoW.lpfnCompare = NULL;
 646
 647     hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
 648     ok(hMru != NULL, "got %p\n", hMru);
 649     pFreeMRUList(hMru);
 650
 651     /* smaller size */
 652     infoW.cbSize = sizeof(infoW) - 1;
 653     infoW.uMax = 1;
 654     infoW.fFlags = 0;
 655     infoW.lpszSubKey = L"MRUTest";
 656     infoW.hKey = hKey;
 657     infoW.lpfnCompare = NULL;
 658
 659     hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
 660     ok(hMru != NULL, "got %p\n", hMru);
 661     pFreeMRUList(hMru);
 662
 663     /* increased size */
 664     infoW.cbSize = sizeof(infoW) + 1;
 665     infoW.uMax = 1;
 666     infoW.fFlags = 0;
 667     infoW.lpszSubKey = L"MRUTest";
 668     infoW.hKey = hKey;
 669     infoW.lpfnCompare = NULL;
 670
 671     hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
 672     ok(hMru != NULL, "got %p\n", hMru);
 673     pFreeMRUList(hMru);
 674
 675     /* zero size */
 676     infoW.cbSize = 0;
 677     infoW.uMax = 1;
 678     infoW.fFlags = 0;
 679     infoW.lpszSubKey = L"MRUTest";
 680     infoW.hKey = hKey;
 681     infoW.lpfnCompare = NULL;
 682
 683     hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
 684     ok(hMru != NULL, "got %p\n", hMru);
 685     pFreeMRUList(hMru);
 686
 687     /* NULL hKey */
 688     infoW.cbSize = sizeof(infoW);
 689     infoW.uMax = 1;
 690     infoW.fFlags = 0;
 691     infoW.lpszSubKey = L"MRUTest";
 692     infoW.hKey = NULL;
 693     infoW.lpfnCompare = NULL;
 694
 695     hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
 696     ok(hMru == NULL, "got %p\n", hMru);
 697
 698     RegCloseKey(hKey);
 699 }
 700
 701 START_TEST(mru)
 702 {
 703     delete_reg_entries();
 704     if (!create_reg_entries())
 705         return;
 706
 707     init_functions();
 708
 709     test_MRUListA();
 710     test_CreateMRUListLazyA();
 711     test_CreateMRUListLazyW();
 712     test_EnumMRUList();
 713     test_FindMRUData();
 714     test_AddMRUData();
 715     test_CreateMRUListW();
 716
 717     delete_reg_entries();
 718 }