dlls/comctl32/tests/trackbar.c

   1 /* Unit tests for the track bar control.
   2  *
   3  * Copyright 2007 Keith Stevens
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <assert.h>
  21 #include <windows.h>
  22 #include <commctrl.h>
  23 #include <stdio.h>
  24
  25 #include "wine/test.h"
  26 #include "msg.h"
  27
  28 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  29 #define NUM_MSG_SEQUENCE 2
  30 #define PARENT_SEQ_INDEX 0
  31 #define TRACKBAR_SEQ_INDEX 1
  32
  33
  34 static struct msg_sequence *sequences[NUM_MSG_SEQUENCE];
  35
  36 static const struct message create_parent_wnd_seq[] = {
  37     { WM_GETMINMAXINFO, sent },
  38     { WM_NCCREATE, sent },
  39     { WM_NCCALCSIZE, sent|wparam, 0 },
  40     { WM_CREATE, sent },
  41     { WM_QUERYNEWPALETTE, sent|optional },
  42     { WM_SHOWWINDOW, sent|wparam, 1 },
  43     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  44     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  45     { WM_ACTIVATEAPP, sent|wparam, 1 },
  46     { WM_NCACTIVATE, sent|wparam, 1 },
  47     { WM_ACTIVATE, sent|wparam, 1 },
  48     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
  49     { WM_IME_NOTIFY, sent|defwinproc|optional },
  50     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
  51     /* Win9x adds SWP_NOZORDER below */
  52     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
  53     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
  54     { WM_SIZE, sent },
  55     { WM_MOVE, sent },
  56     { 0 }
  57 };
  58
  59 static const struct message create_trackbar_wnd_seq[] = {
  60     {0}
  61 };
  62
  63 static const struct message parent_empty_test_seq[] = {
  64     {0}
  65 };
  66
  67 static const struct message parent_create_trackbar_wnd_seq[] = {
  68     { WM_NOTIFYFORMAT, sent},
  69     { WM_QUERYUISTATE, sent|optional},
  70     { WM_WINDOWPOSCHANGING, sent},
  71     { WM_NCACTIVATE, sent},
  72     { PBT_APMRESUMECRITICAL, sent},
  73     { WM_WINDOWPOSCHANGING, sent},
  74     { PBT_APMRESUMESTANDBY, sent},
  75     { WM_IME_SETCONTEXT, sent|optional},
  76     { WM_IME_NOTIFY, sent|optional},
  77     { WM_CTLCOLORSTATIC, sent},
  78     { WM_NOTIFY, sent},
  79     {0}
  80 };
  81
  82 static const struct message parent_new_window_test_seq[] = {
  83     { WM_QUERYNEWPALETTE, sent|optional },
  84     { WM_WINDOWPOSCHANGING, sent},
  85     { WM_NCACTIVATE, sent},
  86     { PBT_APMRESUMECRITICAL, sent},
  87     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
  88     { WM_IME_NOTIFY, sent|defwinproc|optional},
  89     { WM_SETFOCUS, sent|defwinproc},
  90     { WM_NOTIFYFORMAT, sent},
  91     { WM_QUERYUISTATE, sent|optional},
  92     {0}
  93 };
  94
  95 static const struct message buddy_window_test_seq[] = {
  96     { TBM_GETBUDDY, sent|wparam, TRUE},
  97     { TBM_SETBUDDY, sent|wparam, FALSE},
  98     { WM_PAINT, sent|defwinproc},
  99     { TBM_SETBUDDY, sent|wparam, FALSE},
 100     { WM_PAINT, sent|defwinproc},
 101     { TBM_GETBUDDY, sent|wparam, TRUE},
 102     { TBM_SETBUDDY, sent|wparam, TRUE},
 103     { WM_PAINT, sent|defwinproc},
 104     { TBM_SETBUDDY, sent|wparam, TRUE},
 105     { WM_PAINT, sent|defwinproc},
 106     { TBM_GETBUDDY, sent|wparam, FALSE},
 107     { TBM_GETBUDDY, sent|wparam, TRUE},
 108     {0}
 109 };
 110
 111 static const struct message parent_buddy_window_test_seq[] = {
 112     { WM_CTLCOLORSTATIC, sent},
 113     { WM_NOTIFY, sent},
 114     { WM_CTLCOLORSTATIC, sent},
 115     { WM_NOTIFY, sent},
 116     { WM_CTLCOLORSTATIC, sent},
 117     { WM_NOTIFY, sent},
 118     { WM_CTLCOLORSTATIC, sent},
 119     { WM_NOTIFY, sent},
 120     {0}
 121 };
 122
 123 static const struct message line_size_test_seq[] = {
 124     { TBM_SETLINESIZE, sent|lparam, 0, 10},
 125     { TBM_SETLINESIZE, sent|lparam, 0, 4},
 126     { TBM_GETLINESIZE, sent},
 127     {0}
 128 };
 129
 130 static const struct message page_size_test_seq[] = {
 131     { TBM_SETPAGESIZE, sent|lparam, 0, 10},
 132     { TBM_SETPAGESIZE, sent|lparam, 0, -1},
 133     { TBM_GETPAGESIZE, sent},
 134     {0}
 135 };
 136
 137 static const struct message position_test_seq[] = {
 138     { TBM_SETPOS, sent|wparam|lparam, TRUE, -1},
 139     { WM_PAINT, sent|defwinproc},
 140     { TBM_GETPOS, sent},
 141     { TBM_SETPOS, sent|wparam|lparam, TRUE, 5},
 142     { WM_PAINT, sent|defwinproc},
 143     { TBM_GETPOS, sent},
 144     { TBM_SETPOS, sent|wparam|lparam, TRUE, 1000},
 145     { WM_PAINT, sent|defwinproc},
 146     { TBM_GETPOS, sent},
 147     { TBM_SETPOS, sent|wparam|lparam, FALSE, 20},
 148     { TBM_GETPOS, sent},
 149     { TBM_GETPOS, sent},
 150     {0}
 151 };
 152
 153 static const struct message parent_position_test_seq[] = {
 154     { WM_CTLCOLORSTATIC, sent},
 155     { WM_NOTIFY, sent},
 156     { WM_CTLCOLORSTATIC, sent},
 157     { WM_NOTIFY, sent},
 158     { WM_CTLCOLORSTATIC, sent},
 159     { WM_NOTIFY, sent},
 160     {0}
 161 };
 162
 163 static const struct message range_test_seq[] = {
 164     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 165     { WM_PAINT, sent|defwinproc},
 166     { TBM_GETRANGEMAX, sent},
 167     { TBM_GETRANGEMIN, sent},
 168     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(-1, 1000)},
 169     { WM_PAINT, sent|defwinproc},
 170     { TBM_GETRANGEMAX, sent},
 171     { TBM_GETRANGEMIN, sent},
 172     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(10, 0)},
 173     { WM_PAINT, sent|defwinproc},
 174     { TBM_GETRANGEMAX, sent},
 175     { TBM_GETRANGEMIN, sent},
 176     { TBM_SETRANGE, sent|wparam|lparam, FALSE, MAKELONG(0, 10)},
 177     { TBM_GETRANGEMAX, sent},
 178     { TBM_GETRANGEMIN, sent},
 179     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, 10},
 180     { WM_PAINT, sent|defwinproc},
 181     { TBM_GETRANGEMAX, sent},
 182     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, -1},
 183     { WM_PAINT, sent|defwinproc},
 184     { TBM_GETRANGEMAX, sent},
 185     { TBM_SETRANGEMAX, sent|wparam|lparam, FALSE, 10},
 186     { TBM_GETRANGEMAX, sent},
 187     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 0},
 188     { WM_PAINT, sent|defwinproc},
 189     { TBM_GETRANGEMIN, sent},
 190     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 10},
 191     { WM_PAINT, sent|defwinproc},
 192     { TBM_GETRANGEMIN, sent},
 193     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, -10},
 194     { WM_PAINT, sent|defwinproc},
 195     { TBM_GETRANGEMIN, sent},
 196     { TBM_SETRANGEMIN, sent|wparam|lparam, FALSE, 5},
 197     { TBM_GETRANGEMIN, sent},
 198     { TBM_GETRANGEMAX, sent},
 199     { TBM_GETRANGEMIN, sent},
 200     {0}
 201 };
 202
 203 static const struct message parent_range_test_seq[] = {
 204     { WM_CTLCOLORSTATIC, sent},
 205     { WM_NOTIFY, sent},
 206     { WM_CTLCOLORSTATIC, sent},
 207     { WM_NOTIFY, sent},
 208     { WM_CTLCOLORSTATIC, sent},
 209     { WM_NOTIFY, sent},
 210     { WM_CTLCOLORSTATIC, sent},
 211     { WM_NOTIFY, sent},
 212     { WM_CTLCOLORSTATIC, sent},
 213     { WM_NOTIFY, sent},
 214     { WM_CTLCOLORSTATIC, sent},
 215     { WM_NOTIFY, sent},
 216     { WM_CTLCOLORSTATIC, sent},
 217     { WM_NOTIFY, sent},
 218     { WM_CTLCOLORSTATIC, sent},
 219     { WM_NOTIFY, sent},
 220     {0}
 221 };
 222
 223 static const struct message selection_test_seq[] = {
 224     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 225     { WM_PAINT, sent|defwinproc},
 226     { TBM_GETSELEND, sent},
 227     { TBM_GETSELSTART, sent},
 228     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(5, 20)},
 229     { WM_PAINT, sent|defwinproc},
 230     { TBM_GETSELEND, sent},
 231     { TBM_GETSELSTART, sent},
 232     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(5, 10)},
 233     { TBM_GETSELEND, sent},
 234     { TBM_GETSELSTART, sent},
 235     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 236     { WM_PAINT, sent|defwinproc},
 237     { TBM_GETSELEND, sent},
 238     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 20},
 239     { WM_PAINT, sent|defwinproc},
 240     { TBM_GETSELEND, sent},
 241     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 4},
 242     { WM_PAINT, sent|defwinproc},
 243     { TBM_GETSELEND, sent},
 244     { TBM_SETSELEND, sent|wparam|lparam, FALSE, 2},
 245     { TBM_GETSELEND, sent},
 246     { TBM_GETSELEND, sent},
 247     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 5},
 248     { WM_PAINT, sent|defwinproc},
 249     { TBM_GETSELSTART, sent},
 250     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 0},
 251     { WM_PAINT, sent|defwinproc},
 252     { TBM_GETSELSTART, sent},
 253     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 20},
 254     { WM_PAINT, sent|defwinproc},
 255     { TBM_GETSELSTART, sent},
 256     { TBM_SETSELSTART, sent|wparam|lparam, FALSE, 8},
 257     { TBM_GETSELSTART, sent},
 258     { TBM_GETSELSTART, sent},
 259     {0}
 260 };
 261
 262 static const struct message parent_selection_test_seq[] = {
 263     { WM_CTLCOLORSTATIC, sent},
 264     { WM_NOTIFY, sent},
 265     { WM_CTLCOLORSTATIC, sent},
 266     { WM_NOTIFY, sent},
 267     { WM_CTLCOLORSTATIC, sent},
 268     { WM_NOTIFY, sent},
 269     { WM_CTLCOLORSTATIC, sent},
 270     { WM_NOTIFY, sent},
 271     { WM_CTLCOLORSTATIC, sent},
 272     { WM_NOTIFY, sent},
 273     { WM_CTLCOLORSTATIC, sent},
 274     { WM_NOTIFY, sent},
 275     { WM_CTLCOLORSTATIC, sent},
 276     { WM_NOTIFY, sent},
 277     { WM_CTLCOLORSTATIC, sent},
 278     { WM_NOTIFY, sent},
 279     {0}
 280 };
 281
 282 static const struct message tic_settings_test_seq[] = {
 283     { TBM_SETTIC, sent|lparam, 0, 0},
 284     { TBM_SETTIC, sent|lparam, 0, 5},
 285     { TBM_SETTIC, sent|lparam, 0, 10},
 286     { TBM_SETTIC, sent|lparam, 0, 20},
 287     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 288     { WM_PAINT, sent|defwinproc},
 289     { TBM_SETTICFREQ, sent|wparam, 2},
 290     { WM_PAINT, sent|defwinproc},
 291     { TBM_GETNUMTICS, sent},
 292     { TBM_SETTICFREQ, sent|wparam, 5},
 293     { WM_PAINT, sent|defwinproc},
 294     { TBM_GETNUMTICS, sent},
 295     { TBM_SETTICFREQ, sent|wparam, 15},
 296     { WM_PAINT, sent|defwinproc},
 297     { TBM_GETNUMTICS, sent},
 298     { TBM_GETNUMTICS, sent},
 299     {0}
 300 };
 301
 302 static const struct message parent_tic_settings_test_seq[] = {
 303     { WM_CTLCOLORSTATIC, sent},
 304     { WM_NOTIFY, sent},
 305     { WM_CTLCOLORSTATIC, sent},
 306     { WM_NOTIFY, sent},
 307     { WM_CTLCOLORSTATIC, sent},
 308     { WM_NOTIFY, sent},
 309     { WM_CTLCOLORSTATIC, sent},
 310     { WM_NOTIFY, sent},
 311     {0}
 312 };
 313
 314 static const struct message thumb_length_test_seq[] = {
 315     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 15, 0},
 316     { WM_PAINT, sent|defwinproc},
 317     { TBM_GETTHUMBLENGTH, sent},
 318     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 20, 0},
 319     { WM_PAINT, sent|defwinproc},
 320     { TBM_GETTHUMBLENGTH, sent},
 321     { TBM_GETTHUMBLENGTH, sent},
 322     {0}
 323 };
 324
 325 static const struct message parent_thumb_length_test_seq[] = {
 326     { WM_CTLCOLORSTATIC, sent},
 327     { WM_NOTIFY, sent},
 328     { WM_CTLCOLORSTATIC, sent},
 329     { WM_NOTIFY, sent},
 330     {0}
 331 };
 332
 333 static const struct message tic_placement_test_seq[] = {
 334     { TBM_GETPTICS, sent},
 335     { TBM_GETTIC, sent|wparam, 0},
 336     { TBM_GETTIC, sent|wparam, 2},
 337     { TBM_GETTIC, sent|wparam, 4},
 338     { TBM_GETTICPOS, sent|wparam, 0},
 339     { TBM_GETTICPOS, sent|wparam, 2},
 340     {0}
 341 };
 342
 343 static const struct message tool_tips_test_seq[] = {
 344     { TBM_SETTIPSIDE, sent|wparam, TBTS_TOP},
 345     { TBM_SETTIPSIDE, sent|wparam, TBTS_LEFT},
 346     { TBM_SETTIPSIDE, sent|wparam, TBTS_BOTTOM},
 347     { TBM_SETTIPSIDE, sent|wparam, TBTS_RIGHT},
 348     { TBM_SETTOOLTIPS, sent},
 349     { TBM_GETTOOLTIPS, sent},
 350     { TBM_SETTOOLTIPS, sent},
 351     { TBM_GETTOOLTIPS, sent},
 352     { TBM_SETTOOLTIPS, sent},
 353     { TBM_GETTOOLTIPS, sent},
 354     { TBM_GETTOOLTIPS, sent},
 355     {0}
 356 };
 357
 358 static const struct message unicode_test_seq[] = {
 359     { TBM_SETUNICODEFORMAT, sent|wparam, TRUE},
 360     { TBM_SETUNICODEFORMAT, sent|wparam, FALSE},
 361     { TBM_GETUNICODEFORMAT, sent},
 362     {0}
 363 };
 364
 365 static const struct message ignore_selection_test_seq[] = {
 366     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 367     { TBM_GETSELEND, sent},
 368     { TBM_GETSELSTART, sent},
 369     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(0,10)},
 370     { TBM_GETSELEND, sent},
 371     { TBM_GETSELSTART, sent},
 372     { TBM_SETSELEND, sent|wparam|lparam, TRUE,0},
 373     { TBM_GETSELEND, sent},
 374     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 375     { TBM_GETSELEND, sent},
 376     { TBM_SETSELEND, sent|wparam|lparam, FALSE,0},
 377     { TBM_GETSELEND, sent},
 378     { TBM_SETSELSTART, sent|wparam|lparam, TRUE,0},
 379     { TBM_GETSELSTART, sent},
 380     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 10},
 381     { TBM_GETSELSTART, sent},
 382     { TBM_SETSELSTART, sent|wparam|lparam, FALSE,0},
 383     { TBM_GETSELSTART, sent},
 384     {0}
 385 };
 386
 387 struct subclass_info
 388 {
 389     WNDPROC oldproc;
 390 };
 391
 392 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 393     static long defwndproc_counter = 0;
 394     LRESULT ret;
 395     struct message msg;
 396
 397     /* do not log painting messages */
 398     if (message != WM_PAINT &&
 399         message != WM_ERASEBKGND &&
 400         message != WM_NCPAINT &&
 401         message != WM_NCHITTEST &&
 402         message != WM_GETTEXT &&
 403         message != WM_GETICON &&
 404         message != WM_DEVICECHANGE)
 405     {
 406         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 407
 408         msg.message = message;
 409         msg.flags = sent|wparam|lparam;
 410         if (defwndproc_counter) msg.flags |= defwinproc;
 411         msg.wParam = wParam;
 412         msg.lParam = lParam;
 413         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 414     }
 415
 416     defwndproc_counter++;
 417     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 418     defwndproc_counter--;
 419
 420     return ret;
 421 }
 422
 423 static BOOL register_parent_wnd_class(void){
 424     WNDCLASSA cls;
 425
 426     cls.style = 0;
 427     cls.lpfnWndProc = parent_wnd_proc;
 428     cls.cbClsExtra = 0;
 429     cls.cbWndExtra = 0;
 430     cls.hInstance = GetModuleHandleA(NULL);
 431     cls.hIcon = 0;
 432     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
 433     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 434     cls.lpszMenuName = NULL;
 435     cls.lpszClassName = "Trackbar test parent class";
 436     return RegisterClassA(&cls);
 437 }
 438
 439 static HWND create_parent_window(void){
 440     if (!register_parent_wnd_class())
 441         return NULL;
 442
 443     return CreateWindowEx(0, "Trackbar test parent class",
 444         "Trackbar test parent window",
 445         WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 446         WS_MAXIMIZEBOX | WS_VISIBLE,
 447         0, 0, 100, 100,
 448         GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 449 }
 450
 451 static LRESULT WINAPI trackbar_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 452     struct subclass_info *info = (struct subclass_info *) GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 453     static long defwndproc_counter = 0;
 454     LRESULT ret;
 455     struct message msg;
 456
 457     trace("trackbar: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 458
 459     msg.message = message;
 460     msg.flags = sent|wparam|lparam;
 461     if (defwndproc_counter) msg.flags |= defwinproc;
 462     msg.wParam = wParam;
 463     msg.lParam = lParam;
 464     add_message(sequences, TRACKBAR_SEQ_INDEX, &msg);
 465
 466     defwndproc_counter++;
 467     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
 468     defwndproc_counter--;
 469
 470     return ret;
 471 }
 472
 473 static HWND create_trackbar(DWORD style, HWND parent){
 474     struct subclass_info *info;
 475     HWND hWndTrack;
 476     RECT rect;
 477
 478     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
 479     if (!info)
 480         return NULL;
 481
 482     GetClientRect(parent, &rect);
 483     hWndTrack = CreateWindowEx(
 484       0, TRACKBAR_CLASS,"Trackbar Control", style,
 485       rect.right,rect.bottom, 100, 50,
 486       parent, NULL,GetModuleHandleA(NULL) ,NULL);
 487
 488     if (!hWndTrack)
 489     {
 490         HeapFree(GetProcessHeap(), 0, info);
 491         return NULL;
 492     }
 493
 494     info->oldproc = (WNDPROC)SetWindowLongPtrA(hWndTrack, GWLP_WNDPROC, (LONG_PTR)trackbar_subclass_proc);
 495
 496     SetWindowLongPtrA(hWndTrack, GWLP_USERDATA, (LONG_PTR)info);
 497
 498     return hWndTrack;
 499 }
 500
 501 /* test functions for setters, getters, and sequences */
 502
 503 static void test_trackbar_buddy(HWND hWndTrackbar){
 504     HWND hWndLeftBuddy;
 505     HWND hWndRightBuddy;
 506     HWND hWndCurrentBuddy;
 507     HWND rTest;
 508
 509     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 510
 511     hWndLeftBuddy = (HWND) CreateWindowEx(0, STATUSCLASSNAME, NULL, 0,
 512         0,0,300,20, NULL, NULL, NULL, NULL);
 513     ok(hWndLeftBuddy != NULL, "Expected non NULL value\n");
 514
 515     if (hWndLeftBuddy != NULL){
 516         hWndCurrentBuddy = (HWND) SendMessage(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 517         rTest = (HWND) SendMessage(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 518         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 519         rTest = (HWND) SendMessage(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 520         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 521     } else
 522         skip ("left buddy control not present?\n");
 523
 524     hWndRightBuddy = (HWND) CreateWindowEx(0, STATUSCLASSNAME, NULL, 0,
 525         0,0,300,20,NULL,NULL, NULL, NULL);
 526
 527     ok(hWndRightBuddy != NULL, "expected non NULL value\n");
 528
 529     /* test TBM_SETBUDDY */
 530     if (hWndRightBuddy != NULL){
 531         hWndCurrentBuddy = (HWND) SendMessage(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 532         rTest = (HWND) SendMessage(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 533         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 534         rTest = (HWND) SendMessage(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 535         ok(rTest == hWndRightBuddy, "Expected hWndRightbuddy\n");
 536      } else
 537        skip("Right buddy control not present?\n");
 538
 539     /* test TBM_GETBUDDY */
 540     if (hWndLeftBuddy != NULL){
 541         rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETBUDDY, FALSE, 0);
 542         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 543         DestroyWindow(hWndLeftBuddy);
 544     }
 545     if (hWndRightBuddy != NULL){
 546         rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETBUDDY, TRUE,0);
 547         ok(rTest == hWndRightBuddy, "Expected hWndRightBuddy\n");
 548         DestroyWindow(hWndRightBuddy);
 549     }
 550
 551     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, buddy_window_test_seq, "buddy test sequence", TRUE);
 552     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_buddy_window_test_seq, "parent buddy test seq", TRUE);
 553
 554 }
 555
 556 static void test_line_size(HWND hWndTrackbar){
 557     int r;
 558
 559     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 560
 561     /* test TBM_SETLINESIZE */
 562     r = SendMessage(hWndTrackbar, TBM_SETLINESIZE, 0, 10);
 563     r = SendMessage(hWndTrackbar, TBM_SETLINESIZE, 0, 4);
 564     expect(10, r);
 565
 566     /* test TBM_GETLINESIZE */
 567     r = SendMessage(hWndTrackbar, TBM_GETLINESIZE, 0,0);
 568     expect(4, r);
 569
 570     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, line_size_test_seq, "linesize test sequence", FALSE);
 571     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent line test sequence", FALSE);
 572 }
 573
 574
 575 static void test_page_size(HWND hWndTrackbar){
 576     int r;
 577
 578     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 579
 580     /* test TBM_SETPAGESIZE */
 581     r = SendMessage(hWndTrackbar, TBM_SETPAGESIZE, 0, 10);
 582     expect(20, r);
 583     r = SendMessage(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 584     expect(10, r);
 585
 586     /* test TBM_GETPAGESIZE */
 587     r = SendMessage(hWndTrackbar, TBM_GETPAGESIZE, 0,0);
 588     todo_wine{
 589         expect(20, r);
 590     }
 591
 592     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, page_size_test_seq, "page size test sequence", FALSE);
 593     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent page size test sequence", FALSE);
 594 }
 595
 596 static void test_position(HWND hWndTrackbar){
 597     int r;
 598
 599     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 600     /* test TBM_SETPOS */
 601     SendMessage(hWndTrackbar, TBM_SETPOS, TRUE, -1);
 602     r = SendMessage(hWndTrackbar, TBM_GETPOS, 0, 0);
 603     expect(0, r);
 604     SendMessage(hWndTrackbar, TBM_SETPOS, TRUE, 5);
 605     r = SendMessage(hWndTrackbar, TBM_GETPOS, 0,0);
 606     expect(5, r);
 607     SendMessage(hWndTrackbar, TBM_SETPOS, TRUE, 1000);
 608     r = SendMessage(hWndTrackbar, TBM_GETPOS, 0,0);
 609     expect(100, r);
 610     SendMessage(hWndTrackbar, TBM_SETPOS, FALSE, 20);
 611     r = SendMessage(hWndTrackbar, TBM_GETPOS, 0,0);
 612     expect(20, r);
 613
 614     /* test TBM_GETPOS */
 615     r = SendMessage(hWndTrackbar, TBM_GETPOS, 0,0);
 616     expect(20, r);
 617
 618     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, position_test_seq, "position test sequence", TRUE);
 619     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_position_test_seq, "parent position test sequence", TRUE);
 620 }
 621
 622 static void test_range(HWND hWndTrackbar){
 623     int r;
 624
 625     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 626     /* test TBM_SETRANGE */
 627     SendMessage(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
 628     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 629     expect(10, r);
 630     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 631     expect(0, r);
 632     SendMessage(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(-1, 1000));
 633     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 634     expect(1000, r);
 635     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 636     expect(-1, r);
 637     SendMessage(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(10, 0));
 638     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 639     expect(0, r);
 640     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 641     expect(10, r);
 642     SendMessage(hWndTrackbar, TBM_SETRANGE, FALSE, MAKELONG(0,10));
 643     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 644     expect(10, r);
 645     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 646     expect(0, r);
 647
 648     /*test TBM_SETRANGEMAX */
 649     SendMessage(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 10);
 650     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 651     expect(10, r);
 652     SendMessage(hWndTrackbar, TBM_SETRANGEMAX, TRUE, -1);
 653     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 654     expect(-1, r);
 655     SendMessage(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 656     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 657     expect(10, r);
 658
 659     /* testing TBM_SETRANGEMIN */
 660     SendMessage(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 661     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 662     expect(0, r);
 663     SendMessage(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 10);
 664     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 665     expect(10, r);
 666     SendMessage(hWndTrackbar, TBM_SETRANGEMIN, TRUE, -10);
 667     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 668     expect(-10, r);
 669     SendMessage(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 5);
 670     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 671     expect(5, r);
 672
 673     /* test TBM_GETRANGEMAX */
 674     r = SendMessage(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 675     expect(10, r);
 676
 677     /* test TBM_GETRANGEMIN */
 678     r = SendMessage(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 679     expect(5, r);
 680
 681     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, range_test_seq, "range test sequence", TRUE);
 682     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_range_test_seq, "parent range test sequence", TRUE);
 683 }
 684
 685 static void test_selection(HWND hWndTrackbar){
 686     int r;
 687
 688     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 689     /* test TBM_SETSEL */
 690     SendMessage(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
 691     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 692     expect(10, r);
 693     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 694     expect(5, r);
 695     SendMessage(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(5, 20));
 696     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 697     expect(10, r);
 698     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 699     expect(5, r);
 700     SendMessage(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(5, 10));
 701     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 702     expect(10, r);
 703     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 704     expect(5, r);
 705
 706     /* test TBM_SETSELEND */
 707     SendMessage(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
 708     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 709     expect(10, r);
 710     SendMessage(hWndTrackbar, TBM_SETSELEND, TRUE, 20);
 711     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 712     expect(10, r);
 713     SendMessage(hWndTrackbar, TBM_SETSELEND, TRUE, 4);
 714     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 715     expect(4, r);
 716     SendMessage(hWndTrackbar, TBM_SETSELEND, FALSE, 2);
 717     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 718     expect(2, r);
 719
 720     /* test TBM_GETSELEND */
 721     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 722     expect(2, r);
 723
 724     /* testing TBM_SETSELSTART */
 725     SendMessage(hWndTrackbar, TBM_SETSELSTART, TRUE, 5);
 726     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 727     expect(5, r);
 728     SendMessage(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
 729     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 730     expect(5, r);
 731     SendMessage(hWndTrackbar, TBM_SETSELSTART, TRUE, 20);
 732     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 733     expect(20, r);
 734     SendMessage(hWndTrackbar, TBM_SETSELSTART, FALSE, 8);
 735     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 736     expect(8, r);
 737
 738     /* test TBM_GETSELSTART */
 739     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 740     expect(8, r);
 741
 742     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, selection_test_seq, "selection test sequence", TRUE);
 743     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_selection_test_seq, "parent selection test seqence", TRUE);
 744 }
 745
 746 static void test_thumb_length(HWND hWndTrackbar){
 747     int r;
 748
 749     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 750     /* testing TBM_SETTHUMBLENGTH */
 751     SendMessage(hWndTrackbar, TBM_SETTHUMBLENGTH, 15, 0);
 752     r = SendMessage(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 753     expect(15, r);
 754     SendMessage(hWndTrackbar, TBM_SETTHUMBLENGTH, 20, 0);
 755     r = SendMessage(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 756     expect(20, r);
 757
 758     /* test TBM_GETTHUMBLENGTH */
 759     r = SendMessage(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 760     expect(20, r);
 761
 762     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, thumb_length_test_seq, "thumb length test sequence", TRUE);
 763     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_thumb_length_test_seq, "parent thumb lenth test sequence", TRUE);
 764 }
 765
 766 static void test_tic_settings(HWND hWndTrackbar){
 767     int r;
 768
 769     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 770     /* testing TBM_SETTIC */
 771     /* Set tics at 5 and 10 */
 772     /* 0 and 20 are out of range and should not be set */
 773     r = SendMessage(hWndTrackbar, TBM_SETTIC, 0, 0);
 774     ok(r == FALSE, "Expected FALSE, got %d\n", r);
 775     r = SendMessage(hWndTrackbar, TBM_SETTIC, 0, 5);
 776     todo_wine{
 777         ok(r == TRUE, "Expected TRUE, got %d\n", r);
 778         r = SendMessage(hWndTrackbar, TBM_SETTIC, 0, 10);
 779         ok(r == TRUE, "Expected TRUE, got %d\n", r);
 780     }
 781     r = SendMessage(hWndTrackbar, TBM_SETTIC, 0, 20);
 782     ok(r == FALSE, "Expected False, got %d\n", r);
 783
 784     /* test TBM_SETTICFREQ */
 785     SendMessage(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
 786     SendMessage(hWndTrackbar, TBM_SETTICFREQ, 2, 0);
 787     r = SendMessage(hWndTrackbar, TBM_GETNUMTICS, 0,0);
 788     expect(6, r);
 789     SendMessage(hWndTrackbar, TBM_SETTICFREQ, 5, 0);
 790     r = SendMessage(hWndTrackbar, TBM_GETNUMTICS, 0,0);
 791     expect(3, r);
 792     SendMessage(hWndTrackbar, TBM_SETTICFREQ, 15, 0);
 793     r = SendMessage(hWndTrackbar, TBM_GETNUMTICS, 0,0);
 794     expect(2, r);
 795
 796     /* test TBM_GETNUMTICS */
 797     /* since TIC FREQ is 15, there should be only 2 tics now */
 798     r = SendMessage(hWndTrackbar, TBM_GETNUMTICS, 0,0);
 799     expect(2, r);
 800
 801     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_settings_test_seq, "tic settings test sequence", TRUE);
 802     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_tic_settings_test_seq, "parent tic settings test sequence", TRUE);
 803 }
 804
 805 static void test_tic_placement(HWND hWndTrackbar){
 806     int r;
 807     DWORD *rPTics;
 808     DWORD numtics;
 809
 810     SendMessage(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(1, 6));
 811     SendMessage(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
 812
 813     numtics = SendMessage(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 814     ok(numtics == 6, "Expected 6, got %d\n", numtics);
 815
 816     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 817     /* test TBM_GETPTICS */
 818     rPTics = (DWORD *) SendMessage(hWndTrackbar, TBM_GETPTICS, 0,0);
 819     expect(2, rPTics[0]);
 820     expect(3, rPTics[1]);
 821     expect(4, rPTics[2]);
 822     expect(5, rPTics[3]);
 823
 824     /* test TBM_GETTIC */
 825     r = SendMessage(hWndTrackbar, TBM_GETTIC, 0,0);
 826     expect(2, r);
 827     r = SendMessage(hWndTrackbar, TBM_GETTIC, 2,0);
 828     expect(4, r);
 829     r = SendMessage(hWndTrackbar, TBM_GETTIC, 4,0);
 830     todo_wine{
 831         expect(-1, r);
 832     }
 833
 834     /* test TBM_GETTICPIC */
 835     r = SendMessage(hWndTrackbar, TBM_GETTICPOS, 0, 0);
 836     ok(r > 0, "Expected r > 0, got %d\n", r);
 837     r = SendMessage(hWndTrackbar, TBM_GETTICPOS, 2, 0);
 838     ok(r > 0, "Expected r > 0, got %d\n", r);
 839
 840     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_placement_test_seq, "get tic placement test sequence", FALSE);
 841     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent get tic placement test sequence", FALSE);
 842 }
 843
 844
 845 static void test_tool_tips(HWND hWndTrackbar){
 846     int r;
 847     HWND hWndTooltip;
 848     HWND rTest;
 849
 850     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 851     /* testing TBM_SETTIPSIDE */
 852     r = SendMessage(hWndTrackbar, TBM_SETTIPSIDE, TBTS_TOP, 0);
 853     todo_wine{
 854         expect(0, r);
 855     }
 856     r = SendMessage(hWndTrackbar, TBM_SETTIPSIDE, TBTS_LEFT, 0);
 857     expect(0, r);
 858     r = SendMessage(hWndTrackbar, TBM_SETTIPSIDE, TBTS_BOTTOM, 0);
 859     expect(1, r);
 860     r = SendMessage(hWndTrackbar, TBM_SETTIPSIDE, TBTS_RIGHT, 0);
 861     expect(2, r);
 862
 863     /* testing TBM_SETTOOLTIPS */
 864     hWndTooltip = CreateWindowEx(WS_EX_TOPMOST, TOOLTIPS_CLASS, NULL, 0,
 865       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 866       NULL, NULL, NULL, NULL);
 867
 868     ok(hWndTooltip != NULL, "Expected non NULL value\n");
 869     if (hWndTooltip != NULL){
 870         SendMessage(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 0);
 871         rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 872         ok(rTest == hWndTooltip, "Expected hWndToolTip, got\n");
 873         SendMessage(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) NULL, 0);
 874         rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 875         ok(rTest == NULL, "Expected NULL\n");
 876         SendMessage(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 5);
 877         rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 878         ok(rTest == hWndTooltip, "Expected hWndTooltip, got\n");
 879     } else
 880         skip("tool tip control not present?\n");
 881
 882     /* test TBM_GETTOOLTIPS */
 883     rTest = (HWND) SendMessage(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 884     ok(rTest == hWndTooltip, "Expected hWndTooltip\n");
 885
 886     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tool_tips_test_seq, "tool tips test sequence", FALSE);
 887     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent tool tips test sequence", FALSE);
 888 }
 889
 890
 891 static void test_unicode(HWND hWndTrackbar){
 892     int r;
 893
 894     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 895     /* testing TBM_SETUNICODEFORMAT */
 896     r = SendMessage(hWndTrackbar, TBM_SETUNICODEFORMAT, TRUE, 0);
 897     ok(r == FALSE, "Expected FALSE, got %d\n",r);
 898     r = SendMessage(hWndTrackbar, TBM_SETUNICODEFORMAT, FALSE, 0);
 899     ok(r == TRUE, "Expected TRUE, got %d\n",r);
 900
 901     /* test TBM_GETUNICODEFORMAT */
 902     r = SendMessage(hWndTrackbar, TBM_GETUNICODEFORMAT, 0,0);
 903     ok(r == FALSE, "Expected FALSE, got %d\n",r);
 904
 905     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, unicode_test_seq, "unicode test sequence", FALSE);
 906     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent unicode test sequence", FALSE);
 907 }
 908
 909 static void test_ignore_selection(HWND hWndTrackbar){
 910     int r;
 911
 912     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 913     /* test TBM_SETSEL  ensure that it is ignored */
 914     SendMessage(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
 915     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 916     expect(0, r);
 917     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 918     expect(0, r);
 919     SendMessage(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(0,10));
 920     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 921     expect(0, r);
 922     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 923     expect(0, r);
 924
 925     /* test TBM_SETSELEND, ensure that it is ignored */
 926     SendMessage(hWndTrackbar, TBM_SETSELEND, TRUE, 0);
 927     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 928     expect(0, r);
 929     SendMessage(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
 930     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 931     expect(0,r);
 932     SendMessage(hWndTrackbar, TBM_SETSELEND, FALSE, 0);
 933     r = SendMessage(hWndTrackbar, TBM_GETSELEND, 0,0);
 934     expect(0, r);
 935
 936     /* test TBM_SETSELSTART, ensure that it is ignored */
 937     SendMessage(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
 938     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 939     expect(0, r);
 940     SendMessage(hWndTrackbar, TBM_SETSELSTART, TRUE, 10);
 941     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 942     expect(0,r);
 943     SendMessage(hWndTrackbar, TBM_SETSELSTART, FALSE, 0);
 944     r = SendMessage(hWndTrackbar, TBM_GETSELSTART, 0,0);
 945     expect(0, r);
 946
 947     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, ignore_selection_test_seq, "ignore selection setting test sequence", FALSE);
 948     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_empty_test_seq, "parent ignore selection setting test sequence", FALSE);
 949 }
 950
 951 START_TEST(trackbar)
 952 {
 953     DWORD style = WS_VISIBLE | TBS_TOOLTIPS | TBS_ENABLESELRANGE | TBS_FIXEDLENGTH | TBS_AUTOTICKS;
 954     HWND hWndTrackbar;
 955     HWND hWndParent;
 956
 957     init_msg_sequences(sequences, NUM_MSG_SEQUENCE);
 958     InitCommonControls();
 959
 960     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 961
 962     /* create parent window */
 963     hWndParent = create_parent_window();
 964     ok(hWndParent != NULL, "Failed to create parent Window!\n");
 965
 966     if(!hWndParent){
 967         skip("parent window not present\n");
 968         return;
 969     }
 970
 971     ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create Parent Window", TRUE);
 972     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 973
 974     /* create trackbar with set styles */
 975     hWndTrackbar = create_trackbar(style, hWndParent);
 976
 977     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 978
 979     if (!hWndTrackbar){
 980         skip("trackbar control not present?\n");
 981         return;
 982     }
 983
 984     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, create_trackbar_wnd_seq, "create Trackbar Window", FALSE);
 985     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_create_trackbar_wnd_seq, "parent trackbar window", TRUE);
 986     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 987
 988     /* TEST OF ALL SETTER and GETTER MESSAGES with required styles turned on*/
 989     test_trackbar_buddy(hWndTrackbar);
 990     test_line_size(hWndTrackbar);
 991     test_page_size(hWndTrackbar);
 992     test_position(hWndTrackbar);
 993     test_range(hWndTrackbar);
 994     test_selection(hWndTrackbar);
 995     test_thumb_length(hWndTrackbar);
 996     test_tic_settings(hWndTrackbar);
 997     test_tic_placement(hWndTrackbar);
 998     test_tool_tips(hWndTrackbar);
 999     test_unicode(hWndTrackbar);
1000
1001     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1002     DestroyWindow(hWndTrackbar);
1003
1004     /* test getters and setters without styles set */
1005     hWndTrackbar = create_trackbar(0, hWndParent);
1006
1007     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1008
1009     if (!hWndTrackbar){
1010         skip("trackbar control not present?\n");
1011         return;
1012     }
1013
1014     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_new_window_test_seq, "new trackbar window test sequence", TRUE);
1015
1016     test_ignore_selection(hWndTrackbar);
1017
1018     DestroyWindow(hWndTrackbar);
1019
1020     DestroyWindow(hWndParent);
1021 }