dlls/comctl32/tests/dpa.c

   1 /*
   2  * Unit tests for DPA functions
   3  *
   4  * Copyright 2003 Uwe Bonnes
   5  * Copyright 2005 Felix Nawothnig
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "commctrl.h"
  30 #include "objidl.h"
  31
  32 #include "wine/test.h"
  33
  34 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  35
  36 typedef struct _STREAMDATA
  37 {
  38     DWORD dwSize;
  39     DWORD dwData2;
  40     DWORD dwItems;
  41 } STREAMDATA, *PSTREAMDATA;
  42
  43 static HDPA    (WINAPI *pDPA_Clone)(const HDPA,const HDPA);
  44 static HDPA    (WINAPI *pDPA_Create)(INT);
  45 static HDPA    (WINAPI *pDPA_CreateEx)(INT,HANDLE);
  46 static PVOID   (WINAPI *pDPA_DeleteAllPtrs)(const HDPA);
  47 static PVOID   (WINAPI *pDPA_DeletePtr)(const HDPA,INT);
  48 static BOOL    (WINAPI *pDPA_Destroy)(const HDPA);
  49 static VOID    (WINAPI *pDPA_DestroyCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID);
  50 static VOID    (WINAPI *pDPA_EnumCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID);
  51 static INT     (WINAPI *pDPA_GetPtr)(const HDPA,INT);
  52 static INT     (WINAPI *pDPA_GetPtrIndex)(const HDPA,PVOID);
  53 static BOOL    (WINAPI *pDPA_Grow)(HDPA,INT);
  54 static INT     (WINAPI *pDPA_InsertPtr)(const HDPA,INT,PVOID);
  55 static HRESULT (WINAPI *pDPA_LoadStream)(HDPA*,PFNDPASTREAM,IStream*,LPVOID);
  56 static BOOL    (WINAPI *pDPA_Merge)(const HDPA,const HDPA,DWORD,PFNDPACOMPARE,PFNDPAMERGE,LPARAM);
  57 static HRESULT (WINAPI *pDPA_SaveStream)(HDPA,PFNDPASTREAM,IStream*,LPVOID);
  58 static INT     (WINAPI *pDPA_Search)(HDPA,PVOID,INT,PFNDPACOMPARE,LPARAM,UINT);
  59 static BOOL    (WINAPI *pDPA_SetPtr)(const HDPA,INT,PVOID);
  60 static BOOL    (WINAPI *pDPA_Sort)(const HDPA,PFNDPACOMPARE,LPARAM);
  61
  62 #define COMCTL32_GET_PROC(func, ord) \
  63   ((p ## func = (PVOID)GetProcAddress(hcomctl32,(LPCSTR)ord)) ? 1 \
  64    : (trace( #func " not exported\n"), 0))
  65
  66 static BOOL InitFunctionPtrs(HMODULE hcomctl32)
  67 {
  68     /* 4.00+ */
  69     if(COMCTL32_GET_PROC(DPA_Clone, 331) &&
  70        COMCTL32_GET_PROC(DPA_Create, 328) &&
  71        COMCTL32_GET_PROC(DPA_CreateEx, 340) &&
  72        COMCTL32_GET_PROC(DPA_DeleteAllPtrs, 337) &&
  73        COMCTL32_GET_PROC(DPA_DeletePtr, 336) &&
  74        COMCTL32_GET_PROC(DPA_Destroy, 329) &&
  75        COMCTL32_GET_PROC(DPA_GetPtr, 332) &&
  76        COMCTL32_GET_PROC(DPA_GetPtrIndex, 333) &&
  77        COMCTL32_GET_PROC(DPA_Grow, 330) &&
  78        COMCTL32_GET_PROC(DPA_InsertPtr, 334) &&
  79        COMCTL32_GET_PROC(DPA_Search, 339) &&
  80        COMCTL32_GET_PROC(DPA_SetPtr, 335) &&
  81        COMCTL32_GET_PROC(DPA_Sort, 338))
  82     {
  83         /* 4.71+ */
  84         COMCTL32_GET_PROC(DPA_DestroyCallback, 386) &&
  85         COMCTL32_GET_PROC(DPA_EnumCallback, 385) &&
  86         COMCTL32_GET_PROC(DPA_LoadStream, 9) &&
  87         COMCTL32_GET_PROC(DPA_Merge, 11) &&
  88         COMCTL32_GET_PROC(DPA_SaveStream, 10);
  89
  90         return TRUE;
  91     }
  92
  93     return FALSE;
  94 }
  95
  96 /* Callbacks */
  97 static INT CALLBACK CB_CmpLT(PVOID p1, PVOID p2, LPARAM lp)
  98 {
  99     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
 100     return p1 < p2 ? -1 : p1 > p2 ? 1 : 0;
 101 }
 102
 103 static INT CALLBACK CB_CmpGT(PVOID p1, PVOID p2, LPARAM lp)
 104 {
 105     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
 106     return p1 > p2 ? -1 : p1 < p2 ? 1 : 0;
 107 }
 108
 109 /* merge callback messages counter
 110    DPAMM_MERGE     1
 111    DPAMM_DELETE    2
 112    DPAMM_INSERT    3  */
 113 static INT nMessages[4];
 114
 115 static PVOID CALLBACK CB_MergeInsertSrc(UINT op, PVOID p1, PVOID p2, LPARAM lp)
 116 {
 117     nMessages[op]++;
 118     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
 119     return p1;
 120 }
 121
 122 static PVOID CALLBACK CB_MergeDeleteOddSrc(UINT op, PVOID p1, PVOID p2, LPARAM lp)
 123 {
 124     nMessages[op]++;
 125     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
 126     return ((PCHAR)p2)+1;
 127 }
 128
 129 static INT nEnum;
 130
 131 static INT CALLBACK CB_EnumFirstThree(PVOID pItem, PVOID lp)
 132 {
 133     INT i;
 134
 135     i = pDPA_GetPtrIndex(lp, pItem);
 136     ok(i == nEnum, "i=%d nEnum=%d\n", i, nEnum);
 137     nEnum++;
 138     pDPA_SetPtr(lp, i, (PVOID)7);
 139     return pItem != (PVOID)3;
 140 }
 141
 142 static HRESULT CALLBACK CB_Save(DPASTREAMINFO *pInfo, IStream *pStm, LPVOID lp)
 143 {
 144     HRESULT hRes;
 145
 146     ok(lp == (LPVOID)0xdeadbeef, "lp=%p\n", lp);
 147     hRes = IStream_Write(pStm, &pInfo->iPos, sizeof(INT), NULL);
 148     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 149     hRes = IStream_Write(pStm, &pInfo->pvItem, sizeof(PVOID), NULL);
 150     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 151     return S_OK;
 152 }
 153
 154 static HRESULT CALLBACK CB_Load(DPASTREAMINFO *pInfo, IStream *pStm, LPVOID lp)
 155 {
 156     HRESULT hRes;
 157     INT iOldPos;
 158
 159     iOldPos = pInfo->iPos;
 160     ok(lp == (LPVOID)0xdeadbeef, "lp=%p\n", lp);
 161     hRes = IStream_Read(pStm, &pInfo->iPos, sizeof(INT), NULL);
 162     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 163     ok(pInfo->iPos == iOldPos, "iPos=%d iOldPos=%d\n", pInfo->iPos, iOldPos);
 164     hRes = IStream_Read(pStm, &pInfo->pvItem, sizeof(PVOID), NULL);
 165     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 166     return S_OK;
 167 }
 168
 169 static BOOL CheckDPA(HDPA dpa, DWORD dwIn, PDWORD pdwOut)
 170 {
 171     DWORD dwOut = 0;
 172     INT i;
 173
 174     for(i = 0; i < 8;)
 175     {
 176         ULONG_PTR ulItem = (ULONG_PTR)pDPA_GetPtr(dpa, i++);
 177         if(!ulItem) break;
 178         dwOut = dwOut << 4 | (ulItem & 0xf);
 179     }
 180
 181     *pdwOut = dwOut;
 182
 183     if(dwOut != dwIn)
 184     {
 185         pDPA_DeleteAllPtrs(dpa);
 186
 187         do
 188         {
 189             pDPA_InsertPtr(dpa, 0, (PVOID)(ULONG_PTR)(dwIn & 0xf));
 190             dwIn >>= 4;
 191         }
 192         while(dwIn);
 193
 194         return FALSE;
 195     }
 196
 197     return TRUE;
 198 }
 199
 200 static void test_dpa(void)
 201 {
 202     SYSTEM_INFO si;
 203     HANDLE hHeap;
 204     HDPA dpa, dpa2, dpa3;
 205     INT ret, i;
 206     PVOID p;
 207     DWORD dw, dw2, dw3;
 208     BOOL rc;
 209
 210     GetSystemInfo(&si);
 211     hHeap = HeapCreate(0, 1, 2);
 212     ok(hHeap != NULL, "error=%d\n", GetLastError());
 213     dpa3 = pDPA_CreateEx(0, hHeap);
 214     ok(dpa3 != NULL, "\n");
 215     ret = pDPA_Grow(dpa3, si.dwPageSize + 1);
 216     todo_wine ok(!ret && GetLastError() == ERROR_NOT_ENOUGH_MEMORY,
 217        "ret=%d error=%d\n", ret, GetLastError());
 218
 219     dpa = pDPA_Create(0);
 220     ok(dpa != NULL, "\n");
 221
 222     /* Set item with out of bound index */
 223     ok(pDPA_SetPtr(dpa, 1, (PVOID)6), "\n");
 224     /* Fill the created gap */
 225     ok(pDPA_SetPtr(dpa, 0, (PVOID)5), "\n");
 226     rc=CheckDPA(dpa, 0x56, &dw);
 227     ok(rc, "dw=0x%x\n", dw);
 228
 229     /* Prepend item */
 230     ret = pDPA_InsertPtr(dpa, 1, (PVOID)1);
 231     ok(ret == 1, "ret=%d\n", ret);
 232     /* Append item using correct index */
 233     ret = pDPA_InsertPtr(dpa, 3, (PVOID)3);
 234     ok(ret == 3, "ret=%d\n", ret);
 235     /* Append item using out of bound index */
 236     ret = pDPA_InsertPtr(dpa, 5, (PVOID)2);
 237     ok(ret == 4, "ret=%d\n", ret);
 238     /* Append item using DPA_APPEND */
 239     ret = pDPA_InsertPtr(dpa, DPA_APPEND, (PVOID)4);
 240     ok(ret == 5, "ret=%d\n", ret);
 241
 242     rc=CheckDPA(dpa, 0x516324, &dw);
 243     ok(rc, "dw=0x%x\n", dw);
 244
 245     for(i = 1; i <= 6; i++)
 246     {
 247         INT j, k;
 248         k = pDPA_GetPtrIndex(dpa, (PVOID)(INT_PTR)i);
 249         /* Linear searches should work on unsorted DPAs */
 250         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpLT, 0xdeadbeef, 0);
 251         ok(j == k, "j=%d k=%d\n", j, k);
 252     }
 253
 254     /* Sort DPA */
 255     ok(pDPA_Sort(dpa, CB_CmpGT, 0xdeadbeef), "\n");
 256     rc=CheckDPA(dpa, 0x654321, &dw);
 257     ok(rc, "dw=0x%x\n", dw);
 258
 259     /* Clone into a new DPA */
 260     dpa2 = pDPA_Clone(dpa, NULL);
 261     ok(dpa2 != NULL, "\n");
 262     /* The old data should have been preserved */
 263     rc=CheckDPA(dpa2, 0x654321, &dw2);
 264     ok(rc, "dw=0x%x\n", dw2);
 265     ok(pDPA_Sort(dpa, CB_CmpLT, 0xdeadbeef), "\n");
 266
 267     /* Test if the DPA itself was really copied */
 268     rc=CheckDPA(dpa,  0x123456, &dw);
 269     ok(rc, "dw=0x%x\n",  dw );
 270     rc=CheckDPA(dpa2, 0x654321, &dw2);
 271     ok(rc, "dw2=0x%x\n", dw2);
 272
 273     /* Clone into an old DPA */
 274     p = NULL; SetLastError(ERROR_SUCCESS);
 275     p = pDPA_Clone(dpa, dpa3);
 276     ok(p == dpa3, "p=%p\n", p);
 277     rc=CheckDPA(dpa3, 0x123456, &dw3);
 278     ok(rc, "dw3=0x%x\n", dw3);
 279
 280     for(i = 1; i <= 6; i++)
 281     {
 282         INT j;
 283
 284         /* The array is in order so ptr == index+1 */
 285         j = pDPA_GetPtrIndex(dpa, (PVOID)(INT_PTR)i);
 286         ok(j+1 == i, "j=%d i=%d\n", j, i);
 287         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
 288         ok(j+1 == i, "j=%d i=%d\n", j, i);
 289
 290         /* Linear searches respect iStart ... */
 291         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, i+1, CB_CmpLT, 0xdeadbeef, 0);
 292         ok(j == DPA_ERR, "j=%d\n", j);
 293         /* ... but for a binary search it's ignored */
 294         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, i+1, CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
 295         ok(j+1 == i, "j=%d i=%d\n", j, i);
 296     }
 297
 298     /* Try to get the index of a nonexistent item */
 299     i = pDPA_GetPtrIndex(dpa, (PVOID)7);
 300     ok(i == DPA_ERR, "i=%d\n", i);
 301
 302     /* Try to delete out of bound indexes */
 303     p = pDPA_DeletePtr(dpa, -1);
 304     ok(p == NULL, "p=%p\n", p);
 305     p = pDPA_DeletePtr(dpa, 6);
 306     ok(p == NULL, "p=%p\n", p);
 307
 308     /* Delete the third item */
 309     p = pDPA_DeletePtr(dpa, 2);
 310     ok(p == (PVOID)3, "p=%p\n", p);
 311     rc=CheckDPA(dpa, 0x12456, &dw);
 312     ok(rc, "dw=0x%x\n", dw);
 313
 314     /* Check where to re-insert the deleted item */
 315     i = pDPA_Search(dpa, (PVOID)3, 0,
 316                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED|DPAS_INSERTAFTER);
 317     ok(i == 2, "i=%d\n", i);
 318     /* DPAS_INSERTBEFORE works just like DPAS_INSERTAFTER */
 319     i = pDPA_Search(dpa, (PVOID)3, 0,
 320                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED|DPAS_INSERTBEFORE);
 321     ok(i == 2, "i=%d\n", i);
 322     /* without DPAS_INSERTBEFORE/AFTER */
 323     i = pDPA_Search(dpa, (PVOID)3, 0,
 324                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
 325     ok(i == -1, "i=%d\n", i);
 326
 327     /* Re-insert the item */
 328     ret = pDPA_InsertPtr(dpa, 2, (PVOID)3);
 329     ok(ret == 2, "ret=%d i=%d\n", ret, 2);
 330     rc=CheckDPA(dpa, 0x123456, &dw);
 331     ok(rc, "dw=0x%x\n", dw);
 332
 333     /* When doing a binary search while claiming reverse order all indexes
 334      * should be bogus */
 335     for(i = 0; i < 6; i++)
 336     {
 337         INT j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpGT, 0xdeadbeef,
 338                             DPAS_SORTED|DPAS_INSERTBEFORE);
 339         ok(j != i, "i=%d\n", i);
 340     }
 341
 342     /* Setting item with huge index should work */
 343     ok(pDPA_SetPtr(dpa2, 0x12345, (PVOID)0xdeadbeef), "\n");
 344     ret = pDPA_GetPtrIndex(dpa2, (PVOID)0xdeadbeef);
 345     ok(ret == 0x12345, "ret=%d\n", ret);
 346
 347     pDPA_DeleteAllPtrs(dpa2);
 348     rc=CheckDPA(dpa2, 0, &dw2);
 349     ok(rc, "dw2=0x%x\n", dw2);
 350     pDPA_Destroy(dpa2);
 351     pDPA_Destroy(dpa3);
 352 }
 353
 354 static void test_DPA_Merge(void)
 355 {
 356     HDPA dpa, dpa2, dpa3;
 357     INT ret, i;
 358     DWORD dw;
 359     BOOL rc;
 360
 361     if(!pDPA_Merge)
 362     {
 363         win_skip("DPA_Merge() not available\n");
 364         return;
 365     }
 366
 367     dpa  = pDPA_Create(0);
 368     dpa2 = pDPA_Create(0);
 369     dpa3 = pDPA_Create(0);
 370
 371     ret = pDPA_InsertPtr(dpa, 0, (PVOID)1);
 372     ok(ret == 0, "ret=%d\n", ret);
 373     ret = pDPA_InsertPtr(dpa, 1, (PVOID)3);
 374     ok(ret == 1, "ret=%d\n", ret);
 375     ret = pDPA_InsertPtr(dpa, 2, (PVOID)5);
 376     ok(ret == 2, "ret=%d\n", ret);
 377
 378     rc = CheckDPA(dpa, 0x135, &dw);
 379     ok(rc, "dw=0x%x\n", dw);
 380
 381     for (i = 0; i < 6; i++)
 382     {
 383         ret = pDPA_InsertPtr(dpa2, i, (PVOID)(6-i));
 384         ok(ret == i, "ret=%d\n", ret);
 385         ret = pDPA_InsertPtr(dpa3, i, (PVOID)(i+1));
 386         ok(ret == i, "ret=%d\n", ret);
 387     }
 388
 389     rc = CheckDPA(dpa2, 0x654321, &dw);
 390     ok(rc, "dw=0x%x\n", dw);
 391     rc = CheckDPA(dpa3, 0x123456, &dw);
 392     ok(rc, "dw=0x%x\n", dw);
 393
 394     /* Delete all odd entries from dpa2 */
 395     memset(nMessages, 0, sizeof(nMessages));
 396     pDPA_Merge(dpa2, dpa, DPAM_INTERSECT,
 397                CB_CmpLT, CB_MergeDeleteOddSrc, 0xdeadbeef);
 398     rc = CheckDPA(dpa2, 0x246, &dw);
 399     ok(rc, "dw=0x%x\n", dw);
 400
 401     expect(3, nMessages[DPAMM_MERGE]);
 402     expect(3, nMessages[DPAMM_DELETE]);
 403     expect(0, nMessages[DPAMM_INSERT]);
 404
 405     for (i = 0; i < 6; i++)
 406     {
 407         ret = pDPA_InsertPtr(dpa2, i, (PVOID)(6-i));
 408         ok(ret == i, "ret=%d\n", ret);
 409     }
 410
 411     /* DPAM_INTERSECT - returning source while merging */
 412     memset(nMessages, 0, sizeof(nMessages));
 413     pDPA_Merge(dpa2, dpa, DPAM_INTERSECT,
 414                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 415     rc = CheckDPA(dpa2, 0x135, &dw);
 416     ok(rc, "dw=0x%x\n", dw);
 417
 418     expect(3, nMessages[DPAMM_MERGE]);
 419     expect(6, nMessages[DPAMM_DELETE]);
 420     expect(0, nMessages[DPAMM_INSERT]);
 421
 422     /* DPAM_UNION */
 423     pDPA_DeleteAllPtrs(dpa);
 424     pDPA_InsertPtr(dpa, 0, (PVOID)1);
 425     pDPA_InsertPtr(dpa, 1, (PVOID)3);
 426     pDPA_InsertPtr(dpa, 2, (PVOID)5);
 427     pDPA_DeleteAllPtrs(dpa2);
 428     pDPA_InsertPtr(dpa2, 0, (PVOID)2);
 429     pDPA_InsertPtr(dpa2, 1, (PVOID)4);
 430     pDPA_InsertPtr(dpa2, 2, (PVOID)6);
 431
 432     memset(nMessages, 0, sizeof(nMessages));
 433     pDPA_Merge(dpa2, dpa, DPAM_UNION,
 434                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 435     rc = CheckDPA(dpa2, 0x123456, &dw);
 436     ok(rc, "dw=0x%x\n", dw);
 437
 438     expect(0, nMessages[DPAMM_MERGE]);
 439     expect(0, nMessages[DPAMM_DELETE]);
 440     expect(3, nMessages[DPAMM_INSERT]);
 441
 442     /* Merge dpa3 into dpa2 and dpa */
 443     memset(nMessages, 0, sizeof(nMessages));
 444     pDPA_Merge(dpa, dpa3, DPAM_UNION|DPAM_SORTED,
 445                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 446     expect(3, nMessages[DPAMM_MERGE]);
 447     expect(0, nMessages[DPAMM_DELETE]);
 448     expect(3, nMessages[DPAMM_INSERT]);
 449
 450
 451     pDPA_DeleteAllPtrs(dpa2);
 452     pDPA_InsertPtr(dpa2, 0, (PVOID)2);
 453     pDPA_InsertPtr(dpa2, 1, (PVOID)4);
 454     pDPA_InsertPtr(dpa2, 2, (PVOID)6);
 455
 456     memset(nMessages, 0, sizeof(nMessages));
 457     pDPA_Merge(dpa2, dpa3, DPAM_UNION|DPAM_SORTED,
 458                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 459     expect(3, nMessages[DPAMM_MERGE]);
 460     expect(0, nMessages[DPAMM_DELETE]);
 461     expect(3, nMessages[DPAMM_INSERT]);
 462
 463     rc = CheckDPA(dpa,  0x123456, &dw);
 464     ok(rc, "dw=0x%x\n",  dw);
 465     rc = CheckDPA(dpa2, 0x123456, &dw);
 466     ok(rc ||
 467        broken(!rc), /* win98 */
 468        "dw=0x%x\n", dw);
 469     rc = CheckDPA(dpa3, 0x123456, &dw);
 470     ok(rc, "dw=0x%x\n", dw);
 471
 472     pDPA_Destroy(dpa);
 473     pDPA_Destroy(dpa2);
 474     pDPA_Destroy(dpa3);
 475 }
 476
 477 static void test_DPA_EnumCallback(void)
 478 {
 479     HDPA dpa;
 480     BOOL rc;
 481     DWORD dw;
 482     INT i, ret;
 483
 484     if(!pDPA_EnumCallback)
 485     {
 486         win_skip("DPA_EnumCallback() not available\n");
 487         return;
 488     }
 489
 490     dpa = pDPA_Create(0);
 491
 492     for (i = 0; i < 6; i++)
 493     {
 494         ret = pDPA_InsertPtr(dpa, i, (PVOID)(i+1));
 495         ok(ret == i, "ret=%d\n", ret);
 496     }
 497
 498     rc = CheckDPA(dpa, 0x123456, &dw);
 499     ok(rc, "dw=0x%x\n", dw);
 500
 501     nEnum = 0;
 502     /* test callback sets first 3 items to 7 */
 503     pDPA_EnumCallback(dpa, CB_EnumFirstThree, dpa);
 504     rc = CheckDPA(dpa, 0x777456, &dw);
 505     ok(rc, "dw=0x%x\n", dw);
 506     ok(nEnum == 3, "nEnum=%d\n", nEnum);
 507
 508     pDPA_Destroy(dpa);
 509 }
 510
 511 static void test_DPA_DestroyCallback(void)
 512 {
 513     HDPA dpa;
 514     INT i, ret;
 515
 516     if(!pDPA_DestroyCallback)
 517     {
 518         win_skip("DPA_DestroyCallback() not available\n");
 519         return;
 520     }
 521
 522     dpa = pDPA_Create(0);
 523
 524     for (i = 0; i < 3; i++)
 525     {
 526         ret = pDPA_InsertPtr(dpa, i, (PVOID)(i+1));
 527         ok(ret == i, "ret=%d\n", ret);
 528     }
 529
 530     nEnum = 0;
 531     pDPA_DestroyCallback(dpa, CB_EnumFirstThree, dpa);
 532     ok(nEnum == 3, "nEnum=%d\n", nEnum);
 533 }
 534
 535 static void test_DPA_LoadStream(void)
 536 {
 537     static const WCHAR szStg[] = { 'S','t','g',0 };
 538     IStorage* pStg = NULL;
 539     IStream* pStm = NULL;
 540     LARGE_INTEGER li;
 541     ULARGE_INTEGER uli;
 542     DWORD dwMode;
 543     HRESULT hRes;
 544     STREAMDATA header;
 545     ULONG written, ret;
 546     HDPA dpa;
 547
 548     hRes = CoInitialize(NULL);
 549     if (hRes != S_OK)
 550     {
 551         ok(0, "hResult: %d\n", hRes);
 552         return;
 553     }
 554
 555     dwMode = STGM_DIRECT|STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE;
 556     hRes = StgCreateDocfile(NULL, dwMode|STGM_DELETEONRELEASE, 0, &pStg);
 557     expect(S_OK, hRes);
 558
 559     hRes = IStorage_CreateStream(pStg, szStg, dwMode, 0, 0, &pStm);
 560     expect(S_OK, hRes);
 561
 562     /* write less than header size */
 563     li.QuadPart = 0;
 564     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 565     expect(S_OK, hRes);
 566
 567     memset(&header, 0, sizeof(header));
 568     written = 0;
 569     uli.QuadPart = sizeof(header)-1;
 570     hRes = IStream_SetSize(pStm, uli);
 571     expect(S_OK, hRes);
 572     hRes = IStream_Write(pStm, &header, sizeof(header)-1, &written);
 573     expect(S_OK, hRes);
 574     written -= sizeof(header)-1;
 575     expect(0, written);
 576
 577     li.QuadPart = 0;
 578     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 579     expect(S_OK, hRes);
 580
 581     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, NULL);
 582     expect(E_FAIL, hRes);
 583
 584     /* check stream position after header read failed */
 585     li.QuadPart = 0;
 586     uli.QuadPart = 1;
 587     hRes = IStream_Seek(pStm, li, STREAM_SEEK_CUR, &uli);
 588     expect(S_OK, hRes);
 589     ok(uli.QuadPart == 0, "Expected to position reset\n");
 590
 591     /* write valid header for empty DPA */
 592     header.dwSize = sizeof(header);
 593     header.dwData2 = 1;
 594     header.dwItems = 0;
 595     written = 0;
 596
 597     li.QuadPart = 0;
 598     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 599     expect(S_OK, hRes);
 600
 601     uli.QuadPart = sizeof(header);
 602     hRes = IStream_SetSize(pStm, uli);
 603     expect(S_OK, hRes);
 604
 605     hRes = IStream_Write(pStm, &header, sizeof(header), &written);
 606     expect(S_OK, hRes);
 607     written -= sizeof(header);
 608     expect(0, written);
 609
 610     li.QuadPart = 0;
 611     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 612     expect(S_OK, hRes);
 613
 614     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, NULL);
 615     expect(S_OK, hRes);
 616
 617     /* try with altered dwData2 field */
 618     header.dwSize = sizeof(header);
 619     header.dwData2 = 2;
 620     header.dwItems = 0;
 621
 622     li.QuadPart = 0;
 623     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 624     expect(S_OK, hRes);
 625     hRes = IStream_Write(pStm, &header, sizeof(header), &written);
 626     expect(S_OK, hRes);
 627     written -= sizeof(header);
 628     expect(0, written);
 629
 630     li.QuadPart = 0;
 631     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 632     expect(S_OK, hRes);
 633
 634     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, (void*)0xdeadbeef);
 635     expect(E_FAIL, hRes);
 636
 637     ret = IStream_Release(pStm);
 638     ok(!ret, "ret=%d\n", ret);
 639
 640     ret = IStorage_Release(pStg);
 641     ok(!ret, "ret=%d\n", ret);
 642
 643     CoUninitialize();
 644 }
 645
 646 static void test_dpa_stream(void)
 647 {
 648     HDPA dpa;
 649     HRESULT hRes;
 650     INT ret, i;
 651     BOOL rc;
 652
 653     static const WCHAR szStg[] = { 'S','t','g',0 };
 654     IStorage* pStg = NULL;
 655     IStream* pStm = NULL;
 656     LARGE_INTEGER liZero;
 657     DWORD dwMode, dw;
 658
 659     if(!pDPA_SaveStream)
 660     {
 661         win_skip("DPA_SaveStream() not available. Skipping stream tests.\n");
 662         return;
 663     }
 664
 665     hRes = CoInitialize(NULL);
 666     if (hRes != S_OK)
 667     {
 668         ok(0, "hResult: %d\n", hRes);
 669         return;
 670     }
 671
 672     dpa = pDPA_Create(0);
 673
 674     for (i = 0; i < 6; i++)
 675     {
 676         ret = pDPA_InsertPtr(dpa, i, (PVOID)(i+1));
 677         ok(ret == i, "ret=%d\n", ret);
 678     }
 679
 680     dwMode = STGM_DIRECT|STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE;
 681     hRes = StgCreateDocfile(NULL, dwMode|STGM_DELETEONRELEASE, 0, &pStg);
 682     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 683
 684     hRes = IStorage_CreateStream(pStg, szStg, dwMode, 0, 0, &pStm);
 685     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 686
 687     hRes = pDPA_SaveStream(dpa, CB_Save, pStm, (void*)0xdeadbeef);
 688     todo_wine ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 689     pDPA_Destroy(dpa);
 690
 691     liZero.QuadPart = 0;
 692     hRes = IStream_Seek(pStm, liZero, STREAM_SEEK_SET, NULL);
 693     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 694     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, (void*)0xdeadbeef);
 695     todo_wine
 696     {
 697         ok(hRes == S_OK, "hRes=0x%x\n", hRes);
 698         rc = CheckDPA(dpa, 0x123456, &dw);
 699         ok(rc, "dw=0x%x\n", dw);
 700     }
 701     pDPA_Destroy(dpa);
 702
 703     ret = IStream_Release(pStm);
 704     ok(!ret, "ret=%d\n", ret);
 705
 706     ret = IStorage_Release(pStg);
 707     ok(!ret, "ret=%d\n", ret);
 708
 709     CoUninitialize();
 710 }
 711
 712 START_TEST(dpa)
 713 {
 714     HMODULE hcomctl32;
 715
 716     hcomctl32 = GetModuleHandleA("comctl32.dll");
 717
 718     if(!InitFunctionPtrs(hcomctl32))
 719     {
 720         win_skip("Needed functions are not available\n");
 721         return;
 722     }
 723
 724     test_dpa();
 725     test_DPA_Merge();
 726     test_DPA_EnumCallback();
 727     test_DPA_DestroyCallback();
 728     test_DPA_LoadStream();
 729     test_dpa_stream();
 730 }