dlls/comctl32/tests/pager.c

   1 /*
   2  * Unit tests for the pager control
   3  *
   4  * Copyright 2012 Alexandre Julliard
   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 #include <windows.h>
  22 #include <commctrl.h>
  23
  24 #include "wine/test.h"
  25 #include "msg.h"
  26
  27 #define NUM_MSG_SEQUENCES   1
  28 #define PAGER_SEQ_INDEX     0
  29
  30 static HWND parent_wnd, child1_wnd, child2_wnd;
  31 static INT notify_format;
  32 static BOOL notify_query_received;
  33 static const CHAR test_a[] = "test";
  34 static const WCHAR test_w[] = L"test";
  35 /* Double zero so that it's safe to cast it to WCHAR * */
  36 static const CHAR te_a[] = {'t', 'e', 0, 0};
  37 static const CHAR large_a[] =
  38     "You should have received a copy of the GNU Lesser General Public License along with this ...";
  39 static const WCHAR large_w[] =
  40     L"You should have received a copy of the GNU Lesser General Public License along with this ...";
  41 static const WCHAR large_truncated_65_w[65] =
  42     L"You should have received a copy of the GNU Lesser General Public";
  43 static const WCHAR large_truncated_80_w[80] =
  44     L"You should have received a copy of the GNU Lesser General Public License along w";
  45 static WCHAR buffer[64];
  46
  47 /* Text field conversion test behavior flags. */
  48 enum test_conversion_flags
  49 {
  50     CONVERT_SEND = 0x01,
  51     DONT_CONVERT_SEND = 0x02,
  52     CONVERT_RECEIVE = 0x04,
  53     DONT_CONVERT_RECEIVE = 0x08,
  54     SEND_EMPTY_IF_NULL = 0x10,
  55     DONT_SEND_EMPTY_IF_NULL = 0x20,
  56     SET_NULL_IF_NO_MASK = 0x40,
  57     ZERO_SEND = 0x80
  58 };
  59
  60 enum handler_ids
  61 {
  62     TVITEM_NEW_HANDLER,
  63     TVITEM_OLD_HANDLER
  64 };
  65
  66 static struct notify_test_info
  67 {
  68     UINT unicode;
  69     UINT ansi;
  70     UINT_PTR id_from;
  71     HWND hwnd_from;
  72     /* Whether parent received notification */
  73     BOOL received;
  74     UINT test_id;
  75     UINT sub_test_id;
  76     UINT handler_id;
  77     /* Text field conversion test behavior flag */
  78     DWORD flags;
  79 } notify_test_info;
  80
  81 struct notify_test_send
  82 {
  83     /* Data sent to pager */
  84     const WCHAR *send_text;
  85     INT send_text_size;
  86     INT send_text_max;
  87     /* Data expected by parent of pager */
  88     const void *expect_text;
  89 };
  90
  91 struct notify_test_receive
  92 {
  93     /* Data sent to pager */
  94     const WCHAR *send_text;
  95     INT send_text_size;
  96     INT send_text_max;
  97     /* Data for parent to write */
  98     const CHAR *write_pointer;
  99     const CHAR *write_text;
 100     INT write_text_size;
 101     INT write_text_max;
 102     /* Data when message returned */
 103     const void *return_text;
 104     INT return_text_max;
 105 };
 106
 107 struct generic_text_helper_para
 108 {
 109     void *ptr;
 110     size_t size;
 111     UINT *mask;
 112     UINT required_mask;
 113     WCHAR **text;
 114     INT *text_max;
 115     UINT code_unicode;
 116     UINT code_ansi;
 117     DWORD flags;
 118     UINT handler_id;
 119 };
 120
 121 static const struct notify_test_send test_convert_send_data[] =
 122 {
 123     {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_a}
 124 };
 125
 126 static const struct notify_test_send test_dont_convert_send_data[] =
 127 {
 128     {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_w}
 129 };
 130
 131 static const struct notify_test_receive test_convert_receive_data[] =
 132 {
 133     {L"", sizeof(L""), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_w, ARRAY_SIZE(buffer)},
 134     {L"", sizeof(L""), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_w, ARRAY_SIZE(buffer)},
 135     {NULL, sizeof(L""), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, NULL, ARRAY_SIZE(buffer)},
 136     {L"", sizeof(L""), ARRAY_SIZE(buffer), large_a, NULL, 0, -1, large_truncated_65_w, ARRAY_SIZE(buffer)},
 137     {L"", sizeof(L""), ARRAY_SIZE(buffer), "", 0, 0, 1, L"", 1},
 138 };
 139
 140 static const struct notify_test_receive test_dont_convert_receive_data[] =
 141 {
 142     {L"", sizeof(L""), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_a, ARRAY_SIZE(buffer)},
 143     {L"", sizeof(L""), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_a, ARRAY_SIZE(buffer)},
 144 };
 145
 146 static const struct notify_test_tooltip
 147 {
 148     /* Data for parent to write */
 149     const CHAR *write_sztext;
 150     INT write_sztext_size;
 151     const CHAR *write_lpsztext;
 152     HMODULE write_hinst;
 153     /* Data when message returned */
 154     const WCHAR *return_sztext;
 155     INT return_sztext_size;
 156     const WCHAR *return_lpsztext;
 157     HMODULE return_hinst;
 158     /* Data expected by parent */
 159     const CHAR *expect_sztext;
 160     /* Data send to parent */
 161     const WCHAR *send_sztext;
 162     INT send_sztext_size;
 163     const WCHAR *send_lpsztext;
 164 } test_tooltip_data[] =
 165 {
 166     {NULL, 0, NULL, NULL, L"", -1, L""},
 167     {test_a, sizeof(test_a), NULL, NULL, test_w, -1, test_w},
 168     {test_a, sizeof(test_a), test_a, NULL, test_w, -1, test_w},
 169     {test_a, sizeof(test_a), (CHAR *)1, (HMODULE)0xdeadbeef, L"", -1, (WCHAR *)1, (HMODULE)0xdeadbeef},
 170     {test_a, sizeof(test_a), test_a, (HMODULE)0xdeadbeef, test_w, -1, test_w, (HMODULE)0xdeadbeef},
 171     {NULL, 0, test_a, NULL, test_w, -1, test_w},
 172     {test_a, 2, test_a, NULL, test_w, -1, test_w},
 173     {NULL, 0, NULL, NULL, test_w, -1, test_w, NULL, test_a, test_w, sizeof(test_w)},
 174     {NULL, 0, NULL, NULL, L"", -1, L"", NULL, "", NULL, 0, test_w},
 175     {NULL, 0, large_a, NULL, large_truncated_80_w, sizeof(large_truncated_80_w), large_w}
 176 };
 177
 178 static const struct notify_test_datetime_format
 179 {
 180     /* Data send to parent */
 181     const WCHAR *send_pszformat;
 182     /* Data expected by parent */
 183     const CHAR *expect_pszformat;
 184     /* Data for parent to write */
 185     const CHAR *write_szdisplay;
 186     INT write_szdisplay_size;
 187     const CHAR *write_pszdisplay;
 188     /* Data when message returned */
 189     const WCHAR *return_szdisplay;
 190     INT return_szdisplay_size;
 191     const WCHAR *return_pszdisplay;
 192 } test_datetime_format_data[] =
 193 {
 194     {test_w, test_a},
 195     {NULL, NULL, NULL, 0, test_a, L"", -1, test_w},
 196     {NULL, NULL, test_a, sizeof(test_a), NULL, test_w, -1, test_w},
 197     {NULL, NULL, test_a, 2, test_a, (WCHAR *)te_a, -1, test_w},
 198     {NULL, NULL, NULL, 0, large_a, NULL, 0, large_w}
 199 };
 200
 201 #define CHILD1_ID 1
 202 #define CHILD2_ID 2
 203
 204 static BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
 205 static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR);
 206
 207 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
 208
 209 static const struct message set_child_seq[] = {
 210     { PGM_SETCHILD, sent },
 211     { WM_WINDOWPOSCHANGING, sent },
 212     { WM_NCCALCSIZE, sent|wparam, TRUE },
 213     { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
 214     { WM_WINDOWPOSCHANGED, sent },
 215     { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD1_ID },
 216     { WM_NCCALCSIZE, sent|wparam|id|optional, TRUE, 0, CHILD1_ID },
 217     { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD1_ID },
 218     { WM_WINDOWPOSCHANGED, sent|id, 0, 0, CHILD1_ID },
 219     { WM_SIZE, sent|id|defwinproc|optional, 0, 0, CHILD1_ID },
 220     { 0 }
 221 };
 222
 223 /* This differs from the above message list only in the child window that is
 224  * expected to receive the child messages. No message is sent to the old child.
 225  * Also child 2 is hidden while child 1 is visible. The pager does not make the
 226  * hidden child visible. */
 227 static const struct message switch_child_seq[] = {
 228     { PGM_SETCHILD, sent },
 229     { WM_WINDOWPOSCHANGING, sent },
 230     { WM_NCCALCSIZE, sent|wparam, TRUE },
 231     { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
 232     { WM_WINDOWPOSCHANGED, sent },
 233     { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD2_ID },
 234     { WM_NCCALCSIZE, sent|wparam|id, TRUE, 0, CHILD2_ID },
 235     { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD2_ID },
 236     { WM_WINDOWPOSCHANGED, sent|id, 0, 0, CHILD2_ID },
 237     { WM_SIZE, sent|id|defwinproc, 0, 0, CHILD2_ID },
 238     { 0 }
 239 };
 240
 241 static const struct message set_pos_seq[] = {
 242     { PGM_SETPOS, sent },
 243     { WM_WINDOWPOSCHANGING, sent },
 244     { WM_NCCALCSIZE, sent|wparam, TRUE },
 245     { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
 246     { WM_WINDOWPOSCHANGED, sent },
 247     { WM_MOVE, sent|optional },
 248     /* The WM_SIZE handler sends WM_WINDOWPOSCHANGING, WM_CHILDACTIVATE
 249      * and WM_WINDOWPOSCHANGED (which sends WM_MOVE) to the child.
 250      * Another WM_WINDOWPOSCHANGING is sent afterwards.
 251      *
 252      * The 2nd WM_WINDOWPOSCHANGING is unconditional, but the comparison
 253      * function is too simple to roll back an accepted message, so we have
 254      * to mark the 2nd message optional. */
 255     { WM_SIZE, sent|optional },
 256     { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD1_ID }, /* Actually optional. */
 257     { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD1_ID }, /* Actually optional. */
 258     { WM_WINDOWPOSCHANGED, sent|id|optional, TRUE, 0, CHILD1_ID},
 259     { WM_MOVE, sent|id|optional|defwinproc, 0, 0, CHILD1_ID },
 260     { WM_WINDOWPOSCHANGING, sent|id|optional, 0, 0, CHILD1_ID }, /* Actually not optional. */
 261     { WM_CHILDACTIVATE, sent|id|optional, 0, 0, CHILD1_ID }, /* Actually not optional. */
 262     { 0 }
 263 };
 264
 265 static const struct message set_pos_empty_seq[] = {
 266     { PGM_SETPOS, sent },
 267     { 0 }
 268 };
 269
 270 static CHAR *heap_strdup(const CHAR *str)
 271 {
 272     int len = lstrlenA(str) + 1;
 273     CHAR *ret = heap_alloc(len * sizeof(CHAR));
 274     lstrcpyA(ret, str);
 275     return ret;
 276 }
 277
 278 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 279 {
 280     static LONG defwndproc_counter = 0;
 281     LRESULT ret;
 282     struct message msg;
 283
 284     /* log system messages, except for painting */
 285     if (message < WM_USER &&
 286         message != WM_PAINT &&
 287         message != WM_ERASEBKGND &&
 288         message != WM_NCPAINT &&
 289         message != WM_NCHITTEST &&
 290         message != WM_GETTEXT &&
 291         message != WM_GETICON &&
 292         message != WM_DEVICECHANGE)
 293     {
 294         msg.message = message;
 295         msg.flags = sent|wparam|lparam|parent;
 296         if (defwndproc_counter) msg.flags |= defwinproc;
 297         msg.wParam = wParam;
 298         msg.lParam = lParam;
 299         if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
 300         add_message(sequences, PAGER_SEQ_INDEX, &msg);
 301     }
 302
 303     if (message == WM_NOTIFY)
 304     {
 305         NMHDR *nmhdr = (NMHDR *)lParam;
 306
 307         switch (nmhdr->code)
 308         {
 309             case PGN_CALCSIZE:
 310             {
 311                 NMPGCALCSIZE *nmpgcs = (NMPGCALCSIZE *)lParam;
 312                 DWORD style = GetWindowLongA(nmpgcs->hdr.hwndFrom, GWL_STYLE);
 313
 314                 if (style & PGS_HORZ)
 315                     ok(nmpgcs->dwFlag == PGF_CALCWIDTH, "Unexpected flags %#x.\n", nmpgcs->dwFlag);
 316                 else
 317                     ok(nmpgcs->dwFlag == PGF_CALCHEIGHT, "Unexpected flags %#x.\n", nmpgcs->dwFlag);
 318                 break;
 319             }
 320             default:
 321                 ;
 322         }
 323     }
 324
 325     defwndproc_counter++;
 326     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 327     defwndproc_counter--;
 328
 329     return ret;
 330 }
 331
 332 static BOOL register_parent_wnd_class(void)
 333 {
 334     WNDCLASSA cls;
 335
 336     cls.style = 0;
 337     cls.lpfnWndProc = parent_wnd_proc;
 338     cls.cbClsExtra = 0;
 339     cls.cbWndExtra = 0;
 340     cls.hInstance = GetModuleHandleA(NULL);
 341     cls.hIcon = 0;
 342     cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
 343     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 344     cls.lpszMenuName = NULL;
 345     cls.lpszClassName = "Pager test parent class";
 346     return RegisterClassA(&cls);
 347 }
 348
 349 static HWND create_parent_window(void)
 350 {
 351     if (!register_parent_wnd_class())
 352         return NULL;
 353
 354     return CreateWindowA("Pager test parent class", "Pager test parent window",
 355                         WS_OVERLAPPED | WS_VISIBLE,
 356                         0, 0, 200, 200, 0, NULL, GetModuleHandleA(NULL), NULL );
 357 }
 358
 359 static LRESULT WINAPI pager_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 360 {
 361     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 362     struct message msg = { 0 };
 363
 364     msg.message = message;
 365     msg.flags = sent|wparam|lparam;
 366     msg.wParam = wParam;
 367     msg.lParam = lParam;
 368     add_message(sequences, PAGER_SEQ_INDEX, &msg);
 369     return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 370 }
 371
 372 static HWND create_pager_control( DWORD style )
 373 {
 374     WNDPROC oldproc;
 375     HWND hwnd;
 376     RECT rect;
 377
 378     GetClientRect( parent_wnd, &rect );
 379     hwnd = CreateWindowA( WC_PAGESCROLLERA, "pager", WS_CHILD | WS_BORDER | WS_VISIBLE | style,
 380                           0, 0, 100, 100, parent_wnd, 0, GetModuleHandleA(0), 0 );
 381     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)pager_subclass_proc);
 382     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 383     return hwnd;
 384 }
 385
 386 static LRESULT WINAPI child_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 387 {
 388     static LONG defwndproc_counter;
 389     struct message msg = { 0 };
 390     LRESULT ret;
 391
 392     msg.message = message;
 393     msg.flags = sent | wparam | lparam;
 394     if (defwndproc_counter)
 395         msg.flags |= defwinproc;
 396     msg.wParam = wParam;
 397     msg.lParam = lParam;
 398
 399     if (hwnd == child1_wnd)
 400         msg.id = CHILD1_ID;
 401     else if (hwnd == child2_wnd)
 402         msg.id = CHILD2_ID;
 403     else
 404         msg.id = 0;
 405
 406     add_message(sequences, PAGER_SEQ_INDEX, &msg);
 407
 408     defwndproc_counter++;
 409     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 410     defwndproc_counter--;
 411
 412     return ret;
 413 }
 414
 415 static BOOL register_child_wnd_class(void)
 416 {
 417     WNDCLASSA cls;
 418
 419     cls.style = 0;
 420     cls.lpfnWndProc = child_proc;
 421     cls.cbClsExtra = 0;
 422     cls.cbWndExtra = 0;
 423     cls.hInstance = GetModuleHandleA(NULL);
 424     cls.hIcon = 0;
 425     cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
 426     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 427     cls.lpszMenuName = NULL;
 428     cls.lpszClassName = "Pager test child class";
 429     return RegisterClassA(&cls);
 430 }
 431
 432 static void test_pager(void)
 433 {
 434     HWND pager;
 435     RECT rect, rect2;
 436
 437     pager = create_pager_control( PGS_HORZ );
 438     ok(pager != NULL, "Fail to create pager\n");
 439
 440     register_child_wnd_class();
 441
 442     child1_wnd = CreateWindowA( "Pager test child class", "button", WS_CHILD | WS_BORDER | WS_VISIBLE, 0, 0, 300, 300,
 443                            pager, 0, GetModuleHandleA(0), 0 );
 444     child2_wnd = CreateWindowA("Pager test child class", "button", WS_CHILD | WS_BORDER, 0, 0, 300, 300,
 445         pager, 0, GetModuleHandleA(0), 0);
 446
 447     flush_sequences( sequences, NUM_MSG_SEQUENCES );
 448     SendMessageA( pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd );
 449     ok_sequence(sequences, PAGER_SEQ_INDEX, set_child_seq, "set child", FALSE);
 450     GetWindowRect( pager, &rect );
 451     ok( rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
 452         "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top );
 453
 454     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 455     SendMessageA(pager, PGM_SETCHILD, 0, (LPARAM)child2_wnd);
 456     ok_sequence(sequences, PAGER_SEQ_INDEX, switch_child_seq, "switch to invisible child", FALSE);
 457     GetWindowRect(pager, &rect);
 458     ok(rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
 459         "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top);
 460     ok(!IsWindowVisible(child2_wnd), "Child window 2 is visible\n");
 461
 462     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 463     SendMessageA(pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd);
 464     ok_sequence(sequences, PAGER_SEQ_INDEX, set_child_seq, "switch to visible child", FALSE);
 465     GetWindowRect(pager, &rect);
 466     ok(rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
 467         "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top);
 468
 469     flush_sequences( sequences, NUM_MSG_SEQUENCES );
 470     SendMessageA( pager, PGM_SETPOS, 0, 10 );
 471     ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_seq, "set pos", TRUE);
 472     GetWindowRect( pager, &rect );
 473     ok( rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
 474         "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top );
 475
 476     flush_sequences( sequences, NUM_MSG_SEQUENCES );
 477     SendMessageA( pager, PGM_SETPOS, 0, 10 );
 478     ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_empty_seq, "set pos empty", TRUE);
 479
 480     flush_sequences( sequences, NUM_MSG_SEQUENCES );
 481     SendMessageA( pager, PGM_SETPOS, 0, 9 );
 482     ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_seq, "set pos", TRUE);
 483
 484     DestroyWindow( pager );
 485
 486     /* Test if resizing works */
 487     pager = create_pager_control( CCS_NORESIZE );
 488     ok(pager != NULL, "failed to create pager control\n");
 489
 490     GetWindowRect( pager, &rect );
 491     MoveWindow( pager, 0, 0, 200, 100, TRUE );
 492     GetWindowRect( pager, &rect2 );
 493     ok(rect2.right - rect2.left > rect.right - rect.left, "expected pager window to resize, %s\n",
 494         wine_dbgstr_rect( &rect2 ));
 495
 496     DestroyWindow( pager );
 497
 498     pager = create_pager_control( CCS_NORESIZE | PGS_HORZ );
 499     ok(pager != NULL, "failed to create pager control\n");
 500
 501     GetWindowRect( pager, &rect );
 502     MoveWindow( pager, 0, 0, 100, 200, TRUE );
 503     GetWindowRect( pager, &rect2 );
 504     ok(rect2.bottom - rect2.top > rect.bottom - rect.top, "expected pager window to resize, %s\n",
 505         wine_dbgstr_rect( &rect2 ));
 506
 507     DestroyWindow( pager );
 508 }
 509
 510 static LRESULT WINAPI test_notifyformat_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 511 {
 512     switch (message)
 513     {
 514     case WM_NOTIFYFORMAT:
 515         if (lParam == NF_QUERY)
 516         {
 517             notify_query_received = TRUE;
 518             return notify_format;
 519         }
 520         else if (lParam == NF_REQUERY)
 521             return SendMessageA(GetParent(hwnd), WM_NOTIFYFORMAT, (WPARAM)hwnd, NF_QUERY);
 522         else
 523             return 0;
 524     default:
 525         return notify_format == NFR_UNICODE ? DefWindowProcW(hwnd, message, wParam, lParam)
 526                                             : DefWindowProcA(hwnd, message, wParam, lParam);
 527     }
 528 }
 529
 530 static BOOL register_notifyformat_class(void)
 531 {
 532     WNDCLASSW cls = {0};
 533
 534     cls.lpfnWndProc = test_notifyformat_proc;
 535     cls.hInstance = GetModuleHandleW(NULL);
 536     cls.lpszClassName = L"Pager notifyformat class";
 537     return RegisterClassW(&cls);
 538 }
 539
 540 static void test_wm_notifyformat(void)
 541 {
 542     static const INT formats[] = {NFR_UNICODE, NFR_ANSI};
 543     HWND parent, pager, child;
 544     LRESULT ret;
 545     BOOL bret;
 546     INT i;
 547
 548     bret = register_notifyformat_class();
 549     ok(bret, "Register test class failed, error 0x%08x\n", GetLastError());
 550
 551     for (i = 0; i < ARRAY_SIZE(formats); i++)
 552     {
 553         notify_format = formats[i];
 554         parent = CreateWindowW(L"Pager notifyformat class", L"parent", WS_OVERLAPPED, 0, 0, 100, 100, 0, 0, GetModuleHandleW(0), 0);
 555         ok(parent != NULL, "CreateWindow failed\n");
 556         pager = CreateWindowW(WC_PAGESCROLLERW, L"pager", WS_CHILD, 0, 0, 100, 100, parent, 0, GetModuleHandleW(0), 0);
 557         ok(pager != NULL, "CreateWindow failed\n");
 558         child = CreateWindowW(L"Pager notifyformat class", L"child", WS_CHILD, 0, 0, 100, 100, pager, 0, GetModuleHandleW(0), 0);
 559         ok(child != NULL, "CreateWindow failed\n");
 560         SendMessageW(pager, PGM_SETCHILD, 0, (LPARAM)child);
 561
 562         /* Test parent */
 563         notify_query_received = FALSE;
 564         ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)parent, NF_REQUERY);
 565         ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
 566         ok(notify_query_received, "Didn't receive notify\n");
 567
 568         /* Send NF_QUERY directly to parent */
 569         notify_query_received = FALSE;
 570         ret = SendMessageW(parent, WM_NOTIFYFORMAT, (WPARAM)pager, NF_QUERY);
 571         ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
 572         ok(notify_query_received, "Didn't receive notify\n");
 573
 574         /* Pager send notifications to its parent regardless of wParam */
 575         notify_query_received = FALSE;
 576         ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)parent_wnd, NF_REQUERY);
 577         ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
 578         ok(notify_query_received, "Didn't receive notify\n");
 579
 580         /* Pager always wants Unicode notifications from children */
 581         ret = SendMessageW(child, WM_NOTIFYFORMAT, (WPARAM)pager, NF_REQUERY);
 582         ok(ret == NFR_UNICODE, "Expect %d, got %ld\n", NFR_UNICODE, ret);
 583         ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)child, NF_QUERY);
 584         ok(ret == NFR_UNICODE, "Expect %d, got %ld\n", NFR_UNICODE, ret);
 585
 586         DestroyWindow(parent);
 587     }
 588
 589     UnregisterClassW(L"Pager notifyformat class", GetModuleHandleW(NULL));
 590 }
 591
 592 static void notify_generic_text_handler(CHAR **text, INT *text_max)
 593 {
 594     const struct notify_test_send *send_data;
 595     const struct notify_test_receive *receive_data;
 596
 597     switch (notify_test_info.test_id)
 598     {
 599     case CONVERT_SEND:
 600     case DONT_CONVERT_SEND:
 601     {
 602         send_data = (notify_test_info.test_id == CONVERT_SEND ? test_convert_send_data : test_dont_convert_send_data)
 603                     + notify_test_info.sub_test_id;
 604         if (notify_test_info.flags & ZERO_SEND)
 605             ok(!*text[0], "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n",
 606                notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text);
 607         else if (notify_test_info.flags & CONVERT_SEND)
 608             ok(!lstrcmpA(send_data->expect_text, *text), "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n",
 609                notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
 610                (CHAR *)send_data->expect_text, *text);
 611         else
 612             ok(!lstrcmpW((WCHAR *)send_data->expect_text, (WCHAR *)*text),
 613                "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n", notify_test_info.unicode,
 614                notify_test_info.test_id, notify_test_info.sub_test_id, wine_dbgstr_w((WCHAR *)send_data->expect_text),
 615                wine_dbgstr_w((WCHAR *)*text));
 616         if (text_max)
 617             ok(*text_max == send_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n",
 618                notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
 619                send_data->send_text_max, *text_max);
 620         break;
 621     }
 622     case CONVERT_RECEIVE:
 623     case DONT_CONVERT_RECEIVE:
 624     {
 625         receive_data = (notify_test_info.test_id == CONVERT_RECEIVE ? test_convert_receive_data : test_dont_convert_receive_data)
 626                        + notify_test_info.sub_test_id;
 627         if (text_max)
 628             ok(*text_max == receive_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n",
 629                notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
 630                receive_data->send_text_max, *text_max);
 631
 632         if (receive_data->write_text)
 633             memcpy(*text, receive_data->write_text, receive_data->write_text_size);
 634         /* 64bit Windows will try to free the text pointer even if it's application provided when handling
 635          * HDN_GETDISPINFOW. Deliberate leak here. */
 636         else if(notify_test_info.unicode == HDN_GETDISPINFOW)
 637             *text = heap_strdup(receive_data->write_pointer);
 638         else
 639             *text = (char *)receive_data->write_pointer;
 640         if (text_max && receive_data->write_text_max != -1) *text_max = receive_data->write_text_max;
 641         break;
 642     }
 643     case SEND_EMPTY_IF_NULL:
 644         ok(!*text[0], "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n",
 645            notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text);
 646         break;
 647     case DONT_SEND_EMPTY_IF_NULL:
 648         ok(!*text, "Code 0x%08x test 0x%08x sub test %d expect null text\n", notify_test_info.unicode,
 649            notify_test_info.test_id, notify_test_info.sub_test_id);
 650         break;
 651     }
 652 }
 653
 654 static void notify_tooltip_handler(NMTTDISPINFOA *nm)
 655 {
 656     const struct notify_test_tooltip *data = test_tooltip_data + notify_test_info.sub_test_id;
 657     ok(nm->lpszText == nm->szText, "Sub test %d expect %p, got %p\n", notify_test_info.sub_test_id, nm->szText,
 658        nm->lpszText);
 659     if (data->expect_sztext)
 660         ok(!lstrcmpA(data->expect_sztext, nm->szText), "Sub test %d expect %s, got %s\n", notify_test_info.sub_test_id,
 661            data->expect_sztext, nm->szText);
 662     if (data->write_sztext) memcpy(nm->szText, data->write_sztext, data->write_sztext_size);
 663     if (data->write_lpsztext) nm->lpszText = (char *)data->write_lpsztext;
 664     if (data->write_hinst) nm->hinst = data->write_hinst;
 665 }
 666
 667 static void notify_datetime_handler(NMDATETIMEFORMATA *nm)
 668 {
 669     const struct notify_test_datetime_format *data = test_datetime_format_data + notify_test_info.sub_test_id;
 670     if (data->expect_pszformat)
 671         ok(!lstrcmpA(data->expect_pszformat, nm->pszFormat), "Sub test %d expect %s, got %s\n",
 672            notify_test_info.sub_test_id, data->expect_pszformat, nm->pszFormat);
 673     ok(nm->pszDisplay == nm->szDisplay, "Test %d expect %p, got %p\n", notify_test_info.sub_test_id, nm->szDisplay,
 674        nm->pszDisplay);
 675     if (data->write_szdisplay) memcpy(nm->szDisplay, data->write_szdisplay, data->write_szdisplay_size);
 676     if (data->write_pszdisplay) nm->pszDisplay = data->write_pszdisplay;
 677 }
 678
 679 static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 680 {
 681     switch (message)
 682     {
 683     case WM_NOTIFY:
 684     {
 685         NMHDR *hdr = (NMHDR *)lParam;
 686
 687         /* Not notifications we want to test */
 688         if (!notify_test_info.unicode) break;
 689         ok(!notify_test_info.received, "Extra notification received\n");
 690
 691         ok(wParam == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam);
 692         ok(hdr->code == notify_test_info.ansi, "Expect 0x%08x, got 0x%08x\n", notify_test_info.ansi, hdr->code);
 693         ok(hdr->idFrom == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam);
 694         ok(hdr->hwndFrom == notify_test_info.hwnd_from, "Expect %p, got %p\n", notify_test_info.hwnd_from, hdr->hwndFrom);
 695
 696         if (hdr->code != notify_test_info.ansi)
 697         {
 698             skip("Notification code mismatch, skipping lParam check\n");
 699             return 0;
 700         }
 701         switch (hdr->code)
 702         {
 703         /* ComboBoxEx */
 704         case CBEN_INSERTITEM:
 705         case CBEN_DELETEITEM:
 706         {
 707             NMCOMBOBOXEXW *nmcbe = (NMCOMBOBOXEXW *)hdr;
 708             notify_generic_text_handler((CHAR **)&nmcbe->ceItem.pszText, NULL);
 709             break;
 710         }
 711         case CBEN_DRAGBEGINA:
 712         {
 713             NMCBEDRAGBEGINA *nmcbedb = (NMCBEDRAGBEGINA *)hdr;
 714             ok(!lstrcmpA(nmcbedb->szText, test_a), "Expect %s, got %s\n", nmcbedb->szText, test_a);
 715             break;
 716         }
 717         case CBEN_ENDEDITA:
 718         {
 719             NMCBEENDEDITA *nmcbeed = (NMCBEENDEDITA *)hdr;
 720             ok(!lstrcmpA(nmcbeed->szText, test_a), "Expect %s, got %s\n", nmcbeed->szText, test_a);
 721             break;
 722         }
 723         case CBEN_GETDISPINFOA:
 724         {
 725             NMCOMBOBOXEXA *nmcbe = (NMCOMBOBOXEXA *)hdr;
 726             notify_generic_text_handler(&nmcbe->ceItem.pszText, &nmcbe->ceItem.cchTextMax);
 727             break;
 728         }
 729         /* Date and Time Picker */
 730         case DTN_FORMATA:
 731         {
 732             notify_datetime_handler((NMDATETIMEFORMATA *)hdr);
 733             break;
 734         }
 735         case DTN_FORMATQUERYA:
 736         {
 737             NMDATETIMEFORMATQUERYA *nmdtfq = (NMDATETIMEFORMATQUERYA *)hdr;
 738             notify_generic_text_handler((CHAR **)&nmdtfq->pszFormat, NULL);
 739             break;
 740         }
 741         case DTN_WMKEYDOWNA:
 742         {
 743             NMDATETIMEWMKEYDOWNA *nmdtkd = (NMDATETIMEWMKEYDOWNA *)hdr;
 744             notify_generic_text_handler((CHAR **)&nmdtkd->pszFormat, NULL);
 745             break;
 746         }
 747         case DTN_USERSTRINGA:
 748         {
 749             NMDATETIMESTRINGA *nmdts = (NMDATETIMESTRINGA *)hdr;
 750             notify_generic_text_handler((CHAR **)&nmdts->pszUserString, NULL);
 751             break;
 752         }
 753         /* Header */
 754         case HDN_BEGINDRAG:
 755         case HDN_ENDDRAG:
 756         case HDN_BEGINFILTEREDIT:
 757         case HDN_ENDFILTEREDIT:
 758         case HDN_DROPDOWN:
 759         case HDN_FILTERCHANGE:
 760         case HDN_ITEMKEYDOWN:
 761         case HDN_ITEMSTATEICONCLICK:
 762         case HDN_OVERFLOWCLICK:
 763         {
 764             NMHEADERW *nmhd = (NMHEADERW *)hdr;
 765             ok(!lstrcmpW(nmhd->pitem->pszText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w),
 766                wine_dbgstr_w(nmhd->pitem->pszText));
 767             ok(!lstrcmpW(((HD_TEXTFILTERW *)nmhd->pitem->pvFilter)->pszText, test_w), "Expect %s, got %s\n",
 768                wine_dbgstr_w(test_w), wine_dbgstr_w(((HD_TEXTFILTERW *)nmhd->pitem->pvFilter)->pszText));
 769             break;
 770         }
 771         case HDN_BEGINTRACKA:
 772         case HDN_DIVIDERDBLCLICKA:
 773         case HDN_ENDTRACKA:
 774         case HDN_ITEMCHANGEDA:
 775         case HDN_ITEMCHANGINGA:
 776         case HDN_ITEMCLICKA:
 777         case HDN_ITEMDBLCLICKA:
 778         case HDN_TRACKA:
 779         {
 780             NMHEADERA *nmhd = (NMHEADERA *)hdr;
 781             ok(!lstrcmpA(nmhd->pitem->pszText, test_a), "Expect %s, got %s\n", test_a, nmhd->pitem->pszText);
 782             ok(!lstrcmpA(((HD_TEXTFILTERA *)nmhd->pitem->pvFilter)->pszText, test_a), "Expect %s, got %s\n", test_a,
 783                ((HD_TEXTFILTERA *)nmhd->pitem->pvFilter)->pszText);
 784             break;
 785         }
 786         case HDN_GETDISPINFOA:
 787         {
 788             NMHDDISPINFOA *nmhddi = (NMHDDISPINFOA *)hdr;
 789             notify_generic_text_handler(&nmhddi->pszText, &nmhddi->cchTextMax);
 790             break;
 791         }
 792         /* List View */
 793         case LVN_BEGINLABELEDITA:
 794         case LVN_ENDLABELEDITA:
 795         case LVN_GETDISPINFOA:
 796         case LVN_SETDISPINFOA:
 797         {
 798             NMLVDISPINFOA *nmlvdi = (NMLVDISPINFOA *)hdr;
 799             notify_generic_text_handler(&nmlvdi->item.pszText, &nmlvdi->item.cchTextMax);
 800             break;
 801         }
 802         case LVN_GETINFOTIPA:
 803         {
 804             NMLVGETINFOTIPA *nmlvgit = (NMLVGETINFOTIPA *)hdr;
 805             notify_generic_text_handler(&nmlvgit->pszText, &nmlvgit->cchTextMax);
 806             break;
 807         }
 808         case LVN_INCREMENTALSEARCHA:
 809         case LVN_ODFINDITEMA:
 810         {
 811             NMLVFINDITEMA *nmlvfi = (NMLVFINDITEMA *)hdr;
 812             notify_generic_text_handler((CHAR **)&nmlvfi->lvfi.psz, NULL);
 813             break;
 814         }
 815         /* Toolbar */
 816         case TBN_SAVE:
 817         {
 818             NMTBSAVE *nmtbs = (NMTBSAVE *)hdr;
 819             notify_generic_text_handler((CHAR **)&nmtbs->tbButton.iString, NULL);
 820             break;
 821         }
 822         case TBN_RESTORE:
 823         {
 824             NMTBRESTORE *nmtbr = (NMTBRESTORE *)hdr;
 825             notify_generic_text_handler((CHAR **)&nmtbr->tbButton.iString, NULL);
 826             break;
 827         }
 828         case TBN_GETBUTTONINFOA:
 829         {
 830             NMTOOLBARA *nmtb = (NMTOOLBARA *)hdr;
 831             notify_generic_text_handler(&nmtb->pszText, &nmtb->cchText);
 832             break;
 833         }
 834         case TBN_GETDISPINFOW:
 835         {
 836             NMTBDISPINFOW *nmtbdi = (NMTBDISPINFOW *)hdr;
 837             notify_generic_text_handler((CHAR **)&nmtbdi->pszText, &nmtbdi->cchText);
 838             break;
 839         }
 840         case TBN_GETINFOTIPA:
 841         {
 842             NMTBGETINFOTIPA *nmtbgit = (NMTBGETINFOTIPA *)hdr;
 843             notify_generic_text_handler(&nmtbgit->pszText, &nmtbgit->cchTextMax);
 844             break;
 845         }
 846         /* Tooltip */
 847         case TTN_GETDISPINFOA:
 848         {
 849             notify_tooltip_handler((NMTTDISPINFOA *)hdr);
 850             break;
 851         }
 852         /* Tree View */
 853         case TVN_BEGINLABELEDITA:
 854         case TVN_ENDLABELEDITA:
 855         case TVN_GETDISPINFOA:
 856         case TVN_SETDISPINFOA:
 857         {
 858             NMTVDISPINFOA *nmtvdi = (NMTVDISPINFOA *)hdr;
 859             notify_generic_text_handler(&nmtvdi->item.pszText, &nmtvdi->item.cchTextMax);
 860             break;
 861         }
 862         case TVN_GETINFOTIPA:
 863         {
 864             NMTVGETINFOTIPA *nmtvgit = (NMTVGETINFOTIPA *)hdr;
 865             notify_generic_text_handler(&nmtvgit->pszText, &nmtvgit->cchTextMax);
 866             break;
 867         }
 868         case TVN_SINGLEEXPAND:
 869         case TVN_BEGINDRAGA:
 870         case TVN_BEGINRDRAGA:
 871         case TVN_ITEMEXPANDEDA:
 872         case TVN_ITEMEXPANDINGA:
 873         case TVN_DELETEITEMA:
 874         case TVN_SELCHANGINGA:
 875         case TVN_SELCHANGEDA:
 876         {
 877             NMTREEVIEWA *nmtv = (NMTREEVIEWA *)hdr;
 878             if (notify_test_info.handler_id == TVITEM_NEW_HANDLER)
 879                 notify_generic_text_handler((CHAR **)&nmtv->itemNew.pszText, &nmtv->itemNew.cchTextMax);
 880             else
 881                 notify_generic_text_handler((CHAR **)&nmtv->itemOld.pszText, &nmtv->itemOld.cchTextMax);
 882             break;
 883         }
 884
 885         default:
 886             ok(0, "Unexpected message 0x%08x\n", hdr->code);
 887         }
 888         notify_test_info.received = TRUE;
 889         ok(!lstrcmpA(test_a, "test"), "test_a got modified\n");
 890         ok(!lstrcmpW(test_w, L"test"), "test_w got modified\n");
 891         return 0;
 892     }
 893     case WM_NOTIFYFORMAT:
 894         if (lParam == NF_QUERY) return NFR_ANSI;
 895         break;
 896     }
 897     return DefWindowProcA(hwnd, message, wParam, lParam);
 898 }
 899
 900 static BOOL register_test_notify_class(void)
 901 {
 902     WNDCLASSA cls = {0};
 903
 904     cls.lpfnWndProc = test_notify_proc;
 905     cls.hInstance = GetModuleHandleA(NULL);
 906     cls.lpszClassName = "Pager notify class";
 907     return RegisterClassA(&cls);
 908 }
 909
 910 static void send_notify(HWND pager, UINT unicode, UINT ansi, LPARAM lParam, BOOL code_change)
 911 {
 912     NMHDR *hdr = (NMHDR *)lParam;
 913
 914     notify_test_info.unicode = unicode;
 915     notify_test_info.id_from = 1;
 916     notify_test_info.hwnd_from = child1_wnd;
 917     notify_test_info.ansi = ansi;
 918     notify_test_info.received = FALSE;
 919
 920     hdr->code = unicode;
 921     hdr->idFrom = 1;
 922     hdr->hwndFrom = child1_wnd;
 923
 924     SendMessageW(pager, WM_NOTIFY, hdr->idFrom, lParam);
 925     ok(notify_test_info.received, "Expect notification received\n");
 926     ok(hdr->code == code_change ? ansi : unicode, "Expect 0x%08x, got 0x%08x\n", hdr->code,
 927        code_change ? ansi : unicode);
 928 }
 929
 930 /* Send notify to test text field conversion. In parent proc notify_generic_text_handler() handles these messages */
 931 static void test_notify_generic_text_helper(HWND pager, const struct generic_text_helper_para *para)
 932 {
 933     const struct notify_test_send *send_data;
 934     const struct notify_test_receive *receive_data;
 935     INT array_size;
 936     INT i;
 937
 938     notify_test_info.flags = para->flags;
 939     notify_test_info.handler_id = para->handler_id;
 940
 941     if (para->flags & (CONVERT_SEND | DONT_CONVERT_SEND))
 942     {
 943         if (para->flags & CONVERT_SEND)
 944         {
 945             notify_test_info.test_id = CONVERT_SEND;
 946             send_data = test_convert_send_data;
 947             array_size = ARRAY_SIZE(test_convert_send_data);
 948         }
 949         else
 950         {
 951             notify_test_info.test_id = DONT_CONVERT_SEND;
 952             send_data = test_dont_convert_send_data;
 953             array_size = ARRAY_SIZE(test_dont_convert_send_data);
 954         }
 955
 956         for (i = 0; i < array_size; i++)
 957         {
 958             const struct notify_test_send *data = send_data + i;
 959             notify_test_info.sub_test_id = i;
 960
 961             memset(para->ptr, 0, para->size);
 962             if (para->mask) *para->mask = para->required_mask;
 963             if (data->send_text)
 964             {
 965                 memcpy(buffer, data->send_text, data->send_text_size);
 966                 *para->text = buffer;
 967             }
 968             if (para->text_max) *para->text_max = data->send_text_max;
 969             send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
 970         }
 971     }
 972
 973     if (para->flags & (CONVERT_RECEIVE | DONT_CONVERT_RECEIVE))
 974     {
 975         if (para->flags & CONVERT_RECEIVE)
 976         {
 977             notify_test_info.test_id = CONVERT_RECEIVE;
 978             receive_data = test_convert_receive_data;
 979             array_size = ARRAY_SIZE(test_convert_receive_data);
 980         }
 981         else
 982         {
 983             notify_test_info.test_id = DONT_CONVERT_RECEIVE;
 984             receive_data = test_dont_convert_receive_data;
 985             array_size = ARRAY_SIZE(test_dont_convert_receive_data);
 986         }
 987
 988         for (i = 0; i < array_size; i++)
 989         {
 990             const struct notify_test_receive *data = receive_data + i;
 991             notify_test_info.sub_test_id = i;
 992
 993             memset(para->ptr, 0, para->size);
 994             if (para->mask) *para->mask = para->required_mask;
 995             if (data->send_text)
 996             {
 997                 memcpy(buffer, data->send_text, data->send_text_size);
 998                 *para->text = buffer;
 999             }
1000             if (para->text_max) *para->text_max = data->send_text_max;
1001             send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1002             if (data->return_text)
1003             {
1004                 if (para->flags & CONVERT_RECEIVE)
1005                     ok(!wcsncmp(data->return_text, *para->text, *para->text_max),
1006                        "Code 0x%08x sub test %d expect %s, got %s\n", para->code_unicode, i,
1007                        wine_dbgstr_w((WCHAR *)data->return_text), wine_dbgstr_w(*para->text));
1008                 else
1009                     ok(!lstrcmpA(data->return_text, (CHAR *)*para->text), "Code 0x%08x sub test %d expect %s, got %s\n",
1010                        para->code_unicode, i, (CHAR *)data->return_text, (CHAR *)*para->text);
1011             }
1012             if (para->text_max)
1013                 ok(data->return_text_max == *para->text_max, "Code 0x%08x sub test %d expect %d, got %d\n",
1014                    para->code_unicode, i, data->return_text_max, *para->text_max);
1015         }
1016     }
1017
1018     /* Extra tests for other behavior flags that are not worth it to create their own test arrays */
1019     memset(para->ptr, 0, para->size);
1020     if (para->mask) *para->mask = para->required_mask;
1021     if (para->text_max) *para->text_max = 1;
1022     if (para->flags & SEND_EMPTY_IF_NULL)
1023         notify_test_info.test_id = SEND_EMPTY_IF_NULL;
1024     else
1025         notify_test_info.test_id = DONT_SEND_EMPTY_IF_NULL;
1026     send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1027
1028     notify_test_info.test_id = SET_NULL_IF_NO_MASK;
1029     memset(para->ptr, 0, para->size);
1030     memset(buffer, 0, sizeof(buffer));
1031     *para->text = buffer;
1032     if (para->text_max) *para->text_max = ARRAY_SIZE(buffer);
1033     send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1034     if(para->flags & SET_NULL_IF_NO_MASK)
1035         ok(!*para->text, "Expect null text\n");
1036 }
1037
1038 static void test_wm_notify_comboboxex(HWND pager)
1039 {
1040     static NMCBEDRAGBEGINW nmcbedb;
1041     static NMCBEENDEDITW nmcbeed;
1042
1043     /* CBEN_DRAGBEGIN */
1044     memset(&nmcbedb, 0, sizeof(nmcbedb));
1045     memcpy(nmcbedb.szText, test_w, sizeof(test_w));
1046     send_notify(pager, CBEN_DRAGBEGINW, CBEN_DRAGBEGINA, (LPARAM)&nmcbedb, FALSE);
1047     ok(!lstrcmpW(nmcbedb.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbedb.szText));
1048
1049     /* CBEN_ENDEDIT */
1050     memset(&nmcbeed, 0, sizeof(nmcbeed));
1051     memcpy(nmcbeed.szText, test_w, sizeof(test_w));
1052     send_notify(pager, CBEN_ENDEDITW, CBEN_ENDEDITA, (LPARAM)&nmcbeed, FALSE);
1053     ok(!lstrcmpW(nmcbeed.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbeed.szText));
1054 }
1055
1056 static void test_wm_notify_datetime(HWND pager)
1057 {
1058     const struct notify_test_datetime_format *data;
1059     NMDATETIMEFORMATW nmdtf;
1060     INT i;
1061
1062     for (i = 0; i < ARRAY_SIZE(test_datetime_format_data); i++)
1063     {
1064         data = test_datetime_format_data + i;
1065         notify_test_info.sub_test_id = i;
1066
1067         memset(&nmdtf, 0, sizeof(nmdtf));
1068         if(data->send_pszformat) nmdtf.pszFormat = data->send_pszformat;
1069         nmdtf.pszDisplay = nmdtf.szDisplay;
1070         send_notify(pager, DTN_FORMATW, DTN_FORMATA, (LPARAM)&nmdtf, TRUE);
1071         if (data->return_szdisplay)
1072             ok(!lstrcmpW(nmdtf.szDisplay, data->return_szdisplay), "Sub test %d expect %s, got %s\n", i,
1073                wine_dbgstr_w(data->return_szdisplay), wine_dbgstr_w(nmdtf.szDisplay));
1074         if (data->return_pszdisplay)
1075             ok(!lstrcmpW(nmdtf.pszDisplay, data->return_pszdisplay), "Sub test %d expect %s, got %s\n", i,
1076                wine_dbgstr_w(data->return_pszdisplay), wine_dbgstr_w(nmdtf.pszDisplay));
1077     }
1078 }
1079
1080 static void test_wm_notify_header(HWND pager)
1081 {
1082     NMHEADERW nmh = {{0}};
1083     HDITEMW hdi = {0};
1084     HD_TEXTFILTERW hdtf = {0};
1085
1086     hdi.mask = HDI_TEXT | HDI_FILTER;
1087     hdi.pszText = (WCHAR *)test_w;
1088     hdtf.pszText = (WCHAR *)test_w;
1089     nmh.pitem = &hdi;
1090     nmh.pitem->pvFilter = &hdtf;
1091     send_notify(pager, HDN_BEGINDRAG, HDN_BEGINDRAG, (LPARAM)&nmh, TRUE);
1092     send_notify(pager, HDN_ENDDRAG, HDN_ENDDRAG, (LPARAM)&nmh, TRUE);
1093     send_notify(pager, HDN_BEGINFILTEREDIT, HDN_BEGINFILTEREDIT, (LPARAM)&nmh, TRUE);
1094     send_notify(pager, HDN_ENDFILTEREDIT, HDN_ENDFILTEREDIT, (LPARAM)&nmh, TRUE);
1095     send_notify(pager, HDN_DROPDOWN, HDN_DROPDOWN, (LPARAM)&nmh, TRUE);
1096     send_notify(pager, HDN_FILTERCHANGE, HDN_FILTERCHANGE, (LPARAM)&nmh, TRUE);
1097     send_notify(pager, HDN_ITEMKEYDOWN, HDN_ITEMKEYDOWN, (LPARAM)&nmh, TRUE);
1098     send_notify(pager, HDN_ITEMSTATEICONCLICK, HDN_ITEMSTATEICONCLICK, (LPARAM)&nmh, TRUE);
1099     send_notify(pager, HDN_OVERFLOWCLICK, HDN_OVERFLOWCLICK, (LPARAM)&nmh, TRUE);
1100     send_notify(pager, HDN_BEGINTRACKW, HDN_BEGINTRACKA, (LPARAM)&nmh, TRUE);
1101     send_notify(pager, HDN_DIVIDERDBLCLICKW, HDN_DIVIDERDBLCLICKA, (LPARAM)&nmh, TRUE);
1102     send_notify(pager, HDN_ENDTRACKW, HDN_ENDTRACKA, (LPARAM)&nmh, TRUE);
1103     send_notify(pager, HDN_ITEMCHANGEDW, HDN_ITEMCHANGEDA, (LPARAM)&nmh, TRUE);
1104     send_notify(pager, HDN_ITEMCHANGINGW, HDN_ITEMCHANGINGA, (LPARAM)&nmh, TRUE);
1105     send_notify(pager, HDN_ITEMCLICKW, HDN_ITEMCLICKA, (LPARAM)&nmh, TRUE);
1106     send_notify(pager, HDN_ITEMDBLCLICKW, HDN_ITEMDBLCLICKA, (LPARAM)&nmh, TRUE);
1107     send_notify(pager, HDN_TRACKW, HDN_TRACKA, (LPARAM)&nmh, TRUE);
1108 }
1109
1110 static void test_wm_notify_tooltip(HWND pager)
1111 {
1112     NMTTDISPINFOW nmttdi;
1113     const struct notify_test_tooltip *data;
1114     INT i;
1115
1116     for (i = 0; i < ARRAY_SIZE(test_tooltip_data); i++)
1117     {
1118         data = test_tooltip_data + i;
1119         notify_test_info.sub_test_id = i;
1120
1121         memset(&nmttdi, 0, sizeof(nmttdi));
1122         if (data->send_sztext) memcpy(nmttdi.szText, data->send_sztext, data->send_sztext_size);
1123         if (data->send_lpsztext) nmttdi.lpszText = (WCHAR *)data->send_lpsztext;
1124         send_notify(pager, TTN_GETDISPINFOW, TTN_GETDISPINFOA, (LPARAM)&nmttdi, FALSE);
1125         if (data->return_sztext)
1126         {
1127             if (data->return_sztext_size == -1)
1128                 ok(!lstrcmpW(nmttdi.szText, data->return_sztext), "Sub test %d expect %s, got %s\n", i,
1129                    wine_dbgstr_w(data->return_sztext), wine_dbgstr_w(nmttdi.szText));
1130             else
1131                 ok(!memcmp(nmttdi.szText, data->return_sztext, data->return_sztext_size), "Wrong szText content\n");
1132         }
1133         if (data->return_lpsztext)
1134         {
1135             if (IS_INTRESOURCE(data->return_lpsztext))
1136                 ok(nmttdi.lpszText == data->return_lpsztext, "Sub test %d expect %s, got %s\n", i,
1137                    wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText));
1138             else
1139                 ok(!lstrcmpW(nmttdi.lpszText, data->return_lpsztext), "Test %d expect %s, got %s\n", i,
1140                    wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText));
1141         }
1142         if (data->return_hinst)
1143             ok(nmttdi.hinst == data->return_hinst, "Sub test %d expect %p, got %p\n", i, data->return_hinst,
1144                nmttdi.hinst);
1145     }
1146 }
1147
1148 static void test_wm_notify(void)
1149 {
1150     static const CHAR *class = "Pager notify class";
1151     HWND parent, pager;
1152     /* Combo Box Ex */
1153     static NMCOMBOBOXEXW nmcbe;
1154     /* Date and Time Picker */
1155     static NMDATETIMEFORMATQUERYW nmdtfq;
1156     static NMDATETIMEWMKEYDOWNW nmdtkd;
1157     static NMDATETIMESTRINGW nmdts;
1158     /* Header */
1159     static NMHDDISPINFOW nmhddi;
1160     /* List View */
1161     static NMLVDISPINFOW nmlvdi;
1162     static NMLVGETINFOTIPW nmlvgit;
1163     static NMLVFINDITEMW nmlvfi;
1164     /* Tool Bar */
1165     static NMTBRESTORE nmtbr;
1166     static NMTBSAVE nmtbs;
1167     static NMTOOLBARW nmtb;
1168     static NMTBDISPINFOW nmtbdi;
1169     static NMTBGETINFOTIPW nmtbgit;
1170     /* Tree View */
1171     static NMTVDISPINFOW nmtvdi;
1172     static NMTVGETINFOTIPW nmtvgit;
1173     static NMTREEVIEWW nmtv;
1174     static const struct generic_text_helper_para paras[] =
1175     {
1176         /* Combo Box Ex */
1177         {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1178          CBEN_INSERTITEM, CBEN_INSERTITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1179         {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1180          CBEN_DELETEITEM, CBEN_DELETEITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1181         {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1182          CBEN_GETDISPINFOW, CBEN_GETDISPINFOA, ZERO_SEND | SET_NULL_IF_NO_MASK | DONT_CONVERT_SEND | CONVERT_RECEIVE},
1183         /* Date and Time Picker */
1184         {&nmdtfq, sizeof(nmdtfq), NULL, 0, (WCHAR **)&nmdtfq.pszFormat, NULL, DTN_FORMATQUERYW, DTN_FORMATQUERYA,
1185          CONVERT_SEND},
1186         {&nmdtkd, sizeof(nmdtkd), NULL, 0, (WCHAR **)&nmdtkd.pszFormat, NULL, DTN_WMKEYDOWNW, DTN_WMKEYDOWNA,
1187          CONVERT_SEND},
1188         {&nmdts, sizeof(nmdts), NULL, 0, (WCHAR **)&nmdts.pszUserString, NULL, DTN_USERSTRINGW, DTN_USERSTRINGA,
1189          CONVERT_SEND},
1190         /* Header */
1191         {&nmhddi, sizeof(nmhddi), &nmhddi.mask, HDI_TEXT, &nmhddi.pszText, &nmhddi.cchTextMax, HDN_GETDISPINFOW,
1192          HDN_GETDISPINFOA, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE},
1193         /* List View */
1194         {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_STRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL,
1195          LVN_INCREMENTALSEARCHW, LVN_INCREMENTALSEARCHA, CONVERT_SEND},
1196         {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_SUBSTRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL, LVN_ODFINDITEMW,
1197          LVN_ODFINDITEMA, CONVERT_SEND},
1198         {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1199          LVN_BEGINLABELEDITW, LVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1200         {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1201          LVN_ENDLABELEDITW, LVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1202         {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1203          LVN_GETDISPINFOW, LVN_GETDISPINFOA, DONT_CONVERT_SEND | CONVERT_RECEIVE},
1204         {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1205          LVN_SETDISPINFOW, LVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1206         {&nmlvgit, sizeof(nmlvgit), NULL, 0, &nmlvgit.pszText, &nmlvgit.cchTextMax, LVN_GETINFOTIPW, LVN_GETINFOTIPA,
1207          CONVERT_SEND | CONVERT_RECEIVE},
1208         /* Tool Bar */
1209         {&nmtbs, sizeof(nmtbs), NULL, 0, (WCHAR **)&nmtbs.tbButton.iString, NULL, TBN_SAVE, TBN_SAVE,
1210          DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1211         {&nmtbr, sizeof(nmtbr), NULL, 0, (WCHAR **)&nmtbr.tbButton.iString, NULL, TBN_RESTORE, TBN_RESTORE,
1212          DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1213         {&nmtbdi, sizeof(nmtbdi), &nmtbdi.dwMask, TBNF_TEXT, &nmtbdi.pszText, &nmtbdi.cchText, TBN_GETDISPINFOW,
1214          TBN_GETDISPINFOW, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1215         {&nmtb, sizeof(nmtb), NULL, 0, &nmtb.pszText, &nmtb.cchText, TBN_GETBUTTONINFOW, TBN_GETBUTTONINFOA,
1216          SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE},
1217         {&nmtbgit, sizeof(nmtbgit), NULL, 0, &nmtbgit.pszText, &nmtbgit.cchTextMax, TBN_GETINFOTIPW, TBN_GETINFOTIPA,
1218          DONT_CONVERT_SEND | CONVERT_RECEIVE},
1219         /* Tree View */
1220         {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1221          TVN_BEGINLABELEDITW, TVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1222         {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1223          TVN_ENDLABELEDITW, TVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1224         {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1225          TVN_GETDISPINFOW, TVN_GETDISPINFOA, ZERO_SEND | DONT_CONVERT_SEND| CONVERT_RECEIVE},
1226         {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1227          TVN_SETDISPINFOW, TVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1228         {&nmtvgit, sizeof(nmtvgit), NULL, 0, &nmtvgit.pszText, &nmtvgit.cchTextMax, TVN_GETINFOTIPW, TVN_GETINFOTIPA,
1229          DONT_CONVERT_SEND | CONVERT_RECEIVE},
1230         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1231          TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_NEW_HANDLER},
1232         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1233          TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_OLD_HANDLER},
1234         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1235          TVN_BEGINDRAGW, TVN_BEGINDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1236         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1237          TVN_BEGINDRAGW, TVN_BEGINDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1238         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1239          TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1240         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1241          TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1242         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1243          TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1244         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1245          TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1246         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1247          TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1248         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1249          TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1250         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1251          TVN_DELETEITEMW, TVN_DELETEITEMA, DONT_CONVERT_SEND, TVITEM_NEW_HANDLER},
1252         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1253          TVN_DELETEITEMW, TVN_DELETEITEMA, CONVERT_SEND, TVITEM_OLD_HANDLER},
1254         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1255          TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1256         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1257          TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_OLD_HANDLER},
1258         {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1259          TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1260         {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1261          TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_OLD_HANDLER}
1262     };
1263     BOOL bret;
1264     INT i;
1265
1266     bret = register_test_notify_class();
1267     ok(bret, "Register test class failed, error 0x%08x\n", GetLastError());
1268
1269     parent = CreateWindowA(class, "parent", WS_OVERLAPPED, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), 0);
1270     ok(parent != NULL, "CreateWindow failed\n");
1271     pager = CreateWindowA(WC_PAGESCROLLERA, "pager", WS_CHILD, 0, 0, 100, 100, parent, 0, GetModuleHandleA(0), 0);
1272     ok(pager != NULL, "CreateWindow failed\n");
1273     child1_wnd = CreateWindowA(class, "child", WS_CHILD, 0, 0, 100, 100, pager, (HMENU)1, GetModuleHandleA(0), 0);
1274     ok(child1_wnd != NULL, "CreateWindow failed\n");
1275     SendMessageW(pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd);
1276
1277     for (i = 0; i < ARRAY_SIZE(paras); i++)
1278         test_notify_generic_text_helper(pager, paras + i);
1279
1280     /* Tests for those that can't be covered by generic text test helper */
1281     test_wm_notify_comboboxex(pager);
1282     test_wm_notify_datetime(pager);
1283     test_wm_notify_header(pager);
1284     test_wm_notify_tooltip(pager);
1285
1286     DestroyWindow(parent);
1287     UnregisterClassA(class, GetModuleHandleA(NULL));
1288 }
1289
1290 static void init_functions(void)
1291 {
1292     HMODULE mod = LoadLibraryA("comctl32.dll");
1293
1294 #define X(f) p##f = (void*)GetProcAddress(mod, #f);
1295     X(InitCommonControlsEx);
1296 #undef X
1297
1298     pSetWindowSubclass = (void*)GetProcAddress(mod, (LPSTR)410);
1299 }
1300
1301 START_TEST(pager)
1302 {
1303     INITCOMMONCONTROLSEX iccex;
1304
1305     init_functions();
1306
1307     iccex.dwSize = sizeof(iccex);
1308     iccex.dwICC = ICC_PAGESCROLLER_CLASS;
1309     pInitCommonControlsEx(&iccex);
1310
1311     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1312
1313     parent_wnd = create_parent_window();
1314     ok(parent_wnd != NULL, "Failed to create parent window!\n");
1315
1316     test_pager();
1317     test_wm_notifyformat();
1318     test_wm_notify();
1319
1320     DestroyWindow(parent_wnd);
1321 }