comctl32/treeview: Fix pszText NULL pointer dereference.
[wine] / dlls / comctl32 / tests / header.c
1 /* Unit test suite for header control.
2  *
3  * Copyright 2005 Vijay Kiran Kamuju
4  * Copyright 2007 Shanren Zhou
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
21
22 #include <windows.h>
23 #include <commctrl.h>
24 #include <assert.h>
25
26 #include "wine/test.h"
27 #include "msg.h"
28
29 typedef struct tagEXPECTEDNOTIFY
30 {
31     INT iCode;
32     BOOL fUnicode;
33     HDITEMA hdItem;
34 } EXPECTEDNOTIFY;
35
36 typedef LRESULT (*CUSTOMDRAWPROC)(int n, NMCUSTOMDRAW *nm);
37
38 static CUSTOMDRAWPROC g_CustomDrawProc;
39 static int g_CustomDrawCount;
40 static DRAWITEMSTRUCT g_DrawItem;
41 static BOOL g_DrawItemReceived;
42
43 static EXPECTEDNOTIFY expectedNotify[10];
44 static INT nExpectedNotify = 0;
45 static INT nReceivedNotify = 0;
46 static INT unexpectedNotify[10];
47 static INT nUnexpectedNotify = 0;
48
49 static HWND hHeaderParentWnd;
50 static HWND hWndHeader;
51 #define MAX_CHARS 100
52
53 #define compare(val, exp, fmt)  ok((val) == (exp), #val " value: " fmt ", expected: " fmt "\n", (val), (exp))
54
55 #define expect(expected, got) ok(expected == got, "expected %d, got %d\n", expected,got)
56
57 #define NUM_MSG_SEQUENCES    2
58 #define PARENT_SEQ_INDEX     0
59 #define HEADER_SEQ_INDEX     1
60
61 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
62
63 static const struct message create_parent_wnd_seq[] = {
64     { WM_GETMINMAXINFO, sent },
65     { WM_NCCREATE, sent },
66     { WM_NCCALCSIZE, sent|wparam, 0 },
67     { WM_CREATE, sent },
68     { 0 }
69 };
70
71 static const struct message add_header_to_parent_seq_interactive[] = {
72     { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
73     { WM_QUERYUISTATE, sent },
74     { WM_PARENTNOTIFY, sent|wparam, 1 },
75     { WM_SHOWWINDOW, sent|wparam, 1 },
76     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
77     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
78     { WM_ACTIVATEAPP, sent|wparam, 1 },
79     { WM_NCACTIVATE, sent|wparam, 1 },
80     { WM_ACTIVATE, sent|wparam, 1 },
81     { WM_IME_SETCONTEXT, sent|defwinproc|wparam, 1 },
82     { WM_IME_NOTIFY, sent|defwinproc|wparam, 2 },
83     { WM_SETFOCUS, sent|defwinproc|wparam, 0 },
84     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
85     { WM_SIZE, sent|wparam, 0 },
86     { WM_MOVE, sent|wparam, 0 },
87     { 0 }
88 };
89
90 static const struct message add_header_to_parent_seq[] = {
91     { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
92     { WM_QUERYUISTATE, sent|optional },
93     { WM_PARENTNOTIFY, sent },
94     { 0 }
95 };
96
97 static const struct message insertItem_seq[] = {
98     { HDM_INSERTITEM, sent|wparam, 0 },
99     { HDM_INSERTITEM, sent|wparam, 1 },
100     { HDM_INSERTITEM, sent|wparam, 2 },
101     { HDM_INSERTITEM, sent|wparam, 3 },
102     { 0 }
103 };
104
105 static const struct message getItem_seq[] = {
106     { HDM_GETITEM, sent|wparam, 3 },
107     { HDM_GETITEM, sent|wparam, 0 },
108     { 0 }
109 };
110
111
112 static const struct message deleteItem_getItemCount_seq[] = {
113     { HDM_DELETEITEM, sent|wparam, 3 },
114     { HDM_GETITEMCOUNT, sent },
115     { HDM_DELETEITEM, sent|wparam, 3 },
116     { HDM_GETITEMCOUNT, sent },
117     { HDM_DELETEITEM, sent|wparam, 2 },
118     { HDM_GETITEMCOUNT, sent },
119     { 0 }
120 };
121
122 static const struct message orderArray_seq[] = {
123     { HDM_GETITEMCOUNT, sent },
124     { HDM_SETORDERARRAY, sent|wparam, 2 },
125     { HDM_GETORDERARRAY, sent|wparam, 2 },
126     { 0 }
127 };
128
129 static const struct message setItem_seq[] = {
130     { HDM_SETITEM, sent|wparam, 0 },
131     { HDM_SETITEM, sent|wparam, 1 },
132     { 0 }
133 };
134
135 static const struct message getItemRect_seq[] = {
136     { HDM_GETITEMRECT, sent|wparam, 1 },
137     { HDM_GETITEMRECT, sent|wparam, 0 },
138     { HDM_GETITEMRECT, sent|wparam, 10 },
139     { 0 }
140 };
141
142 static const struct message layout_seq[] = {
143     { HDM_LAYOUT, sent },
144     { 0 }
145 };
146
147 static const struct message orderToIndex_seq[] = {
148     { HDM_ORDERTOINDEX, sent|wparam, 1 },
149     { 0 }
150 };
151
152 static const struct message hittest_seq[] = {
153     { HDM_HITTEST, sent },
154     { HDM_HITTEST, sent },
155     { HDM_HITTEST, sent },
156     { 0 }
157 };
158
159 static const struct message setHotDivider_seq_interactive[] = {
160     { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
161     { WM_PAINT, sent|defwinproc},
162     { WM_NCPAINT, sent|defwinproc},
163     { WM_ERASEBKGND, sent|defwinproc},
164     { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
165     { WM_PAINT, sent|defwinproc},
166     { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
167     { WM_PAINT, sent|defwinproc},
168     { 0 }
169 };
170
171 static const struct message setHotDivider_seq_noninteractive[] = {
172     { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
173     { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
174     { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
175     { 0 }
176 };
177
178 static const struct message imageMessages_seq[] = {
179     { HDM_SETIMAGELIST, sent },
180     { HDM_GETIMAGELIST, sent },
181     { HDM_CREATEDRAGIMAGE, sent },
182     { 0 }
183 };
184
185 static const struct message filterMessages_seq_interactive[] = {
186     { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
187     { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
188     { HDM_EDITFILTER,  sent|wparam|lparam, 1, 0 },
189     { WM_PARENTNOTIFY, sent|wparam|defwinproc, WM_CREATE },
190     { WM_CTLCOLOREDIT, sent|defwinproc },
191     { WM_COMMAND, sent|defwinproc },
192     { 0 }
193 };
194
195 static const struct message filterMessages_seq_noninteractive[] = {
196     { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
197     { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
198     { HDM_EDITFILTER,  sent|wparam|lparam, 1, 0 },
199     { WM_PARENTNOTIFY, sent|wparam|defwinproc|optional, WM_CREATE },
200     { WM_COMMAND, sent|defwinproc|optional },
201     { 0 }
202 };
203
204 static const struct message unicodeformatMessages_seq[] = {
205     { HDM_SETUNICODEFORMAT, sent|wparam, TRUE },
206     { HDM_GETUNICODEFORMAT, sent },
207     { 0 }
208 };
209
210 static const struct message bitmapmarginMessages_seq[] = {
211     { HDM_GETBITMAPMARGIN, sent },
212     { 0 }
213 };
214
215
216 static void expect_notify(INT iCode, BOOL fUnicode, HDITEMA *lpItem)
217 {
218     assert(nExpectedNotify < 10);
219     expectedNotify[nExpectedNotify].iCode = iCode;
220     expectedNotify[nExpectedNotify].fUnicode = fUnicode;
221     expectedNotify[nExpectedNotify].hdItem = *lpItem;
222     nExpectedNotify++;
223 }
224
225 static void dont_expect_notify(INT iCode)
226 {
227     assert(nUnexpectedNotify < 10);
228     unexpectedNotify[nUnexpectedNotify++] = iCode;
229 }
230
231 static BOOL notifies_received(void)
232 {
233     BOOL fRet = (nExpectedNotify == nReceivedNotify);
234     nExpectedNotify = nReceivedNotify = 0;
235     nUnexpectedNotify = 0;
236     return fRet;
237 }
238
239 static LONG addItem(HWND hdex, int idx, LPSTR text)
240 {
241     HDITEMA hdItem;
242     hdItem.mask       = HDI_TEXT | HDI_WIDTH;
243     hdItem.cxy        = 100;
244     hdItem.pszText    = text;
245     hdItem.cchTextMax = 0;
246     return (LONG)SendMessage(hdex, HDM_INSERTITEMA, (WPARAM)idx, (LPARAM)&hdItem);
247 }
248
249 static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
250 {
251     LONG ret;
252     HDITEMA hdexItem;
253     hdexItem.mask       = HDI_TEXT;
254     hdexItem.pszText    = text;
255     hdexItem.cchTextMax = 0;
256     if (fCheckNotifies)
257     {
258         expect_notify(HDN_ITEMCHANGINGA, FALSE, &hdexItem);
259         expect_notify(HDN_ITEMCHANGEDA, FALSE, &hdexItem);
260     }
261     ret = (LONG)SendMessage(hdex, HDM_SETITEMA, (WPARAM)idx, (LPARAM)&hdexItem);
262     if (fCheckNotifies)
263         ok(notifies_received(), "setItem(): not all expected notifies were received\n");
264     return ret;
265 }
266
267 static LONG setItemUnicodeNotify(HWND hdex, int idx, LPSTR text, LPWSTR wText)
268 {
269     LONG ret;
270     HDITEMA hdexItem;
271     HDITEMW hdexNotify;
272     hdexItem.mask       = HDI_TEXT;
273     hdexItem.pszText    = text;
274     hdexItem.cchTextMax = 0;
275     
276     hdexNotify.mask    = HDI_TEXT;
277     hdexNotify.pszText = wText;
278     
279     expect_notify(HDN_ITEMCHANGINGW, TRUE, (HDITEMA*)&hdexNotify);
280     expect_notify(HDN_ITEMCHANGEDW, TRUE, (HDITEMA*)&hdexNotify);
281     ret = (LONG)SendMessage(hdex, HDM_SETITEMA, (WPARAM)idx, (LPARAM)&hdexItem);
282     ok(notifies_received(), "setItemUnicodeNotify(): not all expected notifies were received\n");
283     return ret;
284 }
285
286 static LONG delItem(HWND hdex, int idx)
287 {
288     return (LONG)SendMessage(hdex, HDM_DELETEITEM, (WPARAM)idx, 0);
289 }
290
291 static LONG getItemCount(HWND hdex)
292 {
293     return (LONG)SendMessage(hdex, HDM_GETITEMCOUNT, 0, 0);
294 }
295
296 static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
297 {
298     HDITEMA hdItem;
299     hdItem.mask         = HDI_TEXT;
300     hdItem.pszText      = textBuffer;
301     hdItem.cchTextMax   = MAX_CHARS;
302     return (LONG)SendMessage(hdex, HDM_GETITEMA, (WPARAM)idx, (LPARAM)&hdItem);
303 }
304
305 static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
306 {
307     ok(SendMessage(hdex, HDM_INSERTITEMA, (WPARAM)0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
308     ZeroMemory(phdiRead, sizeof(HDITEMA));
309     phdiRead->mask = maskRead;
310     ok(SendMessage(hdex, HDM_GETITEMA, (WPARAM)0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
311     ok(SendMessage(hdex, HDM_DELETEITEM, (WPARAM)0, (LPARAM)0)!=0, "Deleting item failed\n");
312 }
313
314 static HWND create_header_control (void)
315 {
316     HWND handle;
317     HDLAYOUT hlayout;
318     RECT rectwin;
319     WINDOWPOS winpos;
320
321     handle = CreateWindowEx(0, WC_HEADER, NULL,
322                             WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
323                             0, 0, 0, 0,
324                             hHeaderParentWnd, NULL, NULL, NULL);
325     assert(handle);
326
327     if (winetest_interactive)
328         ShowWindow (hHeaderParentWnd, SW_SHOW);
329
330     GetClientRect(hHeaderParentWnd,&rectwin);
331     hlayout.prc = &rectwin;
332     hlayout.pwpos = &winpos;
333     SendMessageA(handle,HDM_LAYOUT,0,(LPARAM) &hlayout);
334     SetWindowPos(handle, winpos.hwndInsertAfter, winpos.x, winpos.y, 
335                  winpos.cx, winpos.cy, 0);
336
337     return handle;
338 }
339
340 static void compare_items(INT iCode, HDITEMA *hdi1, HDITEMA *hdi2, BOOL fUnicode)
341 {
342     ok(hdi1->mask == hdi2->mask, "Notify %d mask mismatch (%08x != %08x)\n", iCode, hdi1->mask, hdi2->mask);
343     if (hdi1->mask & HDI_WIDTH)
344     {
345         ok(hdi1->cxy == hdi2->cxy, "Notify %d cxy mismatch (%08x != %08x)\n", iCode, hdi1->cxy, hdi2->cxy);
346     }
347     if (hdi1->mask & HDI_TEXT)
348     {
349         if (hdi1->pszText == LPSTR_TEXTCALLBACKA)
350         {
351             ok(hdi1->pszText == LPSTR_TEXTCALLBACKA, "Notify %d - only one item is LPSTR_TEXTCALLBACK\n", iCode);
352         }
353         else
354         if (fUnicode)
355         {
356             char buf1[260];
357             char buf2[260];
358             WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi1->pszText, -1, buf1, 260, NULL, NULL);
359             WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi2->pszText, -1, buf2, 260, NULL, NULL);
360             ok(lstrcmpW((LPWSTR)hdi1->pszText, (LPWSTR)hdi2->pszText)==0,
361                 "Notify %d text mismatch (L\"%s\" vs L\"%s\")\n",
362                     iCode, buf1, buf2);
363         }
364         else
365         {
366             ok(strcmp(hdi1->pszText, hdi2->pszText)==0,
367                 "Notify %d text mismatch (\"%s\" vs \"%s\")\n",
368                     iCode, hdi1->pszText, hdi2->pszText);
369             }
370     }
371 }
372
373 static char pszFirstItem[]      = "First Item";
374 static char pszSecondItem[]     = "Second Item";
375 static char pszThirdItem[]      = "Third Item";
376 static char pszFourthItem[]     = "Fourth Item";
377 static char pszReplaceItem[]    = "Replace Item";
378 static char pszOutOfRangeItem[] = "Out Of Range Item";
379
380 static char *str_items[] =
381     {pszFirstItem, pszSecondItem, pszThirdItem, pszFourthItem, pszReplaceItem, pszOutOfRangeItem};
382     
383 static char pszUniTestA[]  = "TST";
384 static WCHAR pszUniTestW[] = {'T','S','T',0};
385
386
387 #define TEST_GET_ITEM(i,c)\
388 {   res = getItem(hWndHeader, i, buffer);\
389     ok(res != 0, "Getting item[%d] using valid index failed unexpectedly (%d)\n", i, res);\
390     ok(strcmp(str_items[c], buffer) == 0, "Getting item[%d] returned \"%s\" expecting \"%s\"\n", i, buffer, str_items[c]);\
391 }
392
393 #define TEST_GET_ITEMCOUNT(i)\
394 {   res = getItemCount(hWndHeader);\
395     ok(res == i, "Got Item Count as %d\n", res);\
396 }
397
398 struct subclass_info
399 {
400     WNDPROC oldproc;
401 };
402
403 static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
404 {
405     struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
406     static long defwndproc_counter = 0;
407     LRESULT ret;
408     struct message msg;
409
410     trace("header: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
411     msg.message = message;
412     msg.flags = sent|wparam|lparam;
413     if (defwndproc_counter) msg.flags |= defwinproc;
414     msg.wParam = wParam;
415     msg.lParam = lParam;
416     add_message(sequences, HEADER_SEQ_INDEX, &msg);
417
418     defwndproc_counter++;
419     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
420     defwndproc_counter--;
421
422     return ret;
423 }
424
425 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
426 {
427     static long defwndproc_counter = 0;
428     LRESULT ret;
429     struct message msg;
430
431     /* do not log painting messages */
432     if (message != WM_PAINT &&
433         message != WM_ERASEBKGND &&
434         message != WM_NCPAINT &&
435         message != WM_NCHITTEST &&
436         message != WM_GETTEXT &&
437         message != WM_GETICON &&
438         message != WM_DEVICECHANGE)
439
440     {
441         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
442
443         msg.message = message;
444         msg.flags = sent|wparam|lparam;
445         if (defwndproc_counter) msg.flags |= defwinproc;
446         msg.wParam = wParam;
447         msg.lParam = lParam;
448         add_message(sequences, PARENT_SEQ_INDEX, &msg);
449    }
450
451     defwndproc_counter++;
452     ret = DefWindowProcA(hwnd, message, wParam, lParam);
453     defwndproc_counter--;
454
455     return ret;
456 }
457
458 static BOOL register_parent_wnd_class(void)
459 {
460     WNDCLASSA cls;
461
462     cls.style = 0;
463     cls.lpfnWndProc = parent_wnd_proc;
464     cls.cbClsExtra = 0;
465     cls.cbWndExtra = 0;
466     cls.hInstance = GetModuleHandleA(NULL);
467     cls.hIcon = 0;
468     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
469     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
470     cls.lpszMenuName = NULL;
471     cls.lpszClassName = "Header test parent class";
472     return RegisterClassA(&cls);
473 }
474
475 static HWND create_custom_parent_window(void)
476 {
477     if (!register_parent_wnd_class())
478         return NULL;
479
480     return CreateWindowExA(0, "Header test parent class", "Header Message Sequence Testing",
481                            WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
482                            672+2*GetSystemMetrics(SM_CXSIZEFRAME),
483                            226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
484                            NULL, NULL, GetModuleHandleA(NULL), 0);
485 }
486
487 static HWND create_custom_header_control(HWND hParent, BOOL preloadHeaderItems)
488 {
489     struct subclass_info *info;
490     HWND childHandle;
491     HDLAYOUT hlayout;
492     RECT rectwin;
493     WINDOWPOS winpos;
494     int retVal;
495     int loopcnt;
496     static char firstHeaderItem[] = "Name";
497     static char secondHeaderItem[] = "Size";
498     static char *items[] = {secondHeaderItem, firstHeaderItem};
499     HDITEM hdItem;
500     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
501     hdItem.fmt = HDF_LEFT;
502     hdItem.cxy = 80;
503     hdItem.cchTextMax = 260;
504
505
506     flush_sequences(sequences, NUM_MSG_SEQUENCES);
507     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
508     if (!info)
509          return NULL;
510
511     childHandle = CreateWindowEx(0, WC_HEADER, NULL,
512                            WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
513                            0, 0, 0, 0,
514                            hParent, NULL, NULL, NULL);
515     assert(childHandle);
516     if (preloadHeaderItems)
517     {
518          for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
519          {
520              hdItem.pszText = items[loopcnt];
521              retVal = SendMessage(childHandle, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
522              ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
523           }
524     }
525
526     if (winetest_interactive)
527        ShowWindow (hParent, SW_SHOW);
528
529     GetClientRect(hParent,&rectwin);
530     hlayout.prc = &rectwin;
531     hlayout.pwpos = &winpos;
532     SendMessageA(childHandle,HDM_LAYOUT,0,(LPARAM) &hlayout);
533     SetWindowPos(childHandle, winpos.hwndInsertAfter, winpos.x, winpos.y,
534                  winpos.cx, winpos.cy, 0);
535
536     info->oldproc = (WNDPROC)SetWindowLongPtrA(childHandle, GWLP_WNDPROC,
537                                                (LONG_PTR)header_subclass_proc);
538     SetWindowLongPtrA(childHandle, GWLP_USERDATA, (LONG_PTR)info);
539     return childHandle;
540 }
541
542 static void check_auto_format(void)
543 {
544     HDITEMA hdiCreate;
545     HDITEMA hdiRead;
546     static CHAR text[] = "Test";
547     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
548
549     /* Windows implicitly sets some format bits in INSERTITEM */
550
551     /* HDF_STRING is automatically set and cleared for no text */
552     hdiCreate.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
553     hdiCreate.pszText = text;
554     hdiCreate.cxy = 100;
555     hdiCreate.fmt=HDF_CENTER;
556     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
557     ok(hdiRead.fmt == (HDF_STRING|HDF_CENTER), "HDF_STRING not set automatically (fmt=%x)\n", hdiRead.fmt);
558
559     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
560     hdiCreate.pszText = text;
561     hdiCreate.fmt = HDF_CENTER|HDF_STRING;
562     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
563     ok(hdiRead.fmt == (HDF_CENTER), "HDF_STRING should be automatically cleared (fmt=%x)\n", hdiRead.fmt);
564
565     /* HDF_BITMAP is automatically set and cleared for a NULL bitmap or no bitmap */
566     hdiCreate.mask = HDI_BITMAP|HDI_WIDTH|HDI_FORMAT;
567     hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
568     hdiCreate.fmt = HDF_CENTER;
569     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
570     ok(hdiRead.fmt == (HDF_BITMAP|HDF_CENTER), "HDF_BITMAP not set automatically (fmt=%x)\n", hdiRead.fmt);
571     DeleteObject(hdiCreate.hbm);
572
573     hdiCreate.hbm = NULL;
574     hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
575     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
576     ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for NULL bitmap (fmt=%x)\n", hdiRead.fmt);
577
578     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
579     hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
580     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
581     ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for no bitmap (fmt=%x)\n", hdiRead.fmt);
582
583     /* HDF_IMAGE is automatically set but not cleared */
584     hdiCreate.mask = HDI_IMAGE|HDI_WIDTH|HDI_FORMAT;
585     hdiCreate.iImage = 17;
586     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
587     ok(hdiRead.fmt == (HDF_IMAGE|HDF_CENTER), "HDF_IMAGE not set automatically (fmt=%x)\n", hdiRead.fmt);
588
589     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
590     hdiCreate.fmt = HDF_CENTER|HDF_IMAGE;
591     hdiCreate.iImage = 0;
592     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
593     ok(hdiRead.fmt == (HDF_CENTER|HDF_IMAGE), "HDF_IMAGE shouldn't be cleared automatically (fmt=%x)\n", hdiRead.fmt);
594 }
595
596 static void check_auto_fields(void)
597 {
598     HDITEMA hdiCreate;
599     HDITEMA hdiRead;
600     static CHAR text[] = "Test";
601     LONG res;
602
603     /* Windows stores the format, width, lparam even if they are not in the item's mask */
604     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
605     hdiCreate.mask = HDI_TEXT;
606     hdiCreate.cxy = 100;
607     hdiCreate.pszText = text;
608     addReadDelItem(hWndHeader, &hdiCreate, HDI_WIDTH, &hdiRead);
609     TEST_GET_ITEMCOUNT(6);
610     ok(hdiRead.cxy == hdiCreate.cxy, "cxy should be automatically set\n");
611
612     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
613     hdiCreate.mask = HDI_TEXT;
614     hdiCreate.pszText = text;
615     hdiCreate.lParam = 0x12345678;
616     addReadDelItem(hWndHeader, &hdiCreate, HDI_LPARAM, &hdiRead);
617     TEST_GET_ITEMCOUNT(6);
618     ok(hdiRead.lParam == hdiCreate.lParam, "lParam should be automatically set\n");
619
620     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
621     hdiCreate.mask = HDI_TEXT;
622     hdiCreate.pszText = text;
623     hdiCreate.fmt = HDF_STRING|HDF_CENTER;
624     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
625     TEST_GET_ITEMCOUNT(6);
626     ok(hdiRead.fmt == hdiCreate.fmt, "fmt should be automatically set\n");
627
628     /* others fields are not set */
629     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
630     hdiCreate.mask = HDI_TEXT;
631     hdiCreate.pszText = text;
632     hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
633     addReadDelItem(hWndHeader, &hdiCreate, HDI_BITMAP, &hdiRead);
634     TEST_GET_ITEMCOUNT(6);
635     ok(hdiRead.hbm == NULL, "hbm should not be automatically set\n");
636     DeleteObject(hdiCreate.hbm);
637
638     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
639     hdiCreate.mask = HDI_IMAGE;
640     hdiCreate.iImage = 17;
641     hdiCreate.pszText = text;
642     addReadDelItem(hWndHeader, &hdiCreate, HDI_TEXT, &hdiRead);
643     TEST_GET_ITEMCOUNT(6);
644     ok(hdiRead.pszText==NULL, "pszText shouldn't be automatically set\n");
645
646     /* field from comctl >4.0 not tested as the system probably won't touch them */
647 }
648
649 static void check_mask(void)
650 {
651     HDITEMA hdi;
652     static CHAR text[] = "ABC";
653     LRESULT ret;
654
655     /* don't create items if the mask is zero */
656     ZeroMemory(&hdi, sizeof(hdi));
657     hdi.mask = 0;
658     hdi.cxy = 200;
659     hdi.pszText = text;
660     hdi.fmt = 0;
661     hdi.iOrder = 0;
662     hdi.lParam = 17;
663     hdi.cchTextMax = 260;
664     ret = SendMessage(hWndHeader, HDM_INSERTITEM, (WPARAM)0, (LPARAM)&hdi);
665     ok(ret == -1, "Creating an item with a zero mask should have failed\n");
666     if (ret != -1) SendMessage(hWndHeader, HDM_DELETEITEM, (WPARAM)0, (LPARAM)0);
667
668     /* with a non-zero mask creation will succeed */
669     ZeroMemory(&hdi, sizeof(hdi));
670     hdi.mask = HDI_LPARAM;
671     ret = SendMessage(hWndHeader, HDM_INSERTITEM, (WPARAM)0, (LPARAM)&hdi);
672     ok(ret != -1, "Adding item with non-zero mask failed\n");
673     if (ret != -1)
674         SendMessage(hWndHeader, HDM_DELETEITEM, (WPARAM)0, (LPARAM)0);
675
676     /* in SETITEM if the mask contains a unknown bit, it is ignored */
677     ZeroMemory(&hdi, sizeof(hdi));
678     hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
679     hdi.lParam = 133;
680     hdi.iImage = 17;
681     ret = SendMessage(hWndHeader, HDM_INSERTITEM, (WPARAM)0, (LPARAM)&hdi);
682     ok(ret != -1, "Adding item failed\n");
683
684     if (ret != -1)
685     {
686         /* check result */
687         ZeroMemory(&hdi, sizeof(hdi));
688         hdi.mask = HDI_LPARAM | HDI_IMAGE;
689         SendMessage(hWndHeader, HDM_GETITEM, (WPARAM)0, (LPARAM)&hdi);
690         ok(hdi.lParam == 133, "comctl32 4.0 field not set\n");
691         ok(hdi.iImage == 17, "comctl32 >4.0 field not set\n");
692
693         /* but in GETITEM if an unknown bit is set, comctl32 uses only version 4.0 fields */
694         ZeroMemory(&hdi, sizeof(hdi));
695         hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
696         SendMessage(hWndHeader, HDM_GETITEM, (WPARAM)0, (LPARAM)&hdi);
697         ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
698         ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");
699
700         SendMessage(hWndHeader, HDM_DELETEITEM, (WPARAM)0, (LPARAM)0);
701     }
702 }
703
704 static void test_header_control (void)
705 {
706     LONG res;
707     static char buffer[MAX_CHARS];
708     int i;
709
710     hWndHeader = create_header_control ();
711
712     for (i = 3; i >= 0; i--)
713     {
714         TEST_GET_ITEMCOUNT(3-i);
715         res = addItem(hWndHeader, 0, str_items[i]);
716         ok(res == 0, "Adding simple item failed (%d)\n", res);
717     }
718
719     TEST_GET_ITEMCOUNT(4);
720     res = addItem(hWndHeader, 99, str_items[i+1]);
721     ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
722     TEST_GET_ITEMCOUNT(5);
723     res = addItem(hWndHeader, 5, str_items[i+1]);
724     ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
725     TEST_GET_ITEMCOUNT(6);
726
727     for (i = 0; i < 4; i++) { TEST_GET_ITEM(i,i); TEST_GET_ITEMCOUNT(6); }
728
729     res=getItem(hWndHeader, 99, buffer);
730     ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
731     res=getItem(hWndHeader, 5, buffer);
732     ok(res == 1, "Getting Out of Range item should fail with 1 (%d), got %s\n", res,buffer);
733     res=getItem(hWndHeader, -2, buffer);
734     ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
735
736     if (winetest_interactive)
737     {
738         UpdateWindow(hHeaderParentWnd);
739         UpdateWindow(hWndHeader);
740     }
741
742     TEST_GET_ITEMCOUNT(6);
743     res=setItem(hWndHeader, 99, str_items[5], FALSE);
744     ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
745     res=setItem(hWndHeader, 5, str_items[5], TRUE);
746     ok(res == 1, "Setting Out of Range item should fail with 1 (%d)\n", res);
747     res=setItem(hWndHeader, -2, str_items[5], FALSE);
748     ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
749     TEST_GET_ITEMCOUNT(6);
750
751     for (i = 0; i < 4; i++)
752     {
753         res = setItem(hWndHeader, i, str_items[4], TRUE);
754         ok(res != 0, "Setting %d item failed (%d)\n", i+1, res);
755         TEST_GET_ITEM(i, 4);
756         TEST_GET_ITEMCOUNT(6);
757     }
758     
759     SendMessageA(hWndHeader, HDM_SETUNICODEFORMAT, (WPARAM)TRUE, 0);
760     setItemUnicodeNotify(hWndHeader, 3, pszUniTestA, pszUniTestW);
761     SendMessageA(hWndHeader, WM_NOTIFYFORMAT, (WPARAM)hHeaderParentWnd, (LPARAM)NF_REQUERY);
762     setItem(hWndHeader, 3, str_items[4], TRUE);
763     
764     dont_expect_notify(HDN_GETDISPINFOA);
765     dont_expect_notify(HDN_GETDISPINFOW);
766     addItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA);
767     setItem(hWndHeader, 0, str_items[4], TRUE);
768     /* unexpected notifies cleared by notifies_received in setItem */
769     dont_expect_notify(HDN_GETDISPINFOA);
770     dont_expect_notify(HDN_GETDISPINFOW);
771     setItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA, TRUE);
772     /* unexpected notifies cleared by notifies_received in setItem */
773     delItem(hWndHeader, 0);
774
775     check_auto_format();
776     TEST_GET_ITEMCOUNT(6);
777     check_auto_fields();
778     TEST_GET_ITEMCOUNT(6);
779     check_mask();
780     TEST_GET_ITEMCOUNT(6);
781
782     res = delItem(hWndHeader, 5);
783     ok(res == 1, "Deleting Out of Range item should fail with 1 (%d)\n", res);
784     res = delItem(hWndHeader, -2);
785     ok(res == 0, "Deleting Out of Range item should fail with 0 (%d)\n", res);
786     TEST_GET_ITEMCOUNT(5);
787
788     res = delItem(hWndHeader, 3);
789     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
790     TEST_GET_ITEMCOUNT(4);
791     res = delItem(hWndHeader, 0);
792     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
793     TEST_GET_ITEMCOUNT(3);
794     res = delItem(hWndHeader, 0);
795     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
796     TEST_GET_ITEMCOUNT(2);
797     res = delItem(hWndHeader, 0);
798     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
799     TEST_GET_ITEMCOUNT(1);
800
801     DestroyWindow(hWndHeader);
802 }
803
804 static void test_hdm_getitemrect(HWND hParent)
805 {
806
807     HWND hChild;
808     RECT rect;
809     int retVal;
810
811     flush_sequences(sequences, NUM_MSG_SEQUENCES);
812     hChild = create_custom_header_control(hParent, TRUE);
813     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
814                                     "adder header control to parent", FALSE);
815
816     retVal = SendMessage(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
817     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
818     /* check bounding rectangle information of 2nd header item */
819     expect(80, rect.left);
820     expect(0, rect.top);
821     expect(160, rect.right);
822     todo_wine
823     {
824       expect(18, rect.bottom);
825     }
826     retVal = SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
827
828     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
829     /* check bounding rectangle information of 1st header item */
830     expect(0, rect.left);
831     expect(0, rect.top);
832
833     expect(80, rect.right);
834     todo_wine
835     {
836       expect(18, rect.bottom);
837     }
838     retVal = SendMessage(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
839     ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
840
841     ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
842     DestroyWindow(hChild);
843 }
844
845 static void test_hdm_layout(HWND hParent)
846 {
847     HWND hChild;
848     int retVal;
849     RECT rect;
850     HDLAYOUT hdLayout;
851     WINDOWPOS windowPos;
852     hdLayout.prc = &rect;
853     hdLayout.pwpos = &windowPos;
854
855     flush_sequences(sequences, NUM_MSG_SEQUENCES);
856     hChild = create_custom_header_control(hParent, TRUE);
857     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
858                                     "adder header control to parent", FALSE);
859
860     flush_sequences(sequences, NUM_MSG_SEQUENCES);
861     retVal = SendMessage(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
862     expect(TRUE, retVal);
863
864     ok_sequence(sequences, HEADER_SEQ_INDEX, layout_seq, "layout sequence testing", FALSE);
865
866     DestroyWindow(hChild);
867 }
868
869 static void test_hdm_ordertoindex(HWND hParent)
870 {
871     HWND hChild;
872     int retVal;
873
874     flush_sequences(sequences, NUM_MSG_SEQUENCES);
875     hChild = create_custom_header_control(hParent, TRUE);
876     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
877                                     "adder header control to parent", FALSE);
878
879     flush_sequences(sequences, NUM_MSG_SEQUENCES);
880     retVal = SendMessage(hChild, HDM_ORDERTOINDEX, 1, 0);
881     expect(1, retVal);
882
883     ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
884     DestroyWindow(hChild);
885 }
886
887 static void test_hdm_hittest(HWND hParent)
888 {
889     HWND hChild;
890     int retVal;
891     POINT pt;
892     HDHITTESTINFO hdHitTestInfo;
893     const int firstItemRightBoundary = 80;
894     const int secondItemRightBoundary = 160;
895     const int bottomBoundary = 18;
896
897     pt.x = firstItemRightBoundary - 1;
898     pt.y = bottomBoundary - 1;
899     hdHitTestInfo.pt = pt;
900
901
902     flush_sequences(sequences, NUM_MSG_SEQUENCES);
903     hChild = create_custom_header_control(hParent, TRUE);
904     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
905                                     "adder header control to parent", FALSE);
906
907     flush_sequences(sequences, NUM_MSG_SEQUENCES);
908     retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
909     todo_wine
910     {
911       expect(0, retVal);
912       expect(0, hdHitTestInfo.iItem);
913     }
914
915     pt.x = secondItemRightBoundary - 1;
916     pt.y = bottomBoundary - 1;
917     hdHitTestInfo.pt = pt;
918     retVal = SendMessage(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
919     todo_wine
920     {
921       expect(1, retVal);
922     }
923     expect(1, hdHitTestInfo.iItem);
924
925     pt.x = secondItemRightBoundary;
926     pt.y = bottomBoundary + 1;
927     hdHitTestInfo.pt = pt;
928     todo_wine
929     {
930      retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
931      expect(-1, retVal);
932     }
933
934     ok_sequence(sequences, HEADER_SEQ_INDEX, hittest_seq, "hittest sequence testing", FALSE);
935
936     DestroyWindow(hChild);
937 }
938
939 static void test_hdm_sethotdivider(HWND hParent)
940 {
941     HWND hChild;
942     int retVal;
943     /*  low word: x coordinate = 5
944      *  high word:  y coordinate = 5
945      */
946
947     flush_sequences(sequences, NUM_MSG_SEQUENCES);
948     hChild = create_custom_header_control(hParent, TRUE);
949     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
950                                     "adder header control to parent", FALSE);
951
952     flush_sequences(sequences, NUM_MSG_SEQUENCES);
953     todo_wine
954     {
955         retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, TRUE, (LPARAM) 0X00050005);
956         expect(0, retVal);
957     }
958     retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
959     expect(100, retVal);
960     retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
961     expect(1, retVal);
962     if (winetest_interactive)
963        ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_interactive,
964                    "setHotDivider sequence testing", TRUE);
965     else
966        ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_noninteractive,
967                    "setHotDivider sequence testing", FALSE);
968
969     DestroyWindow(hChild);
970 }
971
972 static void test_hdm_imageMessages(HWND hParent)
973 {
974     HIMAGELIST hImageList = ImageList_Create (4, 4, 0, 1, 0);
975     HIMAGELIST hImageListRetVal;
976     HWND hChild;
977
978     flush_sequences(sequences, NUM_MSG_SEQUENCES);
979     hChild = create_custom_header_control(hParent, TRUE);
980     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
981                                     "adder header control to parent", FALSE);
982
983     flush_sequences(sequences, NUM_MSG_SEQUENCES);
984
985     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
986     ok(hImageListRetVal == NULL, "Expected NULL, got %d\n", (int) hImageListRetVal);
987
988     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_GETIMAGELIST, 0, 0);
989     ok(hImageListRetVal != NULL, "Expected non-NULL handle, got %d\n", (int) hImageListRetVal);
990
991     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
992     ok(hImageListRetVal != NULL, "Expected non-NULL handle, got %d\n", (int) hImageListRetVal);
993
994     ok_sequence(sequences, HEADER_SEQ_INDEX, imageMessages_seq, "imageMessages sequence testing", FALSE);
995
996     DestroyWindow(hChild);
997 }
998
999 static void test_hdm_filterMessages(HWND hParent)
1000 {
1001     HWND hChild;
1002     int retVal, timeout;
1003
1004     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1005     hChild = create_custom_header_control(hParent, TRUE);
1006     assert(hChild);
1007     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1008                                     "adder header control to parent", FALSE);
1009
1010     timeout = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1011     SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
1012
1013     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1014
1015     /* msdn incorrectly states that return value
1016      * is the index of the filter control being
1017      * modified. The sendMessage here should
1018      * return previous filter timeout value
1019      */
1020
1021     retVal = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1022     expect(timeout, retVal);
1023
1024     todo_wine
1025     {
1026         retVal = SendMessage(hChild, HDM_CLEARFILTER, 0, 1);
1027         expect(1, retVal);
1028         retVal = SendMessage(hChild, HDM_EDITFILTER, 1, 0);
1029         expect(1, retVal);
1030     }
1031     if (winetest_interactive)
1032          ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_interactive,
1033                      "filterMessages sequence testing", TRUE);
1034     else
1035          ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_noninteractive,
1036                      "filterMessages sequence testing", FALSE);
1037     DestroyWindow(hChild);
1038
1039 }
1040
1041 static void test_hdm_unicodeformatMessages(HWND hParent)
1042 {
1043     HWND hChild;
1044     int retVal;
1045
1046     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1047     hChild = create_custom_header_control(hParent, TRUE);
1048     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1049                                     "adder header control to parent", FALSE);
1050
1051     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1052     retVal = SendMessage(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
1053     expect(0, retVal);
1054     retVal = SendMessage(hChild, HDM_GETUNICODEFORMAT, 0, 0);
1055     expect(1, retVal);
1056
1057     ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
1058                      "unicodeformatMessages sequence testing", FALSE);
1059     DestroyWindow(hChild);
1060 }
1061
1062 static void test_hdm_bitmapmarginMessages(HWND hParent)
1063 {
1064     HWND hChild;
1065     int retVal;
1066
1067     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1068     hChild = create_custom_header_control(hParent, TRUE);
1069     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1070                                     "adder header control to parent", FALSE);
1071
1072     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1073     retVal = SendMessage(hChild, HDM_GETBITMAPMARGIN, 0, 0);
1074     expect(6, retVal);
1075
1076     ok_sequence(sequences, HEADER_SEQ_INDEX, bitmapmarginMessages_seq,
1077                       "bitmapmarginMessages sequence testing", FALSE);
1078     DestroyWindow(hChild);
1079 }
1080
1081 static void test_hdm_index_messages(HWND hParent)
1082 {
1083
1084     HWND hChild;
1085     int retVal;
1086     int loopcnt;
1087     int strcmpResult;
1088     int iSize;
1089     static const int lpiarray[2] = {1, 0};
1090     static int lpiarrayReceived[2];
1091     static char firstHeaderItem[] = "Name";
1092     static char secondHeaderItem[] = "Size";
1093     static char thirdHeaderItem[] = "Type";
1094     static char fourthHeaderItem[] = "Date Modified";
1095     static char *items[] = {firstHeaderItem, secondHeaderItem, thirdHeaderItem, fourthHeaderItem};
1096     HDITEM hdItem;
1097     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
1098     hdItem.fmt = HDF_LEFT;
1099     hdItem.cxy = 80;
1100     hdItem.cchTextMax = 260;
1101
1102     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1103     hChild = create_custom_header_control(hParent, FALSE);
1104     if (winetest_interactive)
1105          ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq_interactive,
1106                                               "adder header control to parent", TRUE);
1107     else
1108          ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1109                                      "adder header control to parent", FALSE);
1110     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1111     for ( loopcnt = 0 ; loopcnt < 4 ; loopcnt++ )
1112     {
1113       hdItem.pszText = items[loopcnt];
1114       retVal = SendMessage(hChild, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
1115       ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
1116     }
1117     ok_sequence(sequences, HEADER_SEQ_INDEX, insertItem_seq, "insertItem sequence testing", FALSE);
1118
1119     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1120
1121     retVal = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1122     ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
1123     retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, (LPARAM) &hdItem);
1124     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1125
1126     retVal = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1127     ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
1128     retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, (LPARAM) &hdItem);
1129     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1130
1131     retVal = SendMessage(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
1132     ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
1133     retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, (LPARAM) &hdItem);
1134     ok(retVal == 2, "Getting item count should return 2, got %d\n", retVal);
1135
1136     ok_sequence(sequences, HEADER_SEQ_INDEX, deleteItem_getItemCount_seq,
1137                          "deleteItem_getItemCount sequence testing", FALSE);
1138
1139     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1140
1141     retVal = SendMessage(hChild, HDM_GETITEM, 3, (LPARAM) &hdItem);
1142     ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);
1143
1144     retVal = SendMessage(hChild, HDM_GETITEM, 0, (LPARAM) &hdItem);
1145     ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
1146
1147     ok_sequence(sequences, HEADER_SEQ_INDEX, getItem_seq, "getItem sequence testing", FALSE);
1148
1149     /* check if the item is the right one */
1150     strcmpResult =  strcmp(hdItem.pszText, firstHeaderItem);
1151     expect(0, strcmpResult);
1152     expect(80, hdItem.cxy);
1153
1154     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1155
1156     iSize = SendMessage(hChild, HDM_GETITEMCOUNT, 0, (LPARAM) &hdItem);
1157     retVal = SendMessage(hChild, HDM_SETORDERARRAY, (WPARAM) iSize , (LPARAM) (LPINT) lpiarray );
1158     ok(retVal == TRUE, "Setting header items order should return TRUE, got %d\n", retVal);
1159
1160     retVal = SendMessage(hChild, HDM_GETORDERARRAY, (WPARAM) iSize, (LPARAM) (LPINT) lpiarrayReceived );
1161     ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
1162
1163     ok_sequence(sequences, HEADER_SEQ_INDEX, orderArray_seq, "set_get_orderArray sequence testing", FALSE);
1164
1165     /* check if the array order is set correctly and the size of the array is correct. */
1166     expect(2, iSize);
1167     expect(lpiarray[0], lpiarrayReceived[0]);
1168     expect(lpiarray[1], lpiarrayReceived[1]);
1169
1170     hdItem.mask = HDI_FORMAT;
1171     hdItem.fmt = HDF_CENTER | HDF_STRING;
1172
1173     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1174
1175     retVal = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM) &hdItem);
1176     ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
1177     hdItem.fmt = HDF_RIGHT | HDF_STRING;
1178     retVal = SendMessage(hChild, HDM_SETITEM, 1, (LPARAM) &hdItem);
1179     ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);
1180
1181     ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
1182     DestroyWindow(hChild);
1183 }
1184
1185 #define TEST_NMCUSTOMDRAW(draw_stage, item_spec, lparam, _left, _top, _right, _bottom) \
1186     ok(nm->dwDrawStage == draw_stage, "Invalid dwDrawStage %d vs %d\n", draw_stage, nm->dwDrawStage); \
1187     if (item_spec != -1) \
1188         ok(nm->dwItemSpec == item_spec, "Invalid dwItemSpec %d vs %ld\n", item_spec, nm->dwItemSpec); \
1189     ok(nm->lItemlParam == lparam, "Invalid lItemlParam %d vs %ld\n", lparam, nm->lItemlParam); \
1190     ok(nm->rc.top == _top && nm->rc.bottom == _bottom && nm->rc.left == _left && nm->rc.right == _right, \
1191         "Invalid rect (%d,%d) (%d,%d) vs (%d,%d) (%d,%d)\n", _left, _top, _right, _bottom, \
1192         nm->rc.left, nm->rc.top, nm->rc.right, nm->rc.bottom);
1193
1194 static LRESULT customdraw_1(int n, NMCUSTOMDRAW *nm)
1195 {
1196     if (nm == NULL) {  /* test ended */
1197         ok(n==1, "NM_CUSTOMDRAW messages: %d, expected: 1\n", n);
1198         return 0;
1199     }
1200
1201     switch (n)
1202     {
1203     case 0:
1204         /* don't test dwItemSpec - it's 0 no comctl5 but 1308756 on comctl6 */
1205         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, 18);
1206         return 0;
1207     }
1208
1209     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1210     return -1;
1211 }
1212
1213 static LRESULT customdraw_2(int n, NMCUSTOMDRAW *nm)
1214 {
1215     if (nm == NULL) {  /* test ended */
1216         ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1217         return 0;
1218     }
1219
1220     switch (n)
1221     {
1222     case 0:
1223         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, 18);
1224         return CDRF_NOTIFYITEMDRAW;
1225     case 1:
1226         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, 18);
1227         return 0;
1228     case 2:
1229         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, 18);
1230         return 0;
1231     case 3:
1232         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, 18);
1233         return 0;
1234     }
1235
1236     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1237     return 0;
1238 }
1239
1240 static LRESULT customdraw_3(int n, NMCUSTOMDRAW *nm)
1241 {
1242     if (nm == NULL) {  /* test ended */
1243         ok(n==5, "NM_CUSTOMDRAW messages: %d, expected: 5\n", n);
1244         return 0;
1245     }
1246
1247     switch (n)
1248     {
1249     case 0:
1250         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, 18);
1251         return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTERASE|CDRF_NOTIFYPOSTPAINT|CDRF_SKIPDEFAULT;
1252     case 1:
1253         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, 18);
1254         return 0;
1255     case 2:
1256         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, 18);
1257         return 0;
1258     case 3:
1259         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, 18);
1260         return 0;
1261     case 4:
1262         TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, 18);
1263         return 0;
1264     }
1265
1266     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1267     return 0;
1268 }
1269
1270
1271 static LRESULT customdraw_4(int n, NMCUSTOMDRAW *nm)
1272 {
1273     if (nm == NULL) {  /* test ended */
1274         ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1275         return 0;
1276     }
1277
1278     switch (n)
1279     {
1280     case 0:
1281         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, 18);
1282         return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
1283     case 1:
1284         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, 18);
1285         return 0;
1286     case 2:
1287         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, 18);
1288         return 0;
1289     case 3:
1290         TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, 18);
1291         return 0;
1292     }
1293
1294     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1295     return 0;
1296 }
1297
1298 static void run_customdraw_scenario(CUSTOMDRAWPROC proc)
1299 {
1300     g_CustomDrawProc = proc;
1301     g_CustomDrawCount = 0;
1302     InvalidateRect(hWndHeader, NULL, TRUE);
1303     UpdateWindow(hWndHeader);
1304     proc(g_CustomDrawCount, NULL);
1305     g_CustomDrawProc = NULL;
1306 }
1307
1308 static void test_customdraw(void)
1309 {
1310     int i;
1311     HDITEM item;
1312     RECT rect;
1313     CHAR name[] = "Test";
1314     hWndHeader = create_header_control();
1315     GetClientRect(hWndHeader, &rect);
1316     ok(rect.right - rect.left == 670 && rect.bottom - rect.top == 18,
1317         "Tests will fail as header size is %dx%d instead of 670x18\n",
1318         rect.right - rect.left, rect.bottom - rect.top);
1319
1320     for (i = 0; i < 3; i++)
1321     {
1322         ZeroMemory(&item, sizeof(item));
1323         item.mask = HDI_TEXT|HDI_WIDTH;
1324         item.cxy = 50*(i+1);
1325         item.pszText = name;
1326         item.lParam = i*5;
1327         SendMessage(hWndHeader, HDM_INSERTITEM, i, (LPARAM)&item);
1328     }
1329
1330     run_customdraw_scenario(customdraw_1);
1331     run_customdraw_scenario(customdraw_2);
1332     run_customdraw_scenario(customdraw_3);
1333
1334     ZeroMemory(&item, sizeof(item));
1335     item.mask = HDI_FORMAT;
1336     item.fmt = HDF_OWNERDRAW;
1337     SendMessage(hWndHeader, HDM_SETITEM, 1, (LPARAM)&item);
1338     g_DrawItem.CtlID = 0;
1339     g_DrawItem.CtlType = ODT_HEADER;
1340     g_DrawItem.hwndItem = hWndHeader;
1341     g_DrawItem.itemID = 1;
1342     g_DrawItem.itemState = 0;
1343     SendMessage(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
1344     run_customdraw_scenario(customdraw_4);
1345     ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
1346     DestroyWindow(hWndHeader);
1347     hWndHeader = NULL;
1348     g_DrawItem.CtlType = 0;
1349     g_DrawItemReceived = FALSE;
1350 }
1351
1352 static void check_order(const int expected_id[], const int expected_order[],
1353                         int count, const char *type)
1354 {
1355     int i;
1356     HDITEMA hdi;
1357
1358     ok(getItemCount(hWndHeader) == count, "Invalid item count in order tests\n");
1359     for (i = 0; i < count; i++)
1360     {
1361         hdi.mask = HDI_LPARAM|HDI_ORDER;
1362         SendMessage(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
1363         ok(hdi.lParam == expected_id[i],
1364             "Invalid item ids after '%s'- item %d has lParam %d\n", type, i, (int)hdi.lParam);
1365         ok(hdi.iOrder == expected_order[i],
1366             "Invalid item order after '%s'- item %d has iOrder %d\n", type, i, hdi.iOrder);
1367     }
1368 }
1369
1370 static void test_header_order (void)
1371 {
1372     const int rand1[] = {0, 1, 1, 0, 4};
1373     const int rand2[] = {4, 5, 6, 7, 4};
1374     const int rand3[] = {5, 5, 1, 6, 1};
1375     const int rand4[] = {1, 5, 2, 7, 6, 1, 4, 2, 3, 2};
1376     const int rand5[] = {7, 8, 5, 6, 7, 2, 1, 9, 10, 10};
1377     const int rand6[] = {2, 8, 3, 4, 0};
1378
1379     const int ids1[] = {3, 0, 2, 1, 4};
1380     const int ord1[] = {0, 1, 2, 3, 4};
1381     const int ids2[] = {3, 9, 7, 0, 2, 1, 4, 8, 6, 5};
1382     const int ord2[] = {0, 4, 7, 1, 2, 3, 9, 8, 6, 5};
1383     const int ord3[] = {0, 3, 9, 2, 1, 8, 7, 6, 5, 4};
1384     const int ids4[] = {9, 0, 1, 8, 6};
1385     const int ord4[] = {1, 0, 4, 3, 2};
1386
1387     char buffer[20];
1388     HDITEMA hdi;
1389     int i;
1390
1391     hWndHeader = create_header_control();
1392
1393     ZeroMemory(&hdi, sizeof(HDITEMA));
1394     hdi.mask = HDI_TEXT | HDI_LPARAM;
1395     hdi.pszText = buffer;
1396     strcpy(buffer, "test");
1397
1398     for (i = 0; i < 5; i++)
1399     {
1400         hdi.lParam = i;
1401         SendMessage(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
1402         rand();
1403     }
1404     check_order(ids1, ord1, 5, "insert without iOrder");
1405
1406     hdi.mask |= HDI_ORDER;
1407     for (i = 0; i < 5; i++)
1408     {
1409         hdi.lParam = i + 5;
1410         hdi.iOrder = rand2[i];
1411         SendMessage(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
1412         rand(); rand();
1413     }
1414     check_order(ids2, ord2, 10, "insert with order");
1415
1416     hdi.mask = HDI_ORDER;
1417     for (i=0; i<10; i++)
1418     {
1419         hdi.iOrder = rand5[i];
1420         SendMessage(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
1421         rand(); rand();
1422     }
1423     check_order(ids2, ord3, 10, "setitems changing order");
1424
1425     for (i=0; i<5; i++)
1426         SendMessage(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
1427     check_order(ids4, ord4, 5, "deleteitem");
1428
1429     DestroyWindow(hWndHeader);
1430 }
1431
1432 static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1433 {
1434     DRAWITEMSTRUCT *di;
1435     switch(msg) {
1436
1437     case WM_NOTIFY:
1438     {
1439         NMHEADERA *hdr = (NMHEADER *)lParam;
1440         EXPECTEDNOTIFY *expected;
1441         int i;
1442
1443         if (hdr->hdr.code == NM_CUSTOMDRAW)
1444             if (g_CustomDrawProc)
1445                 return g_CustomDrawProc(g_CustomDrawCount++, (NMCUSTOMDRAW*)hdr);
1446
1447         for (i=0; i<nUnexpectedNotify; i++)
1448             ok(hdr->hdr.code != unexpectedNotify[i], "Received invalid notify %d\n", hdr->hdr.code);
1449         
1450         if (nReceivedNotify >= nExpectedNotify || hdr->hdr.hwndFrom != hWndHeader )
1451             break;
1452
1453         expected = &expectedNotify[nReceivedNotify];
1454         if (hdr->hdr.code != expected->iCode)
1455             break;
1456         
1457         nReceivedNotify++;
1458         compare_items(hdr->hdr.code, &expected->hdItem, hdr->pitem, expected->fUnicode);
1459         break;
1460     }
1461
1462     case WM_DRAWITEM:
1463         di = (DRAWITEMSTRUCT *)lParam;
1464         ok(g_DrawItem.CtlType != 0, "Unexpected WM_DRAWITEM\n");
1465         if (g_DrawItem.CtlType == 0) return 0;
1466         g_DrawItemReceived = TRUE;
1467         compare(di->CtlType,   g_DrawItem.CtlType, "%d");
1468         compare(di->CtlID,     g_DrawItem.CtlID, "%d");
1469         compare(di->hwndItem,  g_DrawItem.hwndItem, "%p");
1470         compare(di->itemID,    g_DrawItem.itemID, "%d");
1471         compare(di->itemState, g_DrawItem.itemState, "%d");
1472         compare(di->rcItem.left,   g_DrawItem.rcItem.left, "%d");
1473         compare(di->rcItem.top,    g_DrawItem.rcItem.top, "%d");
1474         compare(di->rcItem.right,  g_DrawItem.rcItem.right, "%d");
1475         compare(di->rcItem.bottom, g_DrawItem.rcItem.bottom, "%d");
1476         break;
1477
1478     case WM_DESTROY:
1479         PostQuitMessage(0);
1480         break;
1481   
1482     default:
1483         return DefWindowProcA(hWnd, msg, wParam, lParam);
1484     }
1485     
1486     return 0L;
1487 }
1488
1489 static int init(void)
1490 {
1491     HMODULE hComctl32;
1492     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1493     WNDCLASSA wc;
1494     INITCOMMONCONTROLSEX iccex;
1495
1496     hComctl32 = GetModuleHandleA("comctl32.dll");
1497     pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
1498     if (!pInitCommonControlsEx)
1499     {
1500         skip("InitCommonControlsEx() is missing. Skipping the tests\n");
1501         return 0;
1502     }
1503
1504     iccex.dwSize = sizeof(iccex);
1505     iccex.dwICC  = ICC_USEREX_CLASSES;
1506     pInitCommonControlsEx(&iccex);
1507
1508     wc.style = CS_HREDRAW | CS_VREDRAW;
1509     wc.cbClsExtra = 0;
1510     wc.cbWndExtra = 0;
1511     wc.hInstance = GetModuleHandleA(NULL);
1512     wc.hIcon = NULL;
1513     wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
1514     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1515     wc.lpszMenuName = NULL;
1516     wc.lpszClassName = "HeaderTestClass";
1517     wc.lpfnWndProc = HeaderTestWndProc;
1518     RegisterClassA(&wc);
1519
1520     hHeaderParentWnd = CreateWindowExA(0, "HeaderTestClass", "Header test", WS_OVERLAPPEDWINDOW, 
1521       CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
1522       226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
1523       NULL, NULL, GetModuleHandleA(NULL), 0);
1524     assert(hHeaderParentWnd != NULL);
1525     ShowWindow(hHeaderParentWnd, SW_SHOW);
1526     return 1;
1527 }
1528
1529 START_TEST(header)
1530 {
1531     HWND parent_hwnd;
1532
1533     if (!init())
1534         return;
1535
1536     test_header_control();
1537     test_header_order();
1538     test_customdraw();
1539
1540     DestroyWindow(hHeaderParentWnd);
1541
1542     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1543     parent_hwnd = create_custom_parent_window();
1544     ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create parent windows", FALSE);
1545
1546     test_hdm_index_messages(parent_hwnd);
1547     test_hdm_getitemrect(parent_hwnd);
1548     test_hdm_hittest(parent_hwnd);
1549     test_hdm_layout(parent_hwnd);
1550     test_hdm_ordertoindex(parent_hwnd);
1551     test_hdm_sethotdivider(parent_hwnd);
1552     test_hdm_imageMessages(parent_hwnd);
1553     test_hdm_filterMessages(parent_hwnd);
1554     test_hdm_unicodeformatMessages(parent_hwnd);
1555     test_hdm_bitmapmarginMessages(parent_hwnd);
1556
1557     DestroyWindow(parent_hwnd);
1558
1559 }