uspace/lib/ui/test/tab.c

   1 /*
   2  * Copyright (c) 2023 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <gfx/context.h>
  30 #include <gfx/coord.h>
  31 #include <mem.h>
  32 #include <pcut/pcut.h>
  33 #include <stdbool.h>
  34 #include <str.h>
  35 #include <ui/control.h>
  36 #include <ui/tab.h>
  37 #include <ui/tabset.h>
  38 #include <ui/testctl.h>
  39 #include <ui/ui.h>
  40 #include <ui/window.h>
  41 #include "../private/resource.h"
  42 #include "../private/tab.h"
  43 #include "../private/tabset.h"
  44
  45 PCUT_INIT;
  46
  47 PCUT_TEST_SUITE(tab);
  48
  49 /** Create and destroy tab */
  50 PCUT_TEST(create_destroy)
  51 {
  52         ui_t *ui = NULL;
  53         ui_window_t *window = NULL;
  54         ui_wnd_params_t params;
  55         ui_resource_t *res;
  56         ui_tab_set_t *tabset = NULL;
  57         ui_tab_t *tab = NULL;
  58         errno_t rc;
  59
  60         rc = ui_create_disp(NULL, &ui);
  61         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
  62
  63         ui_wnd_params_init(&params);
  64         params.caption = "Hello";
  65
  66         rc = ui_window_create(ui, &params, &window);
  67         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
  68         PCUT_ASSERT_NOT_NULL(window);
  69
  70         res = ui_window_get_res(window);
  71
  72         rc = ui_tab_set_create(res, &tabset);
  73         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
  74
  75         rc = ui_tab_create(tabset, "Test", &tab);
  76         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
  77         PCUT_ASSERT_NOT_NULL(tab);
  78
  79         /*
  80          * Normally we don't need to destroy a tab explicitly, it will
  81          * be destroyed along with tab bar, but here we'll test destroying
  82          * it explicitly.
  83          */
  84         ui_tab_destroy(tab);
  85         ui_tab_set_destroy(tabset);
  86
  87         ui_window_destroy(window);
  88         ui_destroy(ui);
  89 }
  90
  91 /** Destroy tab implicitly by destroying the tab set */
  92 PCUT_TEST(implicit_destroy)
  93 {
  94         ui_t *ui = NULL;
  95         ui_window_t *window = NULL;
  96         ui_wnd_params_t params;
  97         ui_resource_t *res;
  98         ui_tab_set_t *tabset = NULL;
  99         ui_tab_t *tab = NULL;
 100         errno_t rc;
 101
 102         rc = ui_create_disp(NULL, &ui);
 103         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 104
 105         ui_wnd_params_init(&params);
 106         params.caption = "Hello";
 107
 108         rc = ui_window_create(ui, &params, &window);
 109         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 110         PCUT_ASSERT_NOT_NULL(window);
 111
 112         res = ui_window_get_res(window);
 113
 114         rc = ui_tab_set_create(res, &tabset);
 115         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 116
 117         rc = ui_tab_create(tabset, "Test", &tab);
 118         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 119         PCUT_ASSERT_NOT_NULL(tab);
 120
 121         /* Let the tab be destroyed as part of destroying tab set */
 122         ui_tab_set_destroy(tabset);
 123
 124         ui_window_destroy(window);
 125         ui_destroy(ui);
 126 }
 127
 128 /** ui_tab_destroy() can take NULL argument (no-op) */
 129 PCUT_TEST(destroy_null)
 130 {
 131         ui_tab_destroy(NULL);
 132 }
 133
 134 /** ui_tab_first() / ui_tab_next() iterate over tabs */
 135 PCUT_TEST(first_next)
 136 {
 137         ui_t *ui = NULL;
 138         ui_window_t *window = NULL;
 139         ui_wnd_params_t params;
 140         ui_resource_t *res;
 141         ui_tab_set_t *tabset = NULL;
 142         ui_tab_t *tab1 = NULL;
 143         ui_tab_t *tab2 = NULL;
 144         ui_tab_t *t;
 145         errno_t rc;
 146
 147         rc = ui_create_disp(NULL, &ui);
 148         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 149
 150         ui_wnd_params_init(&params);
 151         params.caption = "Hello";
 152
 153         rc = ui_window_create(ui, &params, &window);
 154         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 155         PCUT_ASSERT_NOT_NULL(window);
 156
 157         res = ui_window_get_res(window);
 158
 159         rc = ui_tab_set_create(res, &tabset);
 160         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 161         PCUT_ASSERT_NOT_NULL(tabset);
 162
 163         rc = ui_tab_create(tabset, "Test 1", &tab1);
 164         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 165         PCUT_ASSERT_NOT_NULL(tab1);
 166
 167         rc = ui_tab_create(tabset, "Test 2", &tab2);
 168         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 169         PCUT_ASSERT_NOT_NULL(tab2);
 170
 171         t = ui_tab_first(tabset);
 172         PCUT_ASSERT_EQUALS(tab1, t);
 173
 174         t = ui_tab_next(t);
 175         PCUT_ASSERT_EQUALS(tab2, t);
 176
 177         t = ui_tab_next(t);
 178         PCUT_ASSERT_NULL(t);
 179
 180         ui_tab_set_destroy(tabset);
 181         ui_window_destroy(window);
 182         ui_destroy(ui);
 183 }
 184
 185 /** ui_tab_last() / ui_tab_prev() iterate over tabs in reverse */
 186 PCUT_TEST(last_prev)
 187 {
 188         ui_t *ui = NULL;
 189         ui_window_t *window = NULL;
 190         ui_wnd_params_t params;
 191         ui_resource_t *res;
 192         ui_tab_set_t *tabset = NULL;
 193         ui_tab_t *tab1 = NULL;
 194         ui_tab_t *tab2 = NULL;
 195         ui_tab_t *t;
 196         errno_t rc;
 197
 198         rc = ui_create_disp(NULL, &ui);
 199         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 200
 201         ui_wnd_params_init(&params);
 202         params.caption = "Hello";
 203
 204         rc = ui_window_create(ui, &params, &window);
 205         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 206         PCUT_ASSERT_NOT_NULL(window);
 207
 208         res = ui_window_get_res(window);
 209
 210         rc = ui_tab_set_create(res, &tabset);
 211         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 212         PCUT_ASSERT_NOT_NULL(tabset);
 213
 214         rc = ui_tab_create(tabset, "Test 1", &tab1);
 215         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 216         PCUT_ASSERT_NOT_NULL(tab1);
 217
 218         rc = ui_tab_create(tabset, "Test 2", &tab2);
 219         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 220         PCUT_ASSERT_NOT_NULL(tab2);
 221
 222         t = ui_tab_last(tabset);
 223         PCUT_ASSERT_EQUALS(tab2, t);
 224
 225         t = ui_tab_prev(t);
 226         PCUT_ASSERT_EQUALS(tab1, t);
 227
 228         t = ui_tab_prev(t);
 229         PCUT_ASSERT_NULL(t);
 230
 231         ui_tab_set_destroy(tabset);
 232         ui_window_destroy(window);
 233         ui_destroy(ui);
 234 }
 235
 236 /** ui_tab_is_selected() correctly returns tab state */
 237 PCUT_TEST(is_selected)
 238 {
 239         ui_t *ui = NULL;
 240         ui_window_t *window = NULL;
 241         ui_wnd_params_t params;
 242         ui_resource_t *res;
 243         ui_tab_set_t *tabset = NULL;
 244         ui_tab_t *tab1 = NULL;
 245         ui_tab_t *tab2 = NULL;
 246         errno_t rc;
 247
 248         rc = ui_create_disp(NULL, &ui);
 249         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 250
 251         ui_wnd_params_init(&params);
 252         params.caption = "Hello";
 253
 254         rc = ui_window_create(ui, &params, &window);
 255         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 256         PCUT_ASSERT_NOT_NULL(window);
 257
 258         res = ui_window_get_res(window);
 259
 260         rc = ui_tab_set_create(res, &tabset);
 261         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 262         PCUT_ASSERT_NOT_NULL(tabset);
 263
 264         rc = ui_tab_create(tabset, "Test 1", &tab1);
 265         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 266
 267         /* The first added tab should be automatically selected */
 268         PCUT_ASSERT_TRUE(ui_tab_is_selected(tab1));
 269
 270         rc = ui_tab_create(tabset, "Test 2", &tab2);
 271         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 272
 273         /* After adding a second tab the first should still be selected */
 274         PCUT_ASSERT_TRUE(ui_tab_is_selected(tab1));
 275         PCUT_ASSERT_FALSE(ui_tab_is_selected(tab2));
 276
 277         /* Select second tab */
 278         ui_tab_set_select(tabset, tab2);
 279
 280         /* Now the second tab should be selected */
 281         PCUT_ASSERT_FALSE(ui_tab_is_selected(tab1));
 282         PCUT_ASSERT_TRUE(ui_tab_is_selected(tab2));
 283
 284         ui_tab_set_destroy(tabset);
 285         ui_window_destroy(window);
 286         ui_destroy(ui);
 287 }
 288
 289 /** ui_tab_add() adds control to tab */
 290 PCUT_TEST(add)
 291 {
 292         ui_t *ui = NULL;
 293         ui_window_t *window = NULL;
 294         ui_wnd_params_t params;
 295         ui_resource_t *res;
 296         ui_tab_set_t *tabset = NULL;
 297         ui_tab_t *tab = NULL;
 298         ui_test_ctl_t *testctl = NULL;
 299         ui_tc_resp_t resp;
 300         errno_t rc;
 301
 302         rc = ui_create_disp(NULL, &ui);
 303         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 304
 305         ui_wnd_params_init(&params);
 306         params.caption = "Hello";
 307
 308         rc = ui_window_create(ui, &params, &window);
 309         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 310         PCUT_ASSERT_NOT_NULL(window);
 311
 312         res = ui_window_get_res(window);
 313
 314         rc = ui_tab_set_create(res, &tabset);
 315         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 316         PCUT_ASSERT_NOT_NULL(tabset);
 317
 318         rc = ui_tab_create(tabset, "Test", &tab);
 319         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 320         PCUT_ASSERT_NOT_NULL(tab);
 321
 322         rc = ui_test_ctl_create(&resp, &testctl);
 323         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 324
 325         /* Add test control to tab */
 326         ui_tab_add(tab, ui_test_ctl_ctl(testctl));
 327
 328         resp.destroy = false;
 329
 330         ui_tab_set_destroy(tabset);
 331
 332         /* Destroying the tab should have destroyed the control as well */
 333         PCUT_ASSERT_TRUE(resp.destroy);
 334
 335         ui_window_destroy(window);
 336         ui_destroy(ui);
 337 }
 338
 339 /** ui_tab_remove() removes control to tab */
 340 PCUT_TEST(remove)
 341 {
 342         ui_t *ui = NULL;
 343         ui_window_t *window = NULL;
 344         ui_wnd_params_t params;
 345         ui_resource_t *res;
 346         ui_tab_set_t *tabset = NULL;
 347         ui_tab_t *tab = NULL;
 348         ui_test_ctl_t *testctl = NULL;
 349         ui_tc_resp_t resp;
 350         errno_t rc;
 351
 352         rc = ui_create_disp(NULL, &ui);
 353         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 354
 355         ui_wnd_params_init(&params);
 356         params.caption = "Hello";
 357
 358         rc = ui_window_create(ui, &params, &window);
 359         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 360         PCUT_ASSERT_NOT_NULL(window);
 361
 362         res = ui_window_get_res(window);
 363
 364         rc = ui_tab_set_create(res, &tabset);
 365         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 366         PCUT_ASSERT_NOT_NULL(tabset);
 367
 368         rc = ui_tab_create(tabset, "Test", &tab);
 369         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 370         PCUT_ASSERT_NOT_NULL(tab);
 371
 372         rc = ui_test_ctl_create(&resp, &testctl);
 373         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 374
 375         /* Add test control to tab */
 376         ui_tab_add(tab, ui_test_ctl_ctl(testctl));
 377
 378         /* Rmove control from tab */
 379         ui_tab_remove(tab, ui_test_ctl_ctl(testctl));
 380
 381         resp.destroy = false;
 382
 383         ui_tab_set_destroy(tabset);
 384
 385         /* Destroying the tab should NOT have destroyed the control */
 386         PCUT_ASSERT_FALSE(resp.destroy);
 387
 388         ui_test_ctl_destroy(testctl);
 389         ui_window_destroy(window);
 390         ui_destroy(ui);
 391 }
 392
 393 /** Paint tab */
 394 PCUT_TEST(paint)
 395 {
 396         ui_t *ui = NULL;
 397         ui_window_t *window = NULL;
 398         ui_wnd_params_t params;
 399         ui_resource_t *res;
 400         ui_tab_set_t *tabset = NULL;
 401         ui_tab_t *tab = NULL;
 402         errno_t rc;
 403
 404         rc = ui_create_disp(NULL, &ui);
 405         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 406
 407         ui_wnd_params_init(&params);
 408         params.caption = "Hello";
 409
 410         rc = ui_window_create(ui, &params, &window);
 411         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 412         PCUT_ASSERT_NOT_NULL(window);
 413
 414         res = ui_window_get_res(window);
 415
 416         rc = ui_tab_set_create(res, &tabset);
 417         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 418         PCUT_ASSERT_NOT_NULL(tabset);
 419
 420         rc = ui_tab_create(tabset, "Test", &tab);
 421         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 422         PCUT_ASSERT_NOT_NULL(tab);
 423
 424         rc = ui_tab_paint(tab);
 425         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 426
 427         ui_tab_set_destroy(tabset);
 428         ui_window_destroy(window);
 429         ui_destroy(ui);
 430 }
 431
 432 /** ui_tab_kbd_event() delivers keyboard event */
 433 PCUT_TEST(kbd_event)
 434 {
 435         ui_t *ui = NULL;
 436         ui_window_t *window = NULL;
 437         ui_wnd_params_t params;
 438         ui_resource_t *res;
 439         ui_tab_set_t *tabset = NULL;
 440         ui_tab_t *tab = NULL;
 441         ui_evclaim_t claimed;
 442         kbd_event_t event;
 443         ui_test_ctl_t *testctl = NULL;
 444         ui_tc_resp_t resp;
 445         errno_t rc;
 446
 447         rc = ui_create_disp(NULL, &ui);
 448         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 449
 450         ui_wnd_params_init(&params);
 451         params.caption = "Hello";
 452
 453         rc = ui_window_create(ui, &params, &window);
 454         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 455         PCUT_ASSERT_NOT_NULL(window);
 456
 457         res = ui_window_get_res(window);
 458
 459         rc = ui_tab_set_create(res, &tabset);
 460         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 461         PCUT_ASSERT_NOT_NULL(tabset);
 462
 463         /* Without anytabs, event should be unclaimed */
 464         event.type = KEY_PRESS;
 465         event.key = KC_ENTER;
 466         event.mods = 0;
 467         claimed = ui_tab_set_kbd_event(tabset, &event);
 468         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 469         PCUT_ASSERT_EQUALS(ui_unclaimed, claimed);
 470
 471         rc = ui_tab_create(tabset, "Test", &tab);
 472         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 473         PCUT_ASSERT_NOT_NULL(tab);
 474
 475         rc = ui_test_ctl_create(&resp, &testctl);
 476         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 477
 478         /* Set up response */
 479         ui_tab_add(tab, ui_test_ctl_ctl(testctl));
 480         resp.claim = ui_claimed;
 481         resp.kbd = false;
 482
 483         /* Send keyboard event */
 484         event.type = KEY_PRESS;
 485         event.key = KC_F10;
 486         event.mods = 0;
 487         claimed = ui_tab_kbd_event(tab, &event);
 488         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 489         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
 490
 491         /* Make sure event was delivered */
 492         PCUT_ASSERT_TRUE(resp.kbd);
 493         PCUT_ASSERT_EQUALS(event.type, resp.kevent.type);
 494         PCUT_ASSERT_EQUALS(event.key, resp.kevent.key);
 495         PCUT_ASSERT_EQUALS(event.mods, resp.kevent.mods);
 496
 497         ui_tab_set_destroy(tabset);
 498         ui_window_destroy(window);
 499         ui_destroy(ui);
 500 }
 501
 502 /** ui_tab_pos_event() delivers position event */
 503 PCUT_TEST(pos_event)
 504 {
 505         ui_t *ui = NULL;
 506         ui_window_t *window = NULL;
 507         ui_wnd_params_t params;
 508         ui_resource_t *res;
 509         ui_tab_set_t *tabset = NULL;
 510         gfx_rect_t rect;
 511         ui_tab_t *tab = NULL;
 512         ui_evclaim_t claimed;
 513         pos_event_t event;
 514         ui_test_ctl_t *testctl = NULL;
 515         ui_tc_resp_t resp;
 516         errno_t rc;
 517
 518         rc = ui_create_disp(NULL, &ui);
 519         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 520
 521         ui_wnd_params_init(&params);
 522         params.caption = "Hello";
 523
 524         rc = ui_window_create(ui, &params, &window);
 525         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 526         PCUT_ASSERT_NOT_NULL(window);
 527
 528         res = ui_window_get_res(window);
 529
 530         rc = ui_tab_set_create(res, &tabset);
 531         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 532         PCUT_ASSERT_NOT_NULL(tabset);
 533
 534         rect.p0.x = 0;
 535         rect.p0.y = 0;
 536         rect.p1.x = 100;
 537         rect.p1.y = 200;
 538         ui_tab_set_set_rect(tabset, &rect);
 539
 540         rc = ui_tab_create(tabset, "Test", &tab);
 541         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 542         PCUT_ASSERT_NOT_NULL(tab);
 543
 544         rc = ui_test_ctl_create(&resp, &testctl);
 545         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 546
 547         /* Set up response */
 548         ui_tab_add(tab, ui_test_ctl_ctl(testctl));
 549         resp.claim = ui_claimed;
 550         resp.pos = false;
 551
 552         /* Send position event */
 553         event.type = POS_PRESS;
 554         event.hpos = 10;
 555         event.vpos = 40;
 556         claimed = ui_tab_pos_event(tab, &event);
 557         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 558         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
 559
 560         /* Make sure event was delivered */
 561         PCUT_ASSERT_TRUE(resp.pos);
 562         PCUT_ASSERT_EQUALS(event.type, resp.pevent.type);
 563         PCUT_ASSERT_EQUALS(event.hpos, resp.pevent.hpos);
 564         PCUT_ASSERT_EQUALS(event.vpos, resp.pevent.vpos);
 565
 566         ui_tab_set_destroy(tabset);
 567         ui_window_destroy(window);
 568         ui_destroy(ui);
 569 }
 570
 571 /** ui_tab_handle_width() and ui_tab_handle_height() return dimensions */
 572 PCUT_TEST(handle_width_height)
 573 {
 574         ui_t *ui = NULL;
 575         ui_window_t *window = NULL;
 576         ui_wnd_params_t params;
 577         ui_resource_t *res;
 578         ui_tab_set_t *tabset = NULL;
 579         ui_tab_t *tab = NULL;
 580         gfx_coord_t w, h;
 581         errno_t rc;
 582
 583         rc = ui_create_disp(NULL, &ui);
 584         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 585
 586         ui_wnd_params_init(&params);
 587         params.caption = "Hello";
 588
 589         rc = ui_window_create(ui, &params, &window);
 590         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 591         PCUT_ASSERT_NOT_NULL(window);
 592
 593         res = ui_window_get_res(window);
 594
 595         rc = ui_tab_set_create(res, &tabset);
 596         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 597         PCUT_ASSERT_NOT_NULL(tabset);
 598
 599         rc = ui_tab_create(tabset, "Test", &tab);
 600         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 601         PCUT_ASSERT_NOT_NULL(tab);
 602
 603         w = ui_tab_handle_width(tab);
 604         h = ui_tab_handle_height(tab);
 605
 606         PCUT_ASSERT_INT_EQUALS(50, w);
 607         PCUT_ASSERT_INT_EQUALS(25, h);
 608
 609         ui_tab_set_destroy(tabset);
 610         ui_window_destroy(window);
 611         ui_destroy(ui);
 612 }
 613
 614 /** Computing tab geometry */
 615 PCUT_TEST(get_geom)
 616 {
 617         ui_t *ui = NULL;
 618         ui_window_t *window = NULL;
 619         ui_wnd_params_t params;
 620         ui_resource_t *res;
 621         ui_tab_set_t *tabset = NULL;
 622         ui_tab_t *tab = NULL;
 623         ui_tab_geom_t geom;
 624         gfx_rect_t rect;
 625         errno_t rc;
 626
 627         rc = ui_create_disp(NULL, &ui);
 628         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 629
 630         ui_wnd_params_init(&params);
 631         params.caption = "Hello";
 632
 633         rc = ui_window_create(ui, &params, &window);
 634         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 635         PCUT_ASSERT_NOT_NULL(window);
 636
 637         res = ui_window_get_res(window);
 638
 639         rc = ui_tab_set_create(res, &tabset);
 640         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 641         PCUT_ASSERT_NOT_NULL(tabset);
 642
 643         rect.p0.x = 1000;
 644         rect.p0.y = 2000;
 645         rect.p1.x = 1100;
 646         rect.p1.y = 2200;
 647         ui_tab_set_set_rect(tabset, &rect);
 648
 649         rc = ui_tab_create(tabset, "Test", &tab);
 650         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 651         PCUT_ASSERT_NOT_NULL(tab);
 652
 653         ui_tab_get_geom(tab, &geom);
 654
 655         PCUT_ASSERT_INT_EQUALS(1006, geom.handle.p0.x);
 656         PCUT_ASSERT_INT_EQUALS(2000, geom.handle.p0.y);
 657         PCUT_ASSERT_INT_EQUALS(1056, geom.handle.p1.x);
 658         PCUT_ASSERT_INT_EQUALS(2027, geom.handle.p1.y);
 659
 660         PCUT_ASSERT_INT_EQUALS(1006, geom.handle_area.p0.x);
 661         PCUT_ASSERT_INT_EQUALS(2000, geom.handle_area.p0.y);
 662         PCUT_ASSERT_INT_EQUALS(1056, geom.handle_area.p1.x);
 663         PCUT_ASSERT_INT_EQUALS(2027, geom.handle_area.p1.y);
 664
 665         PCUT_ASSERT_INT_EQUALS(1000, geom.body.p0.x);
 666         PCUT_ASSERT_INT_EQUALS(2025, geom.body.p0.y);
 667         PCUT_ASSERT_INT_EQUALS(1100, geom.body.p1.x);
 668         PCUT_ASSERT_INT_EQUALS(2200, geom.body.p1.y);
 669
 670         PCUT_ASSERT_INT_EQUALS(1014, geom.text_pos.x);
 671         PCUT_ASSERT_INT_EQUALS(2007, geom.text_pos.y);
 672
 673         ui_tab_set_destroy(tabset);
 674         ui_window_destroy(window);
 675         ui_destroy(ui);
 676 }
 677
 678 /** ui_tab_patint_handle_frame() */
 679 PCUT_TEST(paint_handle_frame)
 680 {
 681         ui_t *ui = NULL;
 682         ui_window_t *window = NULL;
 683         ui_wnd_params_t params;
 684         ui_resource_t *res;
 685         gfx_context_t *gc;
 686         gfx_rect_t rect;
 687         gfx_rect_t irect;
 688         gfx_coord_t chamfer;
 689         gfx_color_t *hi_color;
 690         gfx_color_t *sh_color;
 691         errno_t rc;
 692
 693         rc = ui_create_disp(NULL, &ui);
 694         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 695
 696         ui_wnd_params_init(&params);
 697         params.caption = "Hello";
 698
 699         rc = ui_window_create(ui, &params, &window);
 700         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 701         PCUT_ASSERT_NOT_NULL(window);
 702
 703         res = ui_window_get_res(window);
 704         gc = ui_window_get_gc(window);
 705
 706         rect.p0.x = 10;
 707         rect.p0.y = 20;
 708         rect.p1.x = 100;
 709         rect.p1.y = 200;
 710
 711         chamfer = 4;
 712
 713         hi_color = res->wnd_highlight_color;
 714         sh_color = res->wnd_shadow_color;
 715
 716         rc = ui_tab_paint_handle_frame(gc, &rect, chamfer, hi_color, sh_color,
 717             true, &irect);
 718         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 719
 720         rc = ui_tab_paint_handle_frame(gc, &rect, chamfer, hi_color, sh_color,
 721             false, &irect);
 722         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 723
 724         ui_window_destroy(window);
 725         ui_destroy(ui);
 726 }
 727
 728 /** ui_tab_paint_body_frame() */
 729 PCUT_TEST(paint_body_frame)
 730 {
 731         ui_t *ui = NULL;
 732         ui_window_t *window = NULL;
 733         ui_wnd_params_t params;
 734         ui_resource_t *res;
 735         ui_tab_set_t *tabset = NULL;
 736         ui_tab_t *tab = NULL;
 737         errno_t rc;
 738
 739         rc = ui_create_disp(NULL, &ui);
 740         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 741
 742         ui_wnd_params_init(&params);
 743         params.caption = "Hello";
 744
 745         rc = ui_window_create(ui, &params, &window);
 746         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 747         PCUT_ASSERT_NOT_NULL(window);
 748
 749         res = ui_window_get_res(window);
 750
 751         rc = ui_tab_set_create(res, &tabset);
 752         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 753         PCUT_ASSERT_NOT_NULL(tabset);
 754
 755         rc = ui_tab_create(tabset, "Test", &tab);
 756         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 757         PCUT_ASSERT_NOT_NULL(tab);
 758
 759         rc = ui_tab_paint_body_frame(tab);
 760         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 761
 762         ui_tab_set_destroy(tabset);
 763         ui_window_destroy(window);
 764         ui_destroy(ui);
 765 }
 766
 767 /** ui_tab_paint_frame() */
 768 PCUT_TEST(paint_frame)
 769 {
 770         ui_t *ui = NULL;
 771         ui_window_t *window = NULL;
 772         ui_wnd_params_t params;
 773         ui_resource_t *res;
 774         ui_tab_set_t *tabset = NULL;
 775         ui_tab_t *tab = NULL;
 776         errno_t rc;
 777
 778         rc = ui_create_disp(NULL, &ui);
 779         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 780
 781         ui_wnd_params_init(&params);
 782         params.caption = "Hello";
 783
 784         rc = ui_window_create(ui, &params, &window);
 785         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 786         PCUT_ASSERT_NOT_NULL(window);
 787
 788         res = ui_window_get_res(window);
 789
 790         rc = ui_tab_set_create(res, &tabset);
 791         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 792         PCUT_ASSERT_NOT_NULL(tabset);
 793
 794         rc = ui_tab_create(tabset, "Test", &tab);
 795         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 796         PCUT_ASSERT_NOT_NULL(tab);
 797
 798         rc = ui_tab_paint_frame(tab);
 799         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 800
 801         ui_tab_set_destroy(tabset);
 802         ui_window_destroy(window);
 803         ui_destroy(ui);
 804 }
 805
 806 /** ui_tab_get_res() returns the resource */
 807 PCUT_TEST(get_res)
 808 {
 809         ui_t *ui = NULL;
 810         ui_window_t *window = NULL;
 811         ui_wnd_params_t params;
 812         ui_resource_t *res;
 813         ui_tab_set_t *tabset = NULL;
 814         ui_tab_t *tab = NULL;
 815         errno_t rc;
 816
 817         rc = ui_create_disp(NULL, &ui);
 818         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 819
 820         ui_wnd_params_init(&params);
 821         params.caption = "Hello";
 822
 823         rc = ui_window_create(ui, &params, &window);
 824         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 825         PCUT_ASSERT_NOT_NULL(window);
 826
 827         res = ui_window_get_res(window);
 828
 829         rc = ui_tab_set_create(res, &tabset);
 830         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 831         PCUT_ASSERT_NOT_NULL(tabset);
 832
 833         rc = ui_tab_create(tabset, "Test", &tab);
 834         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 835         PCUT_ASSERT_NOT_NULL(tab);
 836
 837         PCUT_ASSERT_EQUALS(res, ui_tab_get_res(tab));
 838
 839         ui_tab_set_destroy(tabset);
 840         ui_window_destroy(window);
 841         ui_destroy(ui);
 842 }
 843
 844 PCUT_EXPORT(tab);