comctl32: Remove unused parameter from SYSLINK_WrapLine.
[wine] / 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 DPAM_NOSORT 0x1
35 #define DPAM_INSERT 0x4
36 #define DPAM_DELETE 0x8
37
38 typedef struct _ITEMDATA
39 {
40     INT   iPos;
41     PVOID pvData;
42 } ITEMDATA, *LPITEMDATA;
43
44 typedef PVOID   (CALLBACK *PFNDPAMERGE)(UINT,PVOID,PVOID,LPARAM);
45 typedef HRESULT (CALLBACK *PFNDPASTM)(LPITEMDATA,IStream*,LPARAM);
46
47 static HDPA    (WINAPI *pDPA_Clone)(const HDPA,const HDPA);
48 static HDPA    (WINAPI *pDPA_Create)(INT);
49 static HDPA    (WINAPI *pDPA_CreateEx)(INT,HANDLE);
50 static PVOID   (WINAPI *pDPA_DeleteAllPtrs)(const HDPA);
51 static PVOID   (WINAPI *pDPA_DeletePtr)(const HDPA,INT);
52 static BOOL    (WINAPI *pDPA_Destroy)(const HDPA);
53 static VOID    (WINAPI *pDPA_DestroyCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID);
54 static VOID    (WINAPI *pDPA_EnumCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID); 
55 static INT     (WINAPI *pDPA_GetPtr)(const HDPA,INT);
56 static INT     (WINAPI *pDPA_GetPtrIndex)(const HDPA,PVOID);
57 static BOOL    (WINAPI *pDPA_Grow)(HDPA,INT);
58 static INT     (WINAPI *pDPA_InsertPtr)(const HDPA,INT,PVOID);
59 static HRESULT (WINAPI *pDPA_LoadStream)(HDPA*,PFNDPASTM,IStream*,LPARAM);
60 static BOOL    (WINAPI *pDPA_Merge)(const HDPA,const HDPA,DWORD,PFNDPACOMPARE,PFNDPAMERGE,LPARAM);
61 static HRESULT (WINAPI *pDPA_SaveStream)(HDPA,PFNDPASTM,IStream*,LPARAM);
62 static INT     (WINAPI *pDPA_Search)(HDPA,PVOID,INT,PFNDPACOMPARE,LPARAM,UINT);
63 static BOOL    (WINAPI *pDPA_SetPtr)(const HDPA,INT,PVOID);
64 static BOOL    (WINAPI *pDPA_Sort)(const HDPA,PFNDPACOMPARE,LPARAM);
65
66 #define COMCTL32_GET_PROC(func, ord) \
67   ((p ## func = (PVOID)GetProcAddress(hcomctl32,(LPCSTR)ord)) ? 1 \
68    : (trace( #func " not exported\n"), 0)) 
69
70 static BOOL InitFunctionPtrs(HMODULE hcomctl32)
71 {
72     /* 4.00+ */
73     if(COMCTL32_GET_PROC(DPA_Clone, 331) &&
74        COMCTL32_GET_PROC(DPA_Create, 328) &&
75        COMCTL32_GET_PROC(DPA_CreateEx, 340) &&
76        COMCTL32_GET_PROC(DPA_DeleteAllPtrs, 337) &&
77        COMCTL32_GET_PROC(DPA_DeletePtr, 336) &&
78        COMCTL32_GET_PROC(DPA_Destroy, 329) &&
79        COMCTL32_GET_PROC(DPA_GetPtr, 332) &&
80        COMCTL32_GET_PROC(DPA_GetPtrIndex, 333) &&
81        COMCTL32_GET_PROC(DPA_Grow, 330) &&
82        COMCTL32_GET_PROC(DPA_InsertPtr, 334) &&
83        COMCTL32_GET_PROC(DPA_Search, 339) &&
84        COMCTL32_GET_PROC(DPA_SetPtr, 335) &&
85        COMCTL32_GET_PROC(DPA_Sort, 338))
86     {
87         /* 4.71+ */
88         COMCTL32_GET_PROC(DPA_DestroyCallback, 386) &&
89         COMCTL32_GET_PROC(DPA_EnumCallback, 385) &&
90         COMCTL32_GET_PROC(DPA_LoadStream, 9) &&
91         COMCTL32_GET_PROC(DPA_Merge, 11) &&
92         COMCTL32_GET_PROC(DPA_SaveStream, 10);
93
94         return TRUE;
95     }
96
97     return FALSE;
98 }
99
100 /* Callbacks */
101 static INT CALLBACK CB_CmpLT(PVOID p1, PVOID p2, LPARAM lp)
102 {
103     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
104     return p1 < p2 ? -1 : p1 > p2 ? 1 : 0;
105 }
106
107 static INT CALLBACK CB_CmpGT(PVOID p1, PVOID p2, LPARAM lp)
108 {
109     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
110     return p1 > p2 ? -1 : p1 < p2 ? 1 : 0;
111 }
112
113 static PVOID CALLBACK CB_MergeInsertSrc(UINT op, PVOID p1, PVOID p2, LPARAM lp)
114 {
115     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
116     return p1;
117 }        
118
119 static PVOID CALLBACK CB_MergeDeleteOddSrc(UINT op, PVOID p1, PVOID p2, LPARAM lp)
120 {
121     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
122     return ((PCHAR)p2)+1;
123 }
124
125 static INT nEnum;
126
127 static INT CALLBACK CB_EnumFirstThree(PVOID pItem, PVOID lp)
128 {   
129     INT i;
130
131     i = pDPA_GetPtrIndex(lp, pItem);
132     ok(i == nEnum, "i=%d nEnum=%d\n", i, nEnum);
133     nEnum++;
134     pDPA_SetPtr(lp, i, (PVOID)7);
135     return pItem != (PVOID)3;
136 }
137
138 static HRESULT CALLBACK CB_Save(LPITEMDATA pInfo, IStream *pStm, LPARAM lp)
139 {
140     HRESULT hRes;
141     
142     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
143     hRes = IStream_Write(pStm, &pInfo->iPos, sizeof(INT), NULL);
144     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
145     hRes = IStream_Write(pStm, &pInfo->pvData, sizeof(PVOID), NULL);
146     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
147     return S_OK;
148 }
149
150 static HRESULT CALLBACK CB_Load(LPITEMDATA pInfo, IStream *pStm, LPARAM lp)
151 {
152     HRESULT hRes;
153     INT iOldPos;
154     
155     iOldPos = pInfo->iPos;
156     ok(lp == 0xdeadbeef, "lp=%ld\n", lp);
157     hRes = IStream_Read(pStm, &pInfo->iPos, sizeof(INT), NULL);
158     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
159     ok(pInfo->iPos == iOldPos, "iPos=%d iOldPos=%d\n", pInfo->iPos, iOldPos);
160     hRes = IStream_Read(pStm, &pInfo->pvData, sizeof(PVOID), NULL);
161     ok(hRes == S_OK, "hRes=0x%x\n", hRes);
162     return S_OK;
163 }
164
165 static BOOL CheckDPA(HDPA dpa, DWORD dwIn, PDWORD pdwOut)
166 {
167     DWORD dwOut = 0;
168     INT i;
169
170     for(i = 0; i < 8;)
171     {
172         ULONG_PTR ulItem = (ULONG_PTR)pDPA_GetPtr(dpa, i++);
173         if(!ulItem) break;
174         dwOut = dwOut << 4 | (ulItem & 0xf);
175     }
176     
177     *pdwOut = dwOut;
178
179     if(dwOut != dwIn)
180     {
181         pDPA_DeleteAllPtrs(dpa);
182         
183         do
184         {
185             pDPA_InsertPtr(dpa, 0, (PVOID)(ULONG_PTR)(dwIn & 0xf));
186             dwIn >>= 4;
187         }
188         while(dwIn);
189         
190         return FALSE;
191     }
192     
193     return TRUE;
194 }
195
196 static void test_dpa(void)
197 {
198     SYSTEM_INFO si;
199     HANDLE hHeap;
200     HDPA dpa, dpa2, dpa3;
201     INT ret, i;
202     PVOID p;
203     DWORD dw, dw2, dw3;
204     HRESULT hRes;
205     BOOL rc;
206     
207     GetSystemInfo(&si);
208     hHeap = HeapCreate(0, 1, 2);
209     ok(hHeap != NULL, "error=%d\n", GetLastError());
210     dpa3 = pDPA_CreateEx(0, hHeap);
211     ok(dpa3 != NULL, "\n");
212     ret = pDPA_Grow(dpa3, si.dwPageSize + 1);
213     todo_wine ok(!ret && GetLastError() == ERROR_NOT_ENOUGH_MEMORY, 
214        "ret=%d error=%d\n", ret, GetLastError());
215         
216     dpa = pDPA_Create(0);
217     ok(dpa != NULL, "\n");
218
219     /* Set item with out of bound index */
220     ok(pDPA_SetPtr(dpa, 1, (PVOID)6), "\n");
221     /* Fill the created gap */
222     ok(pDPA_SetPtr(dpa, 0, (PVOID)5), "\n");
223     rc=CheckDPA(dpa, 0x56, &dw);
224     ok(rc, "dw=0x%x\n", dw);
225     
226     /* Prepend item */
227     ret = pDPA_InsertPtr(dpa, 1, (PVOID)1);
228     ok(ret == 1, "ret=%d\n", ret);
229     /* Append item using correct index */
230     ret = pDPA_InsertPtr(dpa, 3, (PVOID)3);
231     ok(ret == 3, "ret=%d\n", ret);
232     /* Append item using out of bound index */
233     ret = pDPA_InsertPtr(dpa, 5, (PVOID)2);
234     ok(ret == 4, "ret=%d\n", ret);
235     /* Append item using DPA_APPEND */ 
236     ret = pDPA_InsertPtr(dpa, DPA_APPEND, (PVOID)4);
237     ok(ret == 5, "ret=%d\n", ret);
238
239     rc=CheckDPA(dpa, 0x516324, &dw);
240     ok(rc, "dw=0x%x\n", dw);
241
242     for(i = 1; i <= 6; i++)
243     {
244         INT j, k;
245         k = pDPA_GetPtrIndex(dpa, (PVOID)(INT_PTR)i);
246         /* Linear searches should work on unsorted DPAs */
247         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpLT, 0xdeadbeef, 0);
248         ok(j == k, "j=%d k=%d\n", j, k);
249     }
250
251     /* Sort DPA */
252     ok(pDPA_Sort(dpa, CB_CmpGT, 0xdeadbeef), "\n");
253     rc=CheckDPA(dpa, 0x654321, &dw);
254     ok(rc, "dw=0x%x\n", dw);
255     
256     /* Clone into a new DPA */
257     dpa2 = pDPA_Clone(dpa, NULL);
258     ok(dpa2 != NULL, "\n");
259     /* The old data should have been preserved */
260     rc=CheckDPA(dpa2, 0x654321, &dw2);
261     ok(rc, "dw=0x%x\n", dw2);
262     ok(pDPA_Sort(dpa, CB_CmpLT, 0xdeadbeef), "\n");
263     
264     /* Test if the DPA itself was really copied */
265     rc=CheckDPA(dpa,  0x123456, &dw);
266     ok(rc, "dw=0x%x\n",  dw );
267     rc=CheckDPA(dpa2, 0x654321, &dw2);
268     ok(rc, "dw2=0x%x\n", dw2);
269
270     /* Clone into an old DPA */
271     p = NULL; SetLastError(ERROR_SUCCESS);
272     p = pDPA_Clone(dpa, dpa3);
273     ok(p == dpa3, "p=%p\n", p);
274     rc=CheckDPA(dpa3, 0x123456, &dw3);
275     ok(rc, "dw3=0x%x\n", dw3);
276
277     for(i = 1; i <= 6; i++)
278     {
279         INT j;
280
281         /* The array is in order so ptr == index+1 */
282         j = pDPA_GetPtrIndex(dpa, (PVOID)(INT_PTR)i);
283         ok(j+1 == i, "j=%d i=%d\n", j, i);
284         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
285         ok(j+1 == i, "j=%d i=%d\n", j, i);
286
287         /* Linear searches respect iStart ... */
288         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, i+1, CB_CmpLT, 0xdeadbeef, 0);
289         ok(j == DPA_ERR, "j=%d\n", j);
290         /* ... but for a binary search it's ignored */
291         j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, i+1, CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
292         todo_wine ok(j+1 == i, "j=%d i=%d\n", j, i);
293     }
294     
295     /* Try to get the index of a nonexistent item */
296     i = pDPA_GetPtrIndex(dpa, (PVOID)7);
297     ok(i == DPA_ERR, "i=%d\n", i);
298     
299     /* Try to delete out of bound indexes */
300     p = pDPA_DeletePtr(dpa, -1);
301     ok(p == NULL, "p=%p\n", p);
302     p = pDPA_DeletePtr(dpa, 6);
303     ok(p == NULL, "p=%p\n", p);
304
305     /* Delete the third item */
306     p = pDPA_DeletePtr(dpa, 2);
307     ok(p == (PVOID)3, "p=%p\n", p);
308     rc=CheckDPA(dpa, 0x12456, &dw);
309     ok(rc, "dw=0x%x\n", dw);
310
311     /* Check where to re-insert the deleted item */
312     i = pDPA_Search(dpa, (PVOID)3, 0, 
313                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED|DPAS_INSERTAFTER);
314     ok(i == 2, "i=%d\n", i);
315     /* DPAS_INSERTBEFORE works just like DPAS_INSERTAFTER */
316     i = pDPA_Search(dpa, (PVOID)3, 0,
317                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED|DPAS_INSERTBEFORE);
318     ok(i == 2, "i=%d\n", i);
319     /* without DPAS_INSERTBEFORE/AFTER */
320     i = pDPA_Search(dpa, (PVOID)3, 0,
321                     CB_CmpLT, 0xdeadbeef, DPAS_SORTED);
322     ok(i == -1, "i=%d\n", i);
323
324     /* Re-insert the item */
325     ret = pDPA_InsertPtr(dpa, 2, (PVOID)3);
326     ok(ret == 2, "ret=%d i=%d\n", ret, 2);
327     rc=CheckDPA(dpa, 0x123456, &dw);
328     ok(rc, "dw=0x%x\n", dw);
329     
330     /* When doing a binary search while claiming reverse order all indexes
331      * should be bogus */
332     for(i = 0; i < 6; i++)
333     {
334         INT j = pDPA_Search(dpa, (PVOID)(INT_PTR)i, 0, CB_CmpGT, 0xdeadbeef,
335                             DPAS_SORTED|DPAS_INSERTBEFORE);
336         ok(j != i, "i=%d\n", i);
337     }
338
339     if(pDPA_Merge)
340     {
341         /* Delete all even entries from dpa */
342         p = pDPA_DeletePtr(dpa, 1);
343         p = pDPA_DeletePtr(dpa, 2);
344         p = pDPA_DeletePtr(dpa, 3);
345         rc=CheckDPA(dpa, 0x135, &dw);
346         ok(rc, "dw=0x%x\n", dw);
347     
348         /* Delete all odd entries from dpa2 */
349         pDPA_Merge(dpa2, dpa, DPAM_DELETE, 
350                    CB_CmpLT, CB_MergeDeleteOddSrc, 0xdeadbeef);
351         todo_wine
352         {
353             rc=CheckDPA(dpa2, 0x246, &dw2);
354             ok(rc, "dw=0x%x\n", dw2);
355         }
356     
357         /* Merge dpa3 into dpa2 and dpa */
358         pDPA_Merge(dpa, dpa3, DPAM_INSERT|DPAM_NOSORT, 
359                    CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
360         pDPA_Merge(dpa2, dpa3, DPAM_INSERT|DPAM_NOSORT, 
361                    CB_CmpLT, CB_MergeInsertSrc, 0xdeadbeef);
362     
363         rc=CheckDPA(dpa,  0x123456, &dw);
364         ok(rc, "dw=0x%x\n",  dw);
365         rc=CheckDPA(dpa2, 0x123456, &dw2);
366         ok(rc ||
367            broken(!rc), /* win98 */
368            "dw2=0x%x\n", dw2);
369         rc=CheckDPA(dpa3, 0x123456, &dw3);
370         ok(rc, "dw3=0x%x\n", dw3);
371     }
372
373     if(pDPA_EnumCallback)
374     {
375         nEnum = 0;
376         pDPA_EnumCallback(dpa2, CB_EnumFirstThree, (PVOID)dpa2);
377         rc=CheckDPA(dpa2, 0x777456, &dw2);
378         ok(rc, "dw=0x%x\n", dw2);
379         ok(nEnum == 3, "nEnum=%d\n", nEnum);
380     }
381     
382     /* Setting item with huge index should work */
383     ok(pDPA_SetPtr(dpa2, 0x12345, (PVOID)0xdeadbeef), "\n");
384     ret = pDPA_GetPtrIndex(dpa2, (PVOID)0xdeadbeef);
385     ok(ret == 0x12345, "ret=%d\n", ret);
386           
387     pDPA_DeleteAllPtrs(dpa2);
388     rc=CheckDPA(dpa2, 0, &dw2);
389     ok(rc, "dw2=0x%x\n", dw2);
390     pDPA_Destroy(dpa2);
391
392     if(pDPA_DestroyCallback)
393     {
394         nEnum = 0;
395         pDPA_DestroyCallback(dpa3, CB_EnumFirstThree, dpa3);
396         ok(nEnum == 3, "nEnum=%d\n", nEnum);
397     }
398     else pDPA_Destroy(dpa3);
399
400     if(!pDPA_SaveStream)
401         goto skip_stream_tests;
402
403     hRes = CoInitialize(NULL);
404     if(hRes == S_OK)
405     {
406         static const WCHAR szStg[] = { 'S','t','g',0 };
407         IStorage* pStg = NULL;
408         IStream* pStm = NULL;
409         LARGE_INTEGER liZero;
410         DWORD dwMode;
411         liZero.QuadPart = 0;
412
413         dwMode = STGM_DIRECT|STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE;
414         hRes = StgCreateDocfile(NULL, dwMode|STGM_DELETEONRELEASE, 0, &pStg);
415         ok(hRes == S_OK, "hRes=0x%x\n", hRes);
416
417         hRes = IStorage_CreateStream(pStg, szStg, dwMode, 0, 0, &pStm);
418         ok(hRes == S_OK, "hRes=0x%x\n", hRes);
419
420         hRes = pDPA_SaveStream(dpa, CB_Save, pStm, 0xdeadbeef);
421         todo_wine ok(hRes == S_OK, "hRes=0x%x\n", hRes);
422         pDPA_Destroy(dpa);
423         
424         hRes = IStream_Seek(pStm, liZero, STREAM_SEEK_SET, NULL);
425         ok(hRes == S_OK, "hRes=0x%x\n", hRes);
426         hRes = pDPA_LoadStream(&dpa, CB_Load, pStm, 0xdeadbeef);
427         todo_wine
428         {
429             ok(hRes == S_OK, "hRes=0x%x\n", hRes);
430             rc=CheckDPA(dpa, 0x123456, &dw);
431             ok(rc, "dw=0x%x\n", dw);
432         }
433
434         ret = IStream_Release(pStm);
435         ok(!ret, "ret=%d\n", ret);
436         
437         ret = IStorage_Release(pStg);
438         ok(!ret, "ret=%d\n", ret);
439
440         CoUninitialize();
441     }
442     else ok(0, "hResult: %d\n", hRes);
443
444 skip_stream_tests:
445     pDPA_Destroy(dpa);
446 }
447
448 START_TEST(dpa)
449 {
450     HMODULE hcomctl32;
451
452     hcomctl32 = GetModuleHandleA("comctl32.dll");
453
454     if(InitFunctionPtrs(hcomctl32))
455         test_dpa();
456     else
457         win_skip("Needed functions are not available\n");
458 }