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 }
758
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.