git.oblomov.eu Git - wine/blob - 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     expect(S_OK, hRes);
 149     hRes = IStream_Write(pStm, &pInfo->pvItem, sizeof(PVOID), NULL);
 150     expect(S_OK, 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     expect(S_OK, 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     expect(S_OK, 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)(INT_PTR)(6-i));
 384         ok(ret == i, "ret=%d\n", ret);
 385         ret = pDPA_InsertPtr(dpa3, i, (PVOID)(INT_PTR)(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)(INT_PTR)(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 ||
 437        broken(!rc && dw == 0x23456), /* 4.7x */
 438        "dw=0x%x\n", dw);
 439
 440     expect(0, nMessages[DPAMM_MERGE]);
 441     expect(0, nMessages[DPAMM_DELETE]);
 442     ok(nMessages[DPAMM_INSERT] == 3 ||
 443        broken(nMessages[DPAMM_INSERT] == 2), /* 4.7x */
 444        "Expected 3, got %d\n", nMessages[DPAMM_INSERT]);
 445
 446     /* Merge dpa3 into dpa2 and dpa */
 447     memset(nMessages, 0, sizeof(nMessages));
 448     pDPA_Merge(dpa, dpa3, DPAM_UNION|DPAM_SORTED,
 449                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 450     expect(3, nMessages[DPAMM_MERGE]);
 451     expect(0, nMessages[DPAMM_DELETE]);
 452     expect(3, nMessages[DPAMM_INSERT]);
 453
 454
 455     pDPA_DeleteAllPtrs(dpa2);
 456     pDPA_InsertPtr(dpa2, 0, (PVOID)2);
 457     pDPA_InsertPtr(dpa2, 1, (PVOID)4);
 458     pDPA_InsertPtr(dpa2, 2, (PVOID)6);
 459
 460     memset(nMessages, 0, sizeof(nMessages));
 461     pDPA_Merge(dpa2, dpa3, DPAM_UNION|DPAM_SORTED,
 462                CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
 463     expect(3, nMessages[DPAMM_MERGE]);
 464     expect(0, nMessages[DPAMM_DELETE]);
 465     ok(nMessages[DPAMM_INSERT] == 3 ||
 466        broken(nMessages[DPAMM_INSERT] == 2), /* 4.7x */
 467        "Expected 3, got %d\n", nMessages[DPAMM_INSERT]);
 468
 469     rc = CheckDPA(dpa,  0x123456, &dw);
 470     ok(rc, "dw=0x%x\n",  dw);
 471     rc = CheckDPA(dpa2, 0x123456, &dw);
 472     ok(rc ||
 473        broken(!rc), /* win98 */
 474        "dw=0x%x\n", dw);
 475     rc = CheckDPA(dpa3, 0x123456, &dw);
 476     ok(rc, "dw=0x%x\n", dw);
 477
 478     pDPA_Destroy(dpa);
 479     pDPA_Destroy(dpa2);
 480     pDPA_Destroy(dpa3);
 481 }
 482
 483 static void test_DPA_EnumCallback(void)
 484 {
 485     HDPA dpa;
 486     BOOL rc;
 487     DWORD dw;
 488     INT i, ret;
 489
 490     if(!pDPA_EnumCallback)
 491     {
 492         win_skip("DPA_EnumCallback() not available\n");
 493         return;
 494     }
 495
 496     dpa = pDPA_Create(0);
 497
 498     for (i = 0; i < 6; i++)
 499     {
 500         ret = pDPA_InsertPtr(dpa, i, (PVOID)(INT_PTR)(i+1));
 501         ok(ret == i, "ret=%d\n", ret);
 502     }
 503
 504     rc = CheckDPA(dpa, 0x123456, &dw);
 505     ok(rc, "dw=0x%x\n", dw);
 506
 507     nEnum = 0;
 508     /* test callback sets first 3 items to 7 */
 509     pDPA_EnumCallback(dpa, CB_EnumFirstThree, dpa);
 510     rc = CheckDPA(dpa, 0x777456, &dw);
 511     ok(rc, "dw=0x%x\n", dw);
 512     ok(nEnum == 3, "nEnum=%d\n", nEnum);
 513
 514     pDPA_Destroy(dpa);
 515 }
 516
 517 static void test_DPA_DestroyCallback(void)
 518 {
 519     HDPA dpa;
 520     INT i, ret;
 521
 522     if(!pDPA_DestroyCallback)
 523     {
 524         win_skip("DPA_DestroyCallback() not available\n");
 525         return;
 526     }
 527
 528     dpa = pDPA_Create(0);
 529
 530     for (i = 0; i < 3; i++)
 531     {
 532         ret = pDPA_InsertPtr(dpa, i, (PVOID)(INT_PTR)(i+1));
 533         ok(ret == i, "ret=%d\n", ret);
 534     }
 535
 536     nEnum = 0;
 537     pDPA_DestroyCallback(dpa, CB_EnumFirstThree, dpa);
 538     ok(nEnum == 3, "nEnum=%d\n", nEnum);
 539 }
 540
 541 static void test_DPA_LoadStream(void)
 542 {
 543     static const WCHAR szStg[] = { 'S','t','g',0 };
 544     IStorage* pStg = NULL;
 545     IStream* pStm = NULL;
 546     LARGE_INTEGER li;
 547     ULARGE_INTEGER uli;
 548     DWORD dwMode;
 549     HRESULT hRes;
 550     STREAMDATA header;
 551     ULONG written, ret;
 552     HDPA dpa;
 553
 554     if(!pDPA_LoadStream)
 555     {
 556         win_skip("DPA_LoadStream() not available. Skipping stream tests.\n");
 557         return;
 558     }
 559
 560     hRes = CoInitialize(NULL);
 561     if (hRes != S_OK)
 562     {
 563         ok(0, "hResult: %d\n", hRes);
 564         return;
 565     }
 566
 567     dwMode = STGM_DIRECT|STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE;
 568     hRes = StgCreateDocfile(NULL, dwMode|STGM_DELETEONRELEASE, 0, &pStg);
 569     expect(S_OK, hRes);
 570
 571     hRes = IStorage_CreateStream(pStg, szStg, dwMode, 0, 0, &pStm);
 572     expect(S_OK, hRes);
 573
 574     /* write less than header size */
 575     li.QuadPart = 0;
 576     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 577     expect(S_OK, hRes);
 578
 579     memset(&header, 0, sizeof(header));
 580     written = 0;
 581     uli.QuadPart = sizeof(header)-1;
 582     hRes = IStream_SetSize(pStm, uli);
 583     expect(S_OK, hRes);
 584     hRes = IStream_Write(pStm, &header, sizeof(header)-1, &written);
 585     expect(S_OK, hRes);
 586     written -= sizeof(header)-1;
 587     expect(0, written);
 588
 589     li.QuadPart = 0;
 590     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 591     expect(S_OK, hRes);
 592
 593     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, NULL);
 594     expect(E_FAIL, hRes);
 595
 596     /* check stream position after header read failed */
 597     li.QuadPart = 0;
 598     uli.QuadPart = 1;
 599     hRes = IStream_Seek(pStm, li, STREAM_SEEK_CUR, &uli);
 600     expect(S_OK, hRes);
 601     ok(uli.QuadPart == 0, "Expected to position reset\n");
 602
 603     /* write valid header for empty DPA */
 604     header.dwSize = sizeof(header);
 605     header.dwData2 = 1;
 606     header.dwItems = 0;
 607     written = 0;
 608
 609     li.QuadPart = 0;
 610     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 611     expect(S_OK, hRes);
 612
 613     uli.QuadPart = sizeof(header);
 614     hRes = IStream_SetSize(pStm, uli);
 615     expect(S_OK, hRes);
 616
 617     hRes = IStream_Write(pStm, &header, sizeof(header), &written);
 618     expect(S_OK, hRes);
 619     written -= sizeof(header);
 620     expect(0, written);
 621
 622     li.QuadPart = 0;
 623     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 624     expect(S_OK, hRes);
 625
 626     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, NULL);
 627     expect(S_OK, hRes);
 628
 629     /* try with altered dwData2 field */
 630     header.dwSize = sizeof(header);
 631     header.dwData2 = 2;
 632     header.dwItems = 0;
 633
 634     li.QuadPart = 0;
 635     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 636     expect(S_OK, hRes);
 637     hRes = IStream_Write(pStm, &header, sizeof(header), &written);
 638     expect(S_OK, hRes);
 639     written -= sizeof(header);
 640     expect(0, written);
 641
 642     li.QuadPart = 0;
 643     hRes = IStream_Seek(pStm, li, STREAM_SEEK_SET, NULL);
 644     expect(S_OK, hRes);
 645
 646     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, (void*)0xdeadbeef);
 647     expect(E_FAIL, hRes);
 648
 649     ret = IStream_Release(pStm);
 650     ok(!ret, "ret=%d\n", ret);
 651
 652     ret = IStorage_Release(pStg);
 653     ok(!ret, "ret=%d\n", ret);
 654
 655     CoUninitialize();
 656 }
 657
 658 static void test_DPA_SaveStream(void)
 659 {
 660     HDPA dpa;
 661     static const WCHAR szStg[] = { 'S','t','g',0 };
 662     IStorage* pStg = NULL;
 663     IStream* pStm = NULL;
 664     DWORD dwMode, dw;
 665     HRESULT hRes;
 666     ULONG ret;
 667     INT i;
 668     BOOL rc;
 669     LARGE_INTEGER liZero;
 670
 671     if(!pDPA_SaveStream)
 672     {
 673         win_skip("DPA_SaveStream() not available. Skipping stream tests.\n");
 674         return;
 675     }
 676
 677     hRes = CoInitialize(NULL);
 678     if (hRes != S_OK)
 679     {
 680         ok(0, "hResult: %d\n", hRes);
 681         return;
 682     }
 683
 684     dwMode = STGM_DIRECT|STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE;
 685     hRes = StgCreateDocfile(NULL, dwMode|STGM_DELETEONRELEASE, 0, &pStg);
 686     expect(S_OK, hRes);
 687
 688     hRes = IStorage_CreateStream(pStg, szStg, dwMode, 0, 0, &pStm);
 689     expect(S_OK, hRes);
 690
 691     dpa = pDPA_Create(0);
 692
 693     /* simple parameter check */
 694     hRes = pDPA_SaveStream(dpa, NULL, pStm, NULL);
 695     ok(hRes == E_INVALIDARG ||
 696        broken(hRes == S_OK) /* XP and below */, "Wrong result, %d\n", hRes);
 697 if (0) {
 698     /* crashes on XP */
 699     hRes = pDPA_SaveStream(NULL, CB_Save, pStm, NULL);
 700     expect(E_INVALIDARG, hRes);
 701
 702     hRes = pDPA_SaveStream(dpa, CB_Save, NULL, NULL);
 703     expect(E_INVALIDARG, hRes);
 704 }
 705
 706     /* saving/loading */
 707     for (i = 0; i < 6; i++)
 708     {
 709         ret = pDPA_InsertPtr(dpa, i, (PVOID)(INT_PTR)(i+1));
 710         ok(ret == i, "ret=%d\n", ret);
 711     }
 712
 713     liZero.QuadPart = 0;
 714     hRes = IStream_Seek(pStm, liZero, STREAM_SEEK_SET, NULL);
 715     expect(S_OK, hRes);
 716
 717     hRes = pDPA_SaveStream(dpa, CB_Save, pStm, (void*)0xdeadbeef);
 718     expect(S_OK, hRes);
 719     pDPA_Destroy(dpa);
 720
 721     liZero.QuadPart = 0;
 722     hRes = IStream_Seek(pStm, liZero, STREAM_SEEK_SET, NULL);
 723     expect(S_OK, hRes);
 724     hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, (void*)0xdeadbeef);
 725     expect(S_OK, hRes);
 726     rc = CheckDPA(dpa, 0x123456, &dw);
 727     ok(rc, "dw=0x%x\n", dw);
 728     pDPA_Destroy(dpa);
 729
 730     ret = IStream_Release(pStm);
 731     ok(!ret, "ret=%d\n", ret);
 732
 733     ret = IStorage_Release(pStg);
 734     ok(!ret, "ret=%d\n", ret);
 735
 736     CoUninitialize();
 737 }
 738
 739 START_TEST(dpa)
 740 {
 741     HMODULE hcomctl32;
 742
 743     hcomctl32 = GetModuleHandleA("comctl32.dll");
 744
 745     if(!InitFunctionPtrs(hcomctl32))
 746     {
 747         win_skip("Needed functions are not available\n");
 748         return;
 749     }
 750
 751     test_dpa();
 752     test_DPA_Merge();
 753     test_DPA_EnumCallback();
 754     test_DPA_DestroyCallback();
 755     test_DPA_LoadStream();
 756     test_DPA_SaveStream();
 757 }