Changeset 7cf5ddb in mainline for uspace/lib/ui/test/filelist.c


Ignore:
Timestamp:
2023-03-08T18:21:22Z (14 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
42c2e65, 72ac106
Parents:
bea6233
Message:

Generic UI list control

Derived from file list, now file list is based on UI list.
Whew!

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ui/test/filelist.c

    rbea6233 r7cf5ddb  
    11/*
    2  * Copyright (c) 2022 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3737#include <vfs/vfs.h>
    3838#include "../private/filelist.h"
     39#include "../private/list.h"
    3940
    4041PCUT_INIT;
    … …  
    117118}
    118119
    119 /** ui_file_list_entry_height() gives the correct height */
    120 PCUT_TEST(entry_height)
    121 {
    122         ui_t *ui;
    123         ui_window_t *window;
    124         ui_wnd_params_t params;
    125         ui_file_list_t *flist;
    126         errno_t rc;
    127         gfx_coord_t height;
    128 
    129         rc = ui_create_disp(NULL, &ui);
    130         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    131 
    132         ui_wnd_params_init(&params);
    133         params.caption = "Test";
    134 
    135         rc = ui_window_create(ui, &params, &window);
    136         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    137 
    138         rc = ui_file_list_create(window, true, &flist);
    139         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    140 
    141         /* Font height is 13, padding: 2 (top) + 2 (bottom) */
    142         height = ui_file_list_entry_height(flist);
    143         PCUT_ASSERT_INT_EQUALS(17, height);
    144 
    145         ui_file_list_destroy(flist);
    146         ui_window_destroy(window);
    147         ui_destroy(ui);
    148 }
    149 
    150 /** Test ui_file_list_entry_paint() */
    151 PCUT_TEST(entry_paint)
    152 {
    153         ui_t *ui;
    154         ui_window_t *window;
    155         ui_wnd_params_t params;
    156         ui_file_list_t *flist;
    157         ui_file_list_entry_attr_t attr;
    158         errno_t rc;
    159 
    160         rc = ui_create_disp(NULL, &ui);
    161         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    162 
    163         ui_wnd_params_init(&params);
    164         params.caption = "Test";
    165 
    166         rc = ui_window_create(ui, &params, &window);
    167         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    168 
    169         rc = ui_file_list_create(window, true, &flist);
    170         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    171 
    172         ui_file_list_entry_attr_init(&attr);
    173         attr.name = "a";
    174         attr.size = 1;
    175 
    176         rc = ui_file_list_entry_append(flist, &attr);
    177         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178 
    179         rc = ui_file_list_entry_paint(ui_file_list_first(flist), 0);
    180         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    181 
    182         ui_file_list_destroy(flist);
    183         ui_window_destroy(window);
    184         ui_destroy(ui);
    185 }
    186 
    187120/** Test ui_file_list_paint() */
    188121PCUT_TEST(paint)
    … …  
    238171        control = ui_file_list_ctl(flist);
    239172        PCUT_ASSERT_NOT_NULL(control);
    240 
    241         ui_file_list_destroy(flist);
    242         ui_window_destroy(window);
    243         ui_destroy(ui);
    244 }
    245 
    246 /** Test ui_file_list_kbd_event() */
    247 PCUT_TEST(kbd_event)
    248 {
    249         ui_t *ui;
    250         ui_window_t *window;
    251         ui_wnd_params_t params;
    252         ui_file_list_t *flist;
    253         ui_evclaim_t claimed;
    254         kbd_event_t event;
    255         errno_t rc;
    256 
    257         /* Active file list should claim events */
    258 
    259         rc = ui_create_disp(NULL, &ui);
    260         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    261 
    262         ui_wnd_params_init(&params);
    263         params.caption = "Test";
    264 
    265         rc = ui_window_create(ui, &params, &window);
    266         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    267 
    268         rc = ui_file_list_create(window, true, &flist);
    269         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    270 
    271         event.type = KEY_PRESS;
    272         event.key = KC_ESCAPE;
    273         event.mods = 0;
    274         event.c = '\0';
    275 
    276         claimed = ui_file_list_kbd_event(flist, &event);
    277         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
    278 
    279         ui_file_list_destroy(flist);
    280 
    281         /* Inactive file list should not claim events */
    282 
    283         rc = ui_create_disp(NULL, &ui);
    284         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    285 
    286         ui_wnd_params_init(&params);
    287         params.caption = "Test";
    288 
    289         rc = ui_window_create(ui, &params, &window);
    290         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    291 
    292         rc = ui_file_list_create(window, false, &flist);
    293         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    294 
    295         event.type = KEY_PRESS;
    296         event.key = KC_ESCAPE;
    297         event.mods = 0;
    298         event.c = '\0';
    299 
    300         claimed = ui_file_list_kbd_event(flist, &event);
    301         PCUT_ASSERT_EQUALS(ui_unclaimed, claimed);
    302 
    303         ui_file_list_destroy(flist);
    304         ui_window_destroy(window);
    305         ui_destroy(ui);
    306 }
    307 
    308 /** Test ui_file_list_pos_event() */
    309 PCUT_TEST(pos_event)
    310 {
    311         ui_t *ui;
    312         ui_window_t *window;
    313         ui_wnd_params_t params;
    314         ui_file_list_t *flist;
    315         ui_evclaim_t claimed;
    316         pos_event_t event;
    317         gfx_rect_t rect;
    318         ui_file_list_entry_attr_t attr;
    319         errno_t rc;
    320 
    321         rc = ui_create_disp(NULL, &ui);
    322         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    323 
    324         ui_wnd_params_init(&params);
    325         params.caption = "Test";
    326 
    327         rc = ui_window_create(ui, &params, &window);
    328         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    329 
    330         rc = ui_file_list_create(window, true, &flist);
    331         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    332 
    333         rect.p0.x = 10;
    334         rect.p0.y = 20;
    335         rect.p1.x = 50;
    336         rect.p1.y = 220;
    337 
    338         ui_file_list_set_rect(flist, &rect);
    339 
    340         ui_file_list_entry_attr_init(&attr);
    341         attr.name = "a";
    342         attr.size = 1;
    343         rc = ui_file_list_entry_append(flist, &attr);
    344         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    345 
    346         attr.name = "b";
    347         attr.size = 2;
    348         rc = ui_file_list_entry_append(flist, &attr);
    349         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    350 
    351         attr.name = "c";
    352         attr.size = 3;
    353         rc = ui_file_list_entry_append(flist, &attr);
    354         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    355 
    356         flist->cursor = ui_file_list_first(flist);
    357         flist->cursor_idx = 0;
    358         flist->page = ui_file_list_first(flist);
    359         flist->page_idx = 0;
    360 
    361         event.pos_id = 0;
    362         event.type = POS_PRESS;
    363         event.btn_num = 1;
    364 
    365         /* Clicking on the middle entry should select it */
    366         event.hpos = 20;
    367         event.vpos = 40;
    368 
    369         claimed = ui_file_list_pos_event(flist, &event);
    370         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
    371 
    372         PCUT_ASSERT_NOT_NULL(flist->cursor);
    373         PCUT_ASSERT_STR_EQUALS("b", flist->cursor->name);
    374         PCUT_ASSERT_INT_EQUALS(2, flist->cursor->size);
    375 
    376         /* Clicking on the top edge should do a page-up */
    377         event.hpos = 20;
    378         event.vpos = 20;
    379         claimed = ui_file_list_pos_event(flist, &event);
    380         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
    381 
    382         PCUT_ASSERT_NOT_NULL(flist->cursor);
    383         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    384         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    385173
    386174        ui_file_list_destroy(flist);
    … …  
    417205
    418206        ui_file_list_set_rect(flist, &rect);
    419         PCUT_ASSERT_INT_EQUALS(rect.p0.x, flist->rect.p0.x);
    420         PCUT_ASSERT_INT_EQUALS(rect.p0.y, flist->rect.p0.y);
    421         PCUT_ASSERT_INT_EQUALS(rect.p1.x, flist->rect.p1.x);
    422         PCUT_ASSERT_INT_EQUALS(rect.p1.y, flist->rect.p1.y);
    423 
    424         ui_file_list_destroy(flist);
    425         ui_window_destroy(window);
    426         ui_destroy(ui);
    427 }
    428 
    429 /** ui_file_list_page_size() returns correct size */
    430 PCUT_TEST(page_size)
    431 {
    432         ui_t *ui;
    433         ui_window_t *window;
    434         ui_wnd_params_t params;
    435         ui_file_list_t *flist;
    436         gfx_rect_t rect;
    437         errno_t rc;
    438 
    439         rc = ui_create_disp(NULL, &ui);
    440         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    441 
    442         ui_wnd_params_init(&params);
    443         params.caption = "Test";
    444 
    445         rc = ui_window_create(ui, &params, &window);
    446         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    447 
    448         rc = ui_file_list_create(window, true, &flist);
    449         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    450 
    451         rect.p0.x = 10;
    452         rect.p0.y = 20;
    453         rect.p1.x = 50;
    454         rect.p1.y = 220;
    455 
    456         ui_file_list_set_rect(flist, &rect);
    457 
    458         /* NOTE If page size changes, we have problems elsewhere in the tests */
    459         PCUT_ASSERT_INT_EQUALS(11, ui_file_list_page_size(flist));
    460 
    461         ui_file_list_destroy(flist);
    462         ui_window_destroy(window);
    463         ui_destroy(ui);
    464 }
    465 
    466 /** ui_file_list_inside_rect() gives correct interior rectangle */
    467 PCUT_TEST(inside_rect)
    468 {
    469         ui_t *ui;
    470         ui_window_t *window;
    471         ui_wnd_params_t params;
    472         ui_file_list_t *flist;
    473         gfx_rect_t rect;
    474         gfx_rect_t irect;
    475         errno_t rc;
    476 
    477         rc = ui_create_disp(NULL, &ui);
    478         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    479 
    480         ui_wnd_params_init(&params);
    481         params.caption = "Test";
    482 
    483         rc = ui_window_create(ui, &params, &window);
    484         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    485 
    486         rc = ui_file_list_create(window, true, &flist);
    487         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    488 
    489         rect.p0.x = 10;
    490         rect.p0.y = 20;
    491         rect.p1.x = 50;
    492         rect.p1.y = 220;
    493 
    494         ui_file_list_set_rect(flist, &rect);
    495 
    496         ui_file_list_inside_rect(flist, &irect);
    497         PCUT_ASSERT_INT_EQUALS(10 + 2, irect.p0.x);
    498         PCUT_ASSERT_INT_EQUALS(20 + 2, irect.p0.y);
    499         PCUT_ASSERT_INT_EQUALS(50 - 2 - 23, irect.p1.x);
    500         PCUT_ASSERT_INT_EQUALS(220 - 2, irect.p1.y);
    501 
    502         ui_file_list_destroy(flist);
    503         ui_window_destroy(window);
    504         ui_destroy(ui);
    505 }
    506 
    507 /** ui_file_list_scrollbar_rect() gives correct scrollbar rectangle */
    508 PCUT_TEST(scrollbar_rect)
    509 {
    510         ui_t *ui;
    511         ui_window_t *window;
    512         ui_wnd_params_t params;
    513         ui_file_list_t *flist;
    514         gfx_rect_t rect;
    515         gfx_rect_t srect;
    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 = "Test";
    523 
    524         rc = ui_window_create(ui, &params, &window);
    525         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    526 
    527         rc = ui_file_list_create(window, true, &flist);
    528         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    529 
    530         rect.p0.x = 10;
    531         rect.p0.y = 20;
    532         rect.p1.x = 50;
    533         rect.p1.y = 220;
    534 
    535         ui_file_list_set_rect(flist, &rect);
    536 
    537         ui_file_list_scrollbar_rect(flist, &srect);
    538         PCUT_ASSERT_INT_EQUALS(50 - 2 - 23, srect.p0.x);
    539         PCUT_ASSERT_INT_EQUALS(20 + 2, srect.p0.y);
    540         PCUT_ASSERT_INT_EQUALS(50 - 2, srect.p1.x);
    541         PCUT_ASSERT_INT_EQUALS(220 - 2, srect.p1.y);
    542 
    543         ui_file_list_destroy(flist);
    544         ui_window_destroy(window);
    545         ui_destroy(ui);
    546 }
    547 
    548 /** ui_file_list_scrollbar_update() updates scrollbar position */
    549 PCUT_TEST(scrollbar_update)
    550 {
    551         ui_t *ui;
    552         ui_window_t *window;
    553         ui_wnd_params_t params;
    554         ui_file_list_t *flist;
    555         gfx_rect_t rect;
     207        PCUT_ASSERT_INT_EQUALS(rect.p0.x, flist->list->rect.p0.x);
     208        PCUT_ASSERT_INT_EQUALS(rect.p0.y, flist->list->rect.p0.y);
     209        PCUT_ASSERT_INT_EQUALS(rect.p1.x, flist->list->rect.p1.x);
     210        PCUT_ASSERT_INT_EQUALS(rect.p1.y, flist->list->rect.p1.y);
     211
     212        ui_file_list_destroy(flist);
     213        ui_window_destroy(window);
     214        ui_destroy(ui);
     215}
     216
     217/** ui_file_list_is_active() returns file list activity state */
     218PCUT_TEST(is_active)
     219{
     220        ui_t *ui;
     221        ui_window_t *window;
     222        ui_wnd_params_t params;
     223        ui_file_list_t *flist;
     224        errno_t rc;
     225
     226        rc = ui_create_disp(NULL, &ui);
     227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     228
     229        ui_wnd_params_init(&params);
     230        params.caption = "Test";
     231
     232        rc = ui_window_create(ui, &params, &window);
     233        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     234
     235        rc = ui_file_list_create(window, true, &flist);
     236        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     237        PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
     238        ui_file_list_destroy(flist);
     239
     240        rc = ui_file_list_create(window, false, &flist);
     241        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     242        PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
     243        ui_file_list_destroy(flist);
     244        ui_window_destroy(window);
     245        ui_destroy(ui);
     246}
     247
     248/** ui_file_list_activate() activates file list */
     249PCUT_TEST(activate)
     250{
     251        ui_t *ui;
     252        ui_window_t *window;
     253        ui_wnd_params_t params;
     254        ui_file_list_t *flist;
     255        errno_t rc;
     256
     257        rc = ui_create_disp(NULL, &ui);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259
     260        ui_wnd_params_init(&params);
     261        params.caption = "Test";
     262
     263        rc = ui_window_create(ui, &params, &window);
     264        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     265
     266        rc = ui_file_list_create(window, false, &flist);
     267        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     268
     269        PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
     270        rc = ui_file_list_activate(flist);
     271        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     272        PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
     273
     274        ui_file_list_destroy(flist);
     275        ui_window_destroy(window);
     276        ui_destroy(ui);
     277}
     278
     279/** ui_file_list_deactivate() deactivates file list */
     280PCUT_TEST(deactivate)
     281{
     282        ui_t *ui;
     283        ui_window_t *window;
     284        ui_wnd_params_t params;
     285        ui_file_list_t *flist;
     286        errno_t rc;
     287
     288        rc = ui_create_disp(NULL, &ui);
     289        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     290
     291        ui_wnd_params_init(&params);
     292        params.caption = "Test";
     293
     294        rc = ui_window_create(ui, &params, &window);
     295        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     296
     297        rc = ui_file_list_create(window, true, &flist);
     298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     299
     300        PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
     301        ui_file_list_deactivate(flist);
     302        PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
     303
     304        ui_file_list_destroy(flist);
     305        ui_window_destroy(window);
     306        ui_destroy(ui);
     307}
     308
     309/** ui_file_list_entry_append() appends new entry */
     310PCUT_TEST(entry_append)
     311{
     312        ui_t *ui;
     313        ui_window_t *window;
     314        ui_wnd_params_t params;
     315        ui_file_list_t *flist;
    556316        ui_file_list_entry_attr_t attr;
     317        errno_t rc;
     318
     319        rc = ui_create_disp(NULL, &ui);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321
     322        ui_wnd_params_init(&params);
     323        params.caption = "Test";
     324
     325        rc = ui_window_create(ui, &params, &window);
     326        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     327
     328        rc = ui_file_list_create(window, true, &flist);
     329        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     330
     331        ui_file_list_entry_attr_init(&attr);
     332
     333        attr.name = "a";
     334        attr.size = 1;
     335        rc = ui_file_list_entry_append(flist, &attr);
     336        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     337
     338        PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(flist->list));
     339
     340        attr.name = "b";
     341        attr.size = 2;
     342        rc = ui_file_list_entry_append(flist, &attr);
     343        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     344
     345        PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
     346
     347        ui_file_list_destroy(flist);
     348        ui_window_destroy(window);
     349        ui_destroy(ui);
     350}
     351
     352/** ui_file_list_entry_delete() deletes entry */
     353PCUT_TEST(entry_delete)
     354{
     355        ui_t *ui;
     356        ui_window_t *window;
     357        ui_wnd_params_t params;
     358        ui_file_list_t *flist;
    557359        ui_file_list_entry_t *entry;
    558         gfx_coord_t pos;
    559         gfx_coord_t move_len;
    560         errno_t rc;
    561 
    562         rc = ui_create_disp(NULL, &ui);
    563         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    564 
    565         ui_wnd_params_init(&params);
    566         params.caption = "Test";
    567 
    568         rc = ui_window_create(ui, &params, &window);
    569         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    570 
    571         rc = ui_file_list_create(window, true, &flist);
    572         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    573 
    574         rect.p0.x = 0;
    575         rect.p0.y = 0;
    576         rect.p1.x = 50;
    577         rect.p1.y = 38;
    578 
    579         ui_file_list_set_rect(flist, &rect);
     360        ui_file_list_entry_attr_t attr;
     361        errno_t rc;
     362
     363        rc = ui_create_disp(NULL, &ui);
     364        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     365
     366        ui_wnd_params_init(&params);
     367        params.caption = "Test";
     368
     369        rc = ui_window_create(ui, &params, &window);
     370        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     371
     372        rc = ui_file_list_create(window, true, &flist);
     373        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     374
     375        attr.name = "a";
     376        attr.size = 1;
     377        rc = ui_file_list_entry_append(flist, &attr);
     378        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     379
     380        attr.name = "b";
     381        attr.size = 2;
     382        rc = ui_file_list_entry_append(flist, &attr);
     383        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     384
     385        PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
     386
     387        entry = ui_file_list_first(flist);
     388        ui_file_list_entry_delete(entry);
     389
     390        PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(flist->list));
     391
     392        entry = ui_file_list_first(flist);
     393        ui_file_list_entry_delete(entry);
     394
     395        PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(flist->list));
     396
     397        ui_file_list_destroy(flist);
     398        ui_window_destroy(window);
     399        ui_destroy(ui);
     400}
     401
     402/** ui_file_list_clear_entries() removes all entries from file list */
     403PCUT_TEST(clear_entries)
     404{
     405        ui_t *ui;
     406        ui_window_t *window;
     407        ui_wnd_params_t params;
     408        ui_file_list_t *flist;
     409        ui_file_list_entry_attr_t attr;
     410        errno_t rc;
     411
     412        rc = ui_create_disp(NULL, &ui);
     413        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     414
     415        ui_wnd_params_init(&params);
     416        params.caption = "Test";
     417
     418        rc = ui_window_create(ui, &params, &window);
     419        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     420
     421        rc = ui_file_list_create(window, true, &flist);
     422        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    580423
    581424        ui_file_list_entry_attr_init(&attr);
    … …  
    585428        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    586429
    587         attr.name = "b";
    588         attr.size = 2;
    589         rc = ui_file_list_entry_append(flist, &attr);
    590         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    591 
    592         attr.name = "c";
    593         attr.size = 3;
    594         rc = ui_file_list_entry_append(flist, &attr);
    595         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    596 
    597         entry = ui_file_list_next(ui_file_list_first(flist));
    598 
    599         flist->cursor = entry;
    600         flist->cursor_idx = 1;
    601         flist->page = entry;
    602         flist->page_idx = 1;
    603 
    604         ui_file_list_scrollbar_update(flist);
    605 
    606         /* Now scrollbar thumb should be all the way down */
    607         move_len = ui_scrollbar_move_length(flist->scrollbar);
    608         pos = ui_scrollbar_get_pos(flist->scrollbar);
    609         PCUT_ASSERT_INT_EQUALS(move_len, pos);
    610 
    611         ui_file_list_destroy(flist);
    612         ui_window_destroy(window);
    613         ui_destroy(ui);
    614 }
    615 
    616 /** ui_file_list_is_active() returns file list activity state */
    617 PCUT_TEST(is_active)
    618 {
    619         ui_t *ui;
    620         ui_window_t *window;
    621         ui_wnd_params_t params;
    622         ui_file_list_t *flist;
    623         errno_t rc;
    624 
    625         rc = ui_create_disp(NULL, &ui);
    626         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    627 
    628         ui_wnd_params_init(&params);
    629         params.caption = "Test";
    630 
    631         rc = ui_window_create(ui, &params, &window);
    632         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    633 
    634         rc = ui_file_list_create(window, true, &flist);
    635         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    636         PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
    637         ui_file_list_destroy(flist);
    638 
    639         rc = ui_file_list_create(window, false, &flist);
    640         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    641         PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
    642         ui_file_list_destroy(flist);
    643         ui_window_destroy(window);
    644         ui_destroy(ui);
    645 }
    646 
    647 /** ui_file_list_activate() activates file list */
    648 PCUT_TEST(activate)
    649 {
    650         ui_t *ui;
    651         ui_window_t *window;
    652         ui_wnd_params_t params;
    653         ui_file_list_t *flist;
    654         errno_t rc;
    655 
    656         rc = ui_create_disp(NULL, &ui);
    657         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    658 
    659         ui_wnd_params_init(&params);
    660         params.caption = "Test";
    661 
    662         rc = ui_window_create(ui, &params, &window);
    663         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    664 
    665         rc = ui_file_list_create(window, false, &flist);
    666         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    667 
    668         PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
    669         rc = ui_file_list_activate(flist);
    670         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    671         PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
    672 
    673         ui_file_list_destroy(flist);
    674         ui_window_destroy(window);
    675         ui_destroy(ui);
    676 }
    677 
    678 /** ui_file_list_deactivate() deactivates file list */
    679 PCUT_TEST(deactivate)
    680 {
    681         ui_t *ui;
    682         ui_window_t *window;
    683         ui_wnd_params_t params;
    684         ui_file_list_t *flist;
    685         errno_t rc;
    686 
    687         rc = ui_create_disp(NULL, &ui);
    688         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    689 
    690         ui_wnd_params_init(&params);
    691         params.caption = "Test";
    692 
    693         rc = ui_window_create(ui, &params, &window);
    694         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    695 
    696         rc = ui_file_list_create(window, true, &flist);
    697         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    698 
    699         PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
    700         ui_file_list_deactivate(flist);
    701         PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
    702 
    703         ui_file_list_destroy(flist);
    704         ui_window_destroy(window);
    705         ui_destroy(ui);
    706 }
    707 
    708 /** ui_file_list_entry_append() appends new entry */
    709 PCUT_TEST(entry_append)
    710 {
    711         ui_t *ui;
    712         ui_window_t *window;
    713         ui_wnd_params_t params;
    714         ui_file_list_t *flist;
    715         ui_file_list_entry_attr_t attr;
    716         errno_t rc;
    717 
    718         rc = ui_create_disp(NULL, &ui);
    719         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    720 
    721         ui_wnd_params_init(&params);
    722         params.caption = "Test";
    723 
    724         rc = ui_window_create(ui, &params, &window);
    725         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    726 
    727         rc = ui_file_list_create(window, true, &flist);
    728         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    729 
    730         ui_file_list_entry_attr_init(&attr);
    731 
    732         attr.name = "a";
    733         attr.size = 1;
    734         rc = ui_file_list_entry_append(flist, &attr);
    735         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    736 
    737         PCUT_ASSERT_INT_EQUALS(1, list_count(&flist->entries));
    738 
    739         attr.name = "b";
    740         attr.size = 2;
    741         rc = ui_file_list_entry_append(flist, &attr);
    742         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    743 
    744         PCUT_ASSERT_INT_EQUALS(2, list_count(&flist->entries));
    745 
    746         ui_file_list_destroy(flist);
    747         ui_window_destroy(window);
    748         ui_destroy(ui);
    749 }
    750 
    751 /** ui_file_list_entry_delete() deletes entry */
    752 PCUT_TEST(entry_delete)
    753 {
    754         ui_t *ui;
    755         ui_window_t *window;
    756         ui_wnd_params_t params;
    757         ui_file_list_t *flist;
    758         ui_file_list_entry_t *entry;
    759         ui_file_list_entry_attr_t attr;
    760         errno_t rc;
    761 
    762         rc = ui_create_disp(NULL, &ui);
    763         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    764 
    765         ui_wnd_params_init(&params);
    766         params.caption = "Test";
    767 
    768         rc = ui_window_create(ui, &params, &window);
    769         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    770 
    771         rc = ui_file_list_create(window, true, &flist);
    772         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    773 
    774         attr.name = "a";
    775         attr.size = 1;
    776         rc = ui_file_list_entry_append(flist, &attr);
    777         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    778 
    779         attr.name = "b";
    780         attr.size = 2;
    781         rc = ui_file_list_entry_append(flist, &attr);
    782         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    783 
    784         PCUT_ASSERT_INT_EQUALS(2, list_count(&flist->entries));
    785 
    786         entry = ui_file_list_first(flist);
    787         ui_file_list_entry_delete(entry);
    788 
    789         PCUT_ASSERT_INT_EQUALS(1, list_count(&flist->entries));
    790 
    791         entry = ui_file_list_first(flist);
    792         ui_file_list_entry_delete(entry);
    793 
    794         PCUT_ASSERT_INT_EQUALS(0, list_count(&flist->entries));
    795 
    796         ui_file_list_destroy(flist);
    797         ui_window_destroy(window);
    798         ui_destroy(ui);
    799 }
    800 
    801 /** ui_file_list_clear_entries() removes all entries from file list */
    802 PCUT_TEST(clear_entries)
    803 {
    804         ui_t *ui;
    805         ui_window_t *window;
    806         ui_wnd_params_t params;
    807         ui_file_list_t *flist;
    808         ui_file_list_entry_attr_t attr;
    809         errno_t rc;
    810 
    811         rc = ui_create_disp(NULL, &ui);
    812         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    813 
    814         ui_wnd_params_init(&params);
    815         params.caption = "Test";
    816 
    817         rc = ui_window_create(ui, &params, &window);
    818         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    819 
    820         rc = ui_file_list_create(window, true, &flist);
    821         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    822 
    823         ui_file_list_entry_attr_init(&attr);
    824         attr.name = "a";
    825         attr.size = 1;
    826         rc = ui_file_list_entry_append(flist, &attr);
    827         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    828 
    829430        attr.name = "a";
    830431        attr.size = 2;
    … …  
    832433        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    833434
    834         PCUT_ASSERT_INT_EQUALS(2, list_count(&flist->entries));
     435        PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
    835436
    836437        ui_file_list_clear_entries(flist);
    837         PCUT_ASSERT_INT_EQUALS(0, list_count(&flist->entries));
     438        PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(flist->list));
    838439
    839440        ui_file_list_destroy(flist);
    … …  
    892493        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    893494
    894         PCUT_ASSERT_INT_EQUALS(2, list_count(&flist->entries));
     495        PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
    895496
    896497        entry = ui_file_list_first(flist);
    … …  
    979580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    980581
    981         PCUT_ASSERT_NOT_NULL(flist->cursor);
    982         PCUT_ASSERT_STR_EQUALS("b", flist->cursor->name);
     582        PCUT_ASSERT_NOT_NULL(ui_file_list_get_cursor(flist));
     583        PCUT_ASSERT_STR_EQUALS("b", ui_file_list_get_cursor(flist)->name);
    983584
    984585        ui_file_list_destroy(flist);
    … …  
    1064665}
    1065666
    1066 /** ui_file_list_entry_ptr_cmp compares two indirectly referenced entries */
    1067 PCUT_TEST(entry_ptr_cmp)
     667/** ui_file_list_list_compare compares two file list entries */
     668PCUT_TEST(list_compare)
    1068669{
    1069670        ui_t *ui;
    … …  
    1106707
    1107708        /* a < b */
    1108         rel = ui_file_list_entry_ptr_cmp(&a, &b);
     709        rel = ui_file_list_list_compare(a->entry, b->entry);
    1109710        PCUT_ASSERT_TRUE(rel < 0);
    1110711
    1111712        /* b > a */
    1112         rel = ui_file_list_entry_ptr_cmp(&b, &a);
     713        rel = ui_file_list_list_compare(b->entry, a->entry);
    1113714        PCUT_ASSERT_TRUE(rel > 0);
    1114715
    1115716        /* a == a */
    1116         rel = ui_file_list_entry_ptr_cmp(&a, &a);
     717        rel = ui_file_list_list_compare(a->entry, a->entry);
    1117718        PCUT_ASSERT_INT_EQUALS(0, rel);
    1118719
    … …  
    1120721        ui_window_destroy(window);
    1121722        ui_destroy(ui);
     723}
     724
     725/** ui_file_list_entry_attr_init() initializes file list attribute structure */
     726PCUT_TEST(entry_attr_init)
     727{
     728        ui_file_list_entry_attr_t attr;
     729
     730        ui_file_list_entry_attr_init(&attr);
     731        PCUT_ASSERT_NULL(attr.name);
     732        PCUT_ASSERT_INT_EQUALS(0, attr.size);
     733        PCUT_ASSERT_EQUALS(false, attr.isdir);
     734        PCUT_ASSERT_INT_EQUALS(0, attr.svc);
    1122735}
    1123736
    … …  
    1354967}
    1355968
    1356 /** ui_file_list_page_nth_entry() .. */
    1357 PCUT_TEST(page_nth_entry)
    1358 {
    1359         ui_t *ui;
    1360         ui_window_t *window;
    1361         ui_wnd_params_t params;
    1362         ui_file_list_t *flist;
    1363         ui_file_list_entry_t *entry;
    1364         ui_file_list_entry_attr_t attr;
    1365         gfx_rect_t rect;
    1366         size_t idx;
    1367         errno_t rc;
    1368 
    1369         rc = ui_create_disp(NULL, &ui);
    1370         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1371 
    1372         ui_wnd_params_init(&params);
    1373         params.caption = "Test";
    1374 
    1375         rc = ui_window_create(ui, &params, &window);
    1376         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1377 
    1378         rc = ui_file_list_create(window, true, &flist);
    1379         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1380 
    1381         ui_file_list_entry_attr_init(&attr);
    1382 
    1383         /* Add some entries */
    1384         attr.name = "a";
    1385         attr.size = 1;
    1386         rc = ui_file_list_entry_append(flist, &attr);
    1387         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1388 
    1389         attr.name = "b";
    1390         attr.size = 2;
    1391         rc = ui_file_list_entry_append(flist, &attr);
    1392         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1393 
    1394         attr.name = "c";
    1395         attr.size = 3;
    1396         rc = ui_file_list_entry_append(flist, &attr);
    1397         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1398 
    1399         flist->page = ui_file_list_next(ui_file_list_first(flist));
    1400         flist->page_idx = 1;
    1401 
    1402         rect.p0.x = 0;
    1403         rect.p0.y = 0;
    1404         rect.p1.x = 100;
    1405         rect.p1.y = 100;
    1406         ui_file_list_set_rect(flist, &rect);
    1407 
    1408         entry = ui_file_list_page_nth_entry(flist, 0, &idx);
    1409         PCUT_ASSERT_NOT_NULL(entry);
    1410         PCUT_ASSERT_STR_EQUALS("b", entry->name);
    1411         PCUT_ASSERT_INT_EQUALS(1, idx);
    1412 
    1413         entry = ui_file_list_page_nth_entry(flist, 1, &idx);
    1414         PCUT_ASSERT_NOT_NULL(entry);
    1415         PCUT_ASSERT_STR_EQUALS("c", entry->name);
    1416         PCUT_ASSERT_INT_EQUALS(2, idx);
    1417 
    1418         entry = ui_file_list_page_nth_entry(flist, 2, &idx);
    1419         PCUT_ASSERT_NULL(entry);
    1420 
    1421         ui_file_list_destroy(flist);
    1422         ui_window_destroy(window);
    1423         ui_destroy(ui);
    1424 }
    1425 
    1426 /** ui_file_list_cursor_move() moves cursor and scrolls */
    1427 PCUT_TEST(cursor_move)
    1428 {
    1429         ui_t *ui;
    1430         ui_window_t *window;
    1431         ui_wnd_params_t params;
    1432         ui_file_list_t *flist;
    1433         ui_file_list_entry_attr_t attr;
    1434         gfx_rect_t rect;
    1435         errno_t rc;
    1436         rc = ui_create_disp(NULL, &ui);
    1437         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1438 
    1439         ui_wnd_params_init(&params);
    1440         params.caption = "Test";
    1441 
    1442         rc = ui_window_create(ui, &params, &window);
    1443         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1444 
    1445         rc = ui_file_list_create(window, true, &flist);
    1446         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1447 
    1448         rect.p0.x = 0;
    1449         rect.p0.y = 0;
    1450         rect.p1.x = 10;
    1451         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1452         ui_file_list_set_rect(flist, &rect);
    1453 
    1454         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1455 
    1456         /* Add tree entries (more than page size, which is 2) */
    1457 
    1458         ui_file_list_entry_attr_init(&attr);
    1459 
    1460         attr.name = "a";
    1461         attr.size = 1;
    1462         rc = ui_file_list_entry_append(flist, &attr);
    1463         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1464 
    1465         attr.name = "b";
    1466         attr.size = 2;
    1467         rc = ui_file_list_entry_append(flist, &attr);
    1468         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1469 
    1470         attr.name = "c";
    1471         attr.size = 3;
    1472         rc = ui_file_list_entry_append(flist, &attr);
    1473         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1474 
    1475         /* Cursor to the last entry and page start to the next-to-last entry */
    1476         flist->cursor = ui_file_list_last(flist);
    1477         flist->cursor_idx = 2;
    1478         flist->page = ui_file_list_prev(flist->cursor);
    1479         flist->page_idx = 1;
    1480 
    1481         /* Move cursor one entry up */
    1482         ui_file_list_cursor_move(flist, ui_file_list_prev(flist->cursor),
    1483             flist->cursor_idx - 1);
    1484 
    1485         /* Cursor and page start should now both be at the second entry */
    1486         PCUT_ASSERT_STR_EQUALS("b", flist->cursor->name);
    1487         PCUT_ASSERT_INT_EQUALS(2, flist->cursor->size);
    1488         PCUT_ASSERT_INT_EQUALS(1, flist->cursor_idx);
    1489         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1490         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1491 
    1492         /* Move cursor to the first entry. This should scroll up. */
    1493         ui_file_list_cursor_move(flist, ui_file_list_first(flist), 0);
    1494 
    1495         /* Cursor and page start should now both be at the first entry */
    1496         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1497         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1498         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1499         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1500         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1501 
    1502         /* Move cursor to the last entry. */
    1503         ui_file_list_cursor_move(flist, ui_file_list_last(flist), 2);
    1504 
    1505         /* Cursor should be on the last entry and page on the next to last */
    1506         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    1507         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    1508         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    1509         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    1510         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    1511         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1512 
    1513         ui_file_list_destroy(flist);
    1514         ui_window_destroy(window);
    1515         ui_destroy(ui);
    1516 }
    1517 
    1518 /** ui_file_list_cursor_up() moves cursor one entry up */
    1519 PCUT_TEST(cursor_up)
    1520 {
    1521         ui_t *ui;
    1522         ui_window_t *window;
    1523         ui_wnd_params_t params;
    1524         ui_file_list_t *flist;
    1525         ui_file_list_entry_attr_t attr;
    1526         gfx_rect_t rect;
    1527         errno_t rc;
    1528         rc = ui_create_disp(NULL, &ui);
    1529         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1530 
    1531         ui_wnd_params_init(&params);
    1532         params.caption = "Test";
    1533 
    1534         rc = ui_window_create(ui, &params, &window);
    1535         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1536 
    1537         rc = ui_file_list_create(window, true, &flist);
    1538         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1539 
    1540         rect.p0.x = 0;
    1541         rect.p0.y = 0;
    1542         rect.p1.x = 10;
    1543         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1544         ui_file_list_set_rect(flist, &rect);
    1545 
    1546         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1547 
    1548         /* Add tree entries (more than page size, which is 2) */
    1549 
    1550         ui_file_list_entry_attr_init(&attr);
    1551 
    1552         attr.name = "a";
    1553         attr.size = 1;
    1554         rc = ui_file_list_entry_append(flist, &attr);
    1555         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1556 
    1557         attr.name = "b";
    1558         attr.size = 2;
    1559         rc = ui_file_list_entry_append(flist, &attr);
    1560         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1561 
    1562         attr.name = "c";
    1563         attr.size = 3;
    1564         rc = ui_file_list_entry_append(flist, &attr);
    1565         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1566 
    1567         /* Cursor to the last entry and page start to the next-to-last entry */
    1568         flist->cursor = ui_file_list_last(flist);
    1569         flist->cursor_idx = 2;
    1570         flist->page = ui_file_list_prev(flist->cursor);
    1571         flist->page_idx = 1;
    1572 
    1573         /* Move cursor one entry up */
    1574         ui_file_list_cursor_up(flist);
    1575 
    1576         /* Cursor and page start should now both be at the second entry */
    1577         PCUT_ASSERT_STR_EQUALS("b", flist->cursor->name);
    1578         PCUT_ASSERT_INT_EQUALS(2, flist->cursor->size);
    1579         PCUT_ASSERT_INT_EQUALS(1, flist->cursor_idx);
    1580         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1581         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1582 
    1583         /* Move cursor one entry up. This should scroll up. */
    1584         ui_file_list_cursor_up(flist);
    1585 
    1586         /* Cursor and page start should now both be at the first entry */
    1587         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1588         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1589         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1590         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1591         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1592 
    1593         /* Moving further up should do nothing (we are at the top). */
    1594         ui_file_list_cursor_up(flist);
    1595 
    1596         /* Cursor and page start should still be at the first entry */
    1597         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1598         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1599         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1600         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1601         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1602 
    1603         ui_file_list_destroy(flist);
    1604         ui_window_destroy(window);
    1605         ui_destroy(ui);
    1606 }
    1607 
    1608 /** ui_file_list_cursor_down() moves cursor one entry down */
    1609 PCUT_TEST(cursor_down)
    1610 {
    1611         ui_t *ui;
    1612         ui_window_t *window;
    1613         ui_wnd_params_t params;
    1614         ui_file_list_t *flist;
    1615         ui_file_list_entry_attr_t attr;
    1616         gfx_rect_t rect;
    1617         errno_t rc;
    1618 
    1619         rc = ui_create_disp(NULL, &ui);
    1620         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1621 
    1622         ui_wnd_params_init(&params);
    1623         params.caption = "Test";
    1624 
    1625         rc = ui_window_create(ui, &params, &window);
    1626         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1627 
    1628         rc = ui_file_list_create(window, true, &flist);
    1629         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1630 
    1631         rect.p0.x = 0;
    1632         rect.p0.y = 0;
    1633         rect.p1.x = 10;
    1634         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1635         ui_file_list_set_rect(flist, &rect);
    1636 
    1637         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1638 
    1639         /* Add tree entries (more than page size, which is 2) */
    1640 
    1641         ui_file_list_entry_attr_init(&attr);
    1642 
    1643         attr.name = "a";
    1644         attr.size = 1;
    1645         rc = ui_file_list_entry_append(flist, &attr);
    1646         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1647 
    1648         attr.name = "b";
    1649         attr.size = 2;
    1650         rc = ui_file_list_entry_append(flist, &attr);
    1651         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1652 
    1653         attr.name = "c";
    1654         attr.size = 3;
    1655         rc = ui_file_list_entry_append(flist, &attr);
    1656         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1657 
    1658         /* Cursor and page start to the first entry */
    1659         flist->cursor = ui_file_list_first(flist);
    1660         flist->cursor_idx = 0;
    1661         flist->page = flist->cursor;
    1662         flist->page_idx = 0;
    1663 
    1664         /* Move cursor one entry down */
    1665         ui_file_list_cursor_down(flist);
    1666 
    1667         /* Cursor should now be at the second entry, page stays the same */
    1668         PCUT_ASSERT_STR_EQUALS("b", flist->cursor->name);
    1669         PCUT_ASSERT_INT_EQUALS(2, flist->cursor->size);
    1670         PCUT_ASSERT_INT_EQUALS(1, flist->cursor_idx);
    1671         PCUT_ASSERT_EQUALS(ui_file_list_first(flist), flist->page);
    1672         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1673 
    1674         /* Move cursor one entry down. This should scroll down. */
    1675         ui_file_list_cursor_down(flist);
    1676 
    1677         /* Cursor should now be at the third and page at the second entry. */
    1678         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    1679         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    1680         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    1681         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    1682         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    1683         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1684 
    1685         /* Moving further down should do nothing (we are at the bottom). */
    1686         ui_file_list_cursor_down(flist);
    1687 
    1688         /* Cursor should still be at the third and page at the second entry. */
    1689         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    1690         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    1691         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    1692         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    1693         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    1694         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1695 
    1696         ui_file_list_destroy(flist);
    1697         ui_window_destroy(window);
    1698         ui_destroy(ui);
    1699 }
    1700 
    1701 /** ui_file_list_cursor_top() moves cursor to the first entry */
    1702 PCUT_TEST(cursor_top)
    1703 {
    1704         ui_t *ui;
    1705         ui_window_t *window;
    1706         ui_wnd_params_t params;
    1707         ui_file_list_t *flist;
    1708         ui_file_list_entry_attr_t attr;
    1709         gfx_rect_t rect;
    1710         errno_t rc;
    1711 
    1712         rc = ui_create_disp(NULL, &ui);
    1713         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1714 
    1715         ui_wnd_params_init(&params);
    1716         params.caption = "Test";
    1717 
    1718         rc = ui_window_create(ui, &params, &window);
    1719         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1720 
    1721         rc = ui_file_list_create(window, true, &flist);
    1722         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1723 
    1724         rect.p0.x = 0;
    1725         rect.p0.y = 0;
    1726         rect.p1.x = 10;
    1727         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1728         ui_file_list_set_rect(flist, &rect);
    1729 
    1730         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1731 
    1732         /* Add tree entries (more than page size, which is 2) */
    1733 
    1734         ui_file_list_entry_attr_init(&attr);
    1735 
    1736         attr.name = "a";
    1737         attr.size = 1;
    1738         rc = ui_file_list_entry_append(flist, &attr);
    1739         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1740 
    1741         attr.name = "b";
    1742         attr.size = 2;
    1743         rc = ui_file_list_entry_append(flist, &attr);
    1744         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1745 
    1746         attr.name = "c";
    1747         attr.size = 3;
    1748         rc = ui_file_list_entry_append(flist, &attr);
    1749         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1750 
    1751         /* Cursor to the last entry and page start to the next-to-last entry */
    1752         flist->cursor = ui_file_list_last(flist);
    1753         flist->cursor_idx = 2;
    1754         flist->page = ui_file_list_prev(flist->cursor);
    1755         flist->page_idx = 1;
    1756 
    1757         /* Move cursor to the top. This should scroll up. */
    1758         ui_file_list_cursor_top(flist);
    1759 
    1760         /* Cursor and page start should now both be at the first entry */
    1761         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1762         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1763         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1764         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1765         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1766 
    1767         ui_file_list_destroy(flist);
    1768         ui_window_destroy(window);
    1769         ui_destroy(ui);
    1770 }
    1771 
    1772 /** ui_file_list_cursor_bottom() moves cursor to the last entry */
    1773 PCUT_TEST(cursor_bottom)
    1774 {
    1775         ui_t *ui;
    1776         ui_window_t *window;
    1777         ui_wnd_params_t params;
    1778         ui_file_list_t *flist;
    1779         ui_file_list_entry_attr_t attr;
    1780         gfx_rect_t rect;
    1781         errno_t rc;
    1782 
    1783         rc = ui_create_disp(NULL, &ui);
    1784         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1785 
    1786         ui_wnd_params_init(&params);
    1787         params.caption = "Test";
    1788 
    1789         rc = ui_window_create(ui, &params, &window);
    1790         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1791 
    1792         rc = ui_file_list_create(window, true, &flist);
    1793         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1794 
    1795         rect.p0.x = 0;
    1796         rect.p0.y = 0;
    1797         rect.p1.x = 10;
    1798         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1799         ui_file_list_set_rect(flist, &rect);
    1800 
    1801         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1802 
    1803         /* Add tree entries (more than page size, which is 2) */
    1804 
    1805         ui_file_list_entry_attr_init(&attr);
    1806 
    1807         attr.name = "a";
    1808         attr.size = 1;
    1809         rc = ui_file_list_entry_append(flist, &attr);
    1810         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1811 
    1812         attr.name = "b";
    1813         attr.size = 2;
    1814         rc = ui_file_list_entry_append(flist, &attr);
    1815         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1816 
    1817         attr.name = "c";
    1818         attr.size = 3;
    1819         rc = ui_file_list_entry_append(flist, &attr);
    1820         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1821 
    1822         /* Cursor and page start to the first entry */
    1823         flist->cursor = ui_file_list_first(flist);
    1824         flist->cursor_idx = 0;
    1825         flist->page = flist->cursor;
    1826         flist->page_idx = 0;
    1827 
    1828         /* Move cursor to the bottom. This should scroll down. */
    1829         ui_file_list_cursor_bottom(flist);
    1830 
    1831         /* Cursor should now be at the third and page at the second entry. */
    1832         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    1833         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    1834         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    1835         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    1836         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    1837         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1838 
    1839         ui_file_list_destroy(flist);
    1840         ui_window_destroy(window);
    1841         ui_destroy(ui);
    1842 }
    1843 
    1844 /** ui_file_list_page_up() moves one page up */
    1845 PCUT_TEST(page_up)
    1846 {
    1847         ui_t *ui;
    1848         ui_window_t *window;
    1849         ui_wnd_params_t params;
    1850         ui_file_list_t *flist;
    1851         ui_file_list_entry_attr_t attr;
    1852         gfx_rect_t rect;
    1853         errno_t rc;
    1854 
    1855         rc = ui_create_disp(NULL, &ui);
    1856         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1857 
    1858         ui_wnd_params_init(&params);
    1859         params.caption = "Test";
    1860 
    1861         rc = ui_window_create(ui, &params, &window);
    1862         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1863 
    1864         rc = ui_file_list_create(window, true, &flist);
    1865         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1866 
    1867         rect.p0.x = 0;
    1868         rect.p0.y = 0;
    1869         rect.p1.x = 10;
    1870         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1871         ui_file_list_set_rect(flist, &rect);
    1872 
    1873         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1874 
    1875         /* Add five entries (2 full pages, one partial) */
    1876 
    1877         ui_file_list_entry_attr_init(&attr);
    1878 
    1879         attr.name = "a";
    1880         attr.size = 1;
    1881         rc = ui_file_list_entry_append(flist, &attr);
    1882         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1883 
    1884         attr.name = "b";
    1885         attr.size = 2;
    1886         rc = ui_file_list_entry_append(flist, &attr);
    1887         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1888 
    1889         attr.name = "c";
    1890         attr.size = 3;
    1891         rc = ui_file_list_entry_append(flist, &attr);
    1892         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1893 
    1894         attr.name = "d";
    1895         attr.size = 4;
    1896         rc = ui_file_list_entry_append(flist, &attr);
    1897         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1898 
    1899         attr.name = "e";
    1900         attr.size = 5;
    1901         rc = ui_file_list_entry_append(flist, &attr);
    1902         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1903 
    1904         /* Cursor to the last entry and page start to the next-to-last entry */
    1905         flist->cursor = ui_file_list_last(flist);
    1906         flist->cursor_idx = 4;
    1907         flist->page = ui_file_list_prev(flist->cursor);
    1908         flist->page_idx = 3;
    1909 
    1910         /* Move one page up */
    1911         ui_file_list_page_up(flist);
    1912 
    1913         /* Page should now start at second entry and cursor at third */
    1914         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    1915         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    1916         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    1917         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    1918         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    1919         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    1920 
    1921         /* Move one page up again. */
    1922         ui_file_list_page_up(flist);
    1923 
    1924         /* Cursor and page start should now both be at the first entry */
    1925         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1926         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1927         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1928         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1929         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1930 
    1931         /* Moving further up should do nothing (we are at the top). */
    1932         ui_file_list_page_up(flist);
    1933 
    1934         /* Cursor and page start should still be at the first entry */
    1935         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    1936         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    1937         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    1938         PCUT_ASSERT_EQUALS(flist->cursor, flist->page);
    1939         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    1940 
    1941         ui_file_list_destroy(flist);
    1942         ui_window_destroy(window);
    1943         ui_destroy(ui);
    1944 }
    1945 
    1946 /** ui_file_list_page_up() moves one page down */
    1947 PCUT_TEST(page_down)
    1948 {
    1949         ui_t *ui;
    1950         ui_window_t *window;
    1951         ui_wnd_params_t params;
    1952         ui_file_list_t *flist;
    1953         ui_file_list_entry_attr_t attr;
    1954         gfx_rect_t rect;
    1955         errno_t rc;
    1956 
    1957         rc = ui_create_disp(NULL, &ui);
    1958         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1959 
    1960         ui_wnd_params_init(&params);
    1961         params.caption = "Test";
    1962 
    1963         rc = ui_window_create(ui, &params, &window);
    1964         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1965 
    1966         rc = ui_file_list_create(window, true, &flist);
    1967         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1968 
    1969         rect.p0.x = 0;
    1970         rect.p0.y = 0;
    1971         rect.p1.x = 10;
    1972         rect.p1.y = 38; /* Assuming this makes page size 2 */
    1973         ui_file_list_set_rect(flist, &rect);
    1974 
    1975         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    1976 
    1977         /* Add five entries (2 full pages, one partial) */
    1978 
    1979         ui_file_list_entry_attr_init(&attr);
    1980 
    1981         attr.name = "a";
    1982         attr.size = 1;
    1983         rc = ui_file_list_entry_append(flist, &attr);
    1984         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1985 
    1986         attr.name = "b";
    1987         attr.size = 2;
    1988         rc = ui_file_list_entry_append(flist, &attr);
    1989         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1990 
    1991         attr.name = "c";
    1992         attr.size = 3;
    1993         rc = ui_file_list_entry_append(flist, &attr);
    1994         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1995 
    1996         attr.name = "d";
    1997         attr.size = 4;
    1998         rc = ui_file_list_entry_append(flist, &attr);
    1999         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2000 
    2001         attr.name = "e";
    2002         attr.size = 5;
    2003         rc = ui_file_list_entry_append(flist, &attr);
    2004         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2005 
    2006         /* Cursor and page to the first entry */
    2007         flist->cursor = ui_file_list_first(flist);
    2008         flist->cursor_idx = 0;
    2009         flist->page = flist->cursor;
    2010         flist->page_idx = 0;
    2011 
    2012         /* Move one page down */
    2013         ui_file_list_page_down(flist);
    2014 
    2015         /* Page and cursor should point to the third entry */
    2016         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    2017         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    2018         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    2019         PCUT_ASSERT_STR_EQUALS("c", flist->page->name);
    2020         PCUT_ASSERT_INT_EQUALS(3, flist->page->size);
    2021         PCUT_ASSERT_INT_EQUALS(2, flist->page_idx);
    2022 
    2023         /* Move one page down again. */
    2024         ui_file_list_page_down(flist);
    2025 
    2026         /* Cursor should point to last and page to next-to-last entry */
    2027         PCUT_ASSERT_STR_EQUALS("e", flist->cursor->name);
    2028         PCUT_ASSERT_INT_EQUALS(5, flist->cursor->size);
    2029         PCUT_ASSERT_INT_EQUALS(4, flist->cursor_idx);
    2030         PCUT_ASSERT_STR_EQUALS("d", flist->page->name);
    2031         PCUT_ASSERT_INT_EQUALS(4, flist->page->size);
    2032         PCUT_ASSERT_INT_EQUALS(3, flist->page_idx);
    2033 
    2034         /* Moving further down should do nothing (we are at the bottom). */
    2035         ui_file_list_page_down(flist);
    2036 
    2037         /* Cursor should still point to last and page to next-to-last entry */
    2038         PCUT_ASSERT_STR_EQUALS("e", flist->cursor->name);
    2039         PCUT_ASSERT_INT_EQUALS(5, flist->cursor->size);
    2040         PCUT_ASSERT_INT_EQUALS(4, flist->cursor_idx);
    2041         PCUT_ASSERT_STR_EQUALS("d", flist->page->name);
    2042         PCUT_ASSERT_INT_EQUALS(4, flist->page->size);
    2043         PCUT_ASSERT_INT_EQUALS(3, flist->page_idx);
    2044 
    2045         ui_file_list_destroy(flist);
    2046         ui_window_destroy(window);
    2047         ui_destroy(ui);
    2048 }
    2049 
    2050 /** ui_file_list_scroll_up() scrolls up by one row */
    2051 PCUT_TEST(scroll_up)
    2052 {
    2053         ui_t *ui;
    2054         ui_window_t *window;
    2055         ui_wnd_params_t params;
    2056         ui_file_list_t *flist;
    2057         ui_file_list_entry_attr_t attr;
    2058         gfx_rect_t rect;
    2059         errno_t rc;
    2060 
    2061         rc = ui_create_disp(NULL, &ui);
    2062         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2063 
    2064         ui_wnd_params_init(&params);
    2065         params.caption = "Test";
    2066 
    2067         rc = ui_window_create(ui, &params, &window);
    2068         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2069 
    2070         rc = ui_file_list_create(window, true, &flist);
    2071         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2072 
    2073         rect.p0.x = 0;
    2074         rect.p0.y = 0;
    2075         rect.p1.x = 10;
    2076         rect.p1.y = 38; /* Assuming this makes page size 2 */
    2077         ui_file_list_set_rect(flist, &rect);
    2078 
    2079         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    2080 
    2081         /* Add tree entries (more than page size, which is 2) */
    2082 
    2083         ui_file_list_entry_attr_init(&attr);
    2084 
    2085         attr.name = "a";
    2086         attr.size = 1;
    2087         rc = ui_file_list_entry_append(flist, &attr);
    2088         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2089 
    2090         attr.name = "b";
    2091         attr.size = 2;
    2092         rc = ui_file_list_entry_append(flist, &attr);
    2093         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2094 
    2095         attr.name = "c";
    2096         attr.size = 3;
    2097         rc = ui_file_list_entry_append(flist, &attr);
    2098         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2099 
    2100         /* Cursor to the last entry, page to the second */
    2101         flist->cursor = ui_file_list_last(flist);
    2102         flist->cursor_idx = 2;
    2103         flist->page = ui_file_list_prev(flist->cursor);
    2104         flist->page_idx = 1;
    2105 
    2106         /* Scroll one entry up */
    2107         ui_file_list_scroll_up(flist);
    2108 
    2109         /* Page should start on the first entry, cursor unchanged */
    2110         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    2111         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    2112         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    2113         PCUT_ASSERT_STR_EQUALS("a", flist->page->name);
    2114         PCUT_ASSERT_INT_EQUALS(1, flist->page->size);
    2115         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    2116 
    2117         /* Try scrolling one more entry up */
    2118         ui_file_list_scroll_up(flist);
    2119 
    2120         /* We were at the beginning, so nothing should have changed  */
    2121         PCUT_ASSERT_STR_EQUALS("c", flist->cursor->name);
    2122         PCUT_ASSERT_INT_EQUALS(3, flist->cursor->size);
    2123         PCUT_ASSERT_INT_EQUALS(2, flist->cursor_idx);
    2124         PCUT_ASSERT_STR_EQUALS("a", flist->page->name);
    2125         PCUT_ASSERT_INT_EQUALS(1, flist->page->size);
    2126         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    2127 
    2128         ui_file_list_destroy(flist);
    2129         ui_window_destroy(window);
    2130         ui_destroy(ui);
    2131 }
    2132 
    2133 /** ui_file_list_scroll_down() scrolls down by one row */
    2134 PCUT_TEST(scroll_down)
    2135 {
    2136         ui_t *ui;
    2137         ui_window_t *window;
    2138         ui_wnd_params_t params;
    2139         ui_file_list_t *flist;
    2140         ui_file_list_entry_attr_t attr;
    2141         gfx_rect_t rect;
    2142         errno_t rc;
    2143 
    2144         rc = ui_create_disp(NULL, &ui);
    2145         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2146 
    2147         ui_wnd_params_init(&params);
    2148         params.caption = "Test";
    2149 
    2150         rc = ui_window_create(ui, &params, &window);
    2151         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2152 
    2153         rc = ui_file_list_create(window, true, &flist);
    2154         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2155 
    2156         rect.p0.x = 0;
    2157         rect.p0.y = 0;
    2158         rect.p1.x = 10;
    2159         rect.p1.y = 38; /* Assuming this makes page size 2 */
    2160         ui_file_list_set_rect(flist, &rect);
    2161 
    2162         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    2163 
    2164         /* Add tree entries (more than page size, which is 2) */
    2165 
    2166         ui_file_list_entry_attr_init(&attr);
    2167 
    2168         attr.name = "a";
    2169         attr.size = 1;
    2170         rc = ui_file_list_entry_append(flist, &attr);
    2171         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2172 
    2173         attr.name = "b";
    2174         attr.size = 2;
    2175         rc = ui_file_list_entry_append(flist, &attr);
    2176         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2177 
    2178         attr.name = "c";
    2179         attr.size = 3;
    2180         rc = ui_file_list_entry_append(flist, &attr);
    2181         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2182 
    2183         /* Cursor and page start to the first entry */
    2184         flist->cursor = ui_file_list_first(flist);
    2185         flist->cursor_idx = 0;
    2186         flist->page = flist->cursor;
    2187         flist->page_idx = 0;
    2188 
    2189         /* Scroll one entry down */
    2190         ui_file_list_scroll_down(flist);
    2191 
    2192         /* Page should start on the second entry, cursor unchanged */
    2193         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2194         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2195         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2196         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    2197         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    2198         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    2199 
    2200         /* Try scrolling one more entry down */
    2201         ui_file_list_scroll_down(flist);
    2202 
    2203         /* We were at the end, so nothing should have changed  */
    2204         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2205         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2206         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2207         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    2208         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    2209         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    2210 
    2211         ui_file_list_destroy(flist);
    2212         ui_window_destroy(window);
    2213         ui_destroy(ui);
    2214 }
    2215 
    2216 /** ui_file_list_scroll_page_up() scrolls up by one page */
    2217 PCUT_TEST(scroll_page_up)
    2218 {
    2219         ui_t *ui;
    2220         ui_window_t *window;
    2221         ui_wnd_params_t params;
    2222         ui_file_list_t *flist;
    2223         ui_file_list_entry_attr_t attr;
    2224         gfx_rect_t rect;
    2225         errno_t rc;
    2226 
    2227         rc = ui_create_disp(NULL, &ui);
    2228         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2229 
    2230         ui_wnd_params_init(&params);
    2231         params.caption = "Test";
    2232 
    2233         rc = ui_window_create(ui, &params, &window);
    2234         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2235 
    2236         rc = ui_file_list_create(window, true, &flist);
    2237         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2238 
    2239         rect.p0.x = 0;
    2240         rect.p0.y = 0;
    2241         rect.p1.x = 10;
    2242         rect.p1.y = 38; /* Assuming this makes page size 2 */
    2243         ui_file_list_set_rect(flist, &rect);
    2244 
    2245         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    2246 
    2247         /* Add five entries (more than twice the page size, which is 2) */
    2248 
    2249         ui_file_list_entry_attr_init(&attr);
    2250 
    2251         attr.name = "a";
    2252         attr.size = 1;
    2253         rc = ui_file_list_entry_append(flist, &attr);
    2254         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2255 
    2256         attr.name = "b";
    2257         attr.size = 2;
    2258         rc = ui_file_list_entry_append(flist, &attr);
    2259         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2260 
    2261         attr.name = "c";
    2262         attr.size = 3;
    2263         rc = ui_file_list_entry_append(flist, &attr);
    2264         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2265 
    2266         attr.name = "d";
    2267         attr.size = 4;
    2268         rc = ui_file_list_entry_append(flist, &attr);
    2269         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2270 
    2271         attr.name = "e";
    2272         attr.size = 5;
    2273         rc = ui_file_list_entry_append(flist, &attr);
    2274         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2275 
    2276         /* Cursor to the last entry, page to the second last */
    2277         flist->cursor = ui_file_list_last(flist);
    2278         flist->cursor_idx = 4;
    2279         flist->page = ui_file_list_prev(flist->cursor);
    2280         flist->page_idx = 3;
    2281 
    2282         /* Scroll one page up */
    2283         ui_file_list_scroll_page_up(flist);
    2284 
    2285         /* Page should start on 'b', cursor unchanged */
    2286         PCUT_ASSERT_STR_EQUALS("e", flist->cursor->name);
    2287         PCUT_ASSERT_INT_EQUALS(5, flist->cursor->size);
    2288         PCUT_ASSERT_INT_EQUALS(4, flist->cursor_idx);
    2289         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    2290         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    2291         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    2292 
    2293         /* Page up again */
    2294         ui_file_list_scroll_page_up(flist);
    2295 
    2296         /* Page should now be at the beginning, cursor unchanged */
    2297         PCUT_ASSERT_STR_EQUALS("e", flist->cursor->name);
    2298         PCUT_ASSERT_INT_EQUALS(5, flist->cursor->size);
    2299         PCUT_ASSERT_INT_EQUALS(4, flist->cursor_idx);
    2300         PCUT_ASSERT_STR_EQUALS("a", flist->page->name);
    2301         PCUT_ASSERT_INT_EQUALS(1, flist->page->size);
    2302         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    2303 
    2304         /* Page up again */
    2305         ui_file_list_scroll_page_up(flist);
    2306 
    2307         /* We were at the beginning, nothing should have changed */
    2308         PCUT_ASSERT_STR_EQUALS("e", flist->cursor->name);
    2309         PCUT_ASSERT_INT_EQUALS(5, flist->cursor->size);
    2310         PCUT_ASSERT_INT_EQUALS(4, flist->cursor_idx);
    2311         PCUT_ASSERT_STR_EQUALS("a", flist->page->name);
    2312         PCUT_ASSERT_INT_EQUALS(1, flist->page->size);
    2313         PCUT_ASSERT_INT_EQUALS(0, flist->page_idx);
    2314 
    2315         ui_file_list_destroy(flist);
    2316         ui_window_destroy(window);
    2317         ui_destroy(ui);
    2318 }
    2319 
    2320 /** ui_file_list_scroll_page_up() scrolls down by one page */
    2321 PCUT_TEST(scroll_page_down)
    2322 {
    2323         ui_t *ui;
    2324         ui_window_t *window;
    2325         ui_wnd_params_t params;
    2326         ui_file_list_t *flist;
    2327         ui_file_list_entry_attr_t attr;
    2328         gfx_rect_t rect;
    2329         errno_t rc;
    2330 
    2331         rc = ui_create_disp(NULL, &ui);
    2332         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2333 
    2334         ui_wnd_params_init(&params);
    2335         params.caption = "Test";
    2336 
    2337         rc = ui_window_create(ui, &params, &window);
    2338         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2339 
    2340         rc = ui_file_list_create(window, true, &flist);
    2341         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2342 
    2343         rect.p0.x = 0;
    2344         rect.p0.y = 0;
    2345         rect.p1.x = 10;
    2346         rect.p1.y = 38; /* Assuming this makes page size 2 */
    2347         ui_file_list_set_rect(flist, &rect);
    2348 
    2349         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    2350 
    2351         /* Add five entries (more than twice the page size, which is 2) */
    2352 
    2353         ui_file_list_entry_attr_init(&attr);
    2354 
    2355         attr.name = "a";
    2356         attr.size = 1;
    2357         rc = ui_file_list_entry_append(flist, &attr);
    2358         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2359 
    2360         attr.name = "b";
    2361         attr.size = 2;
    2362         rc = ui_file_list_entry_append(flist, &attr);
    2363         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2364 
    2365         attr.name = "c";
    2366         attr.size = 3;
    2367         rc = ui_file_list_entry_append(flist, &attr);
    2368         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2369 
    2370         attr.name = "d";
    2371         attr.size = 4;
    2372         rc = ui_file_list_entry_append(flist, &attr);
    2373         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2374 
    2375         attr.name = "e";
    2376         attr.size = 5;
    2377         rc = ui_file_list_entry_append(flist, &attr);
    2378         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2379 
    2380         /* Cursor and page to the first entry */
    2381         flist->cursor = ui_file_list_first(flist);
    2382         flist->cursor_idx = 0;
    2383         flist->page = ui_file_list_first(flist);
    2384         flist->page_idx = 0;
    2385 
    2386         /* Scroll one page down */
    2387         ui_file_list_scroll_page_down(flist);
    2388 
    2389         /* Page should start on 'c', cursor unchanged */
    2390         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2391         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2392         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2393         PCUT_ASSERT_STR_EQUALS("c", flist->page->name);
    2394         PCUT_ASSERT_INT_EQUALS(3, flist->page->size);
    2395         PCUT_ASSERT_INT_EQUALS(2, flist->page_idx);
    2396 
    2397         /* Page down again */
    2398         ui_file_list_scroll_page_down(flist);
    2399 
    2400         /* Page should now start at 'd', cursor unchanged */
    2401         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2402         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2403         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2404         PCUT_ASSERT_STR_EQUALS("d", flist->page->name);
    2405         PCUT_ASSERT_INT_EQUALS(4, flist->page->size);
    2406         PCUT_ASSERT_INT_EQUALS(3, flist->page_idx);
    2407 
    2408         /* Page down again */
    2409         ui_file_list_scroll_page_down(flist);
    2410 
    2411         /* We were at the end, nothing should have changed */
    2412         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2413         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2414         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2415         PCUT_ASSERT_STR_EQUALS("d", flist->page->name);
    2416         PCUT_ASSERT_INT_EQUALS(4, flist->page->size);
    2417         PCUT_ASSERT_INT_EQUALS(3, flist->page_idx);
    2418 
    2419         ui_file_list_destroy(flist);
    2420         ui_window_destroy(window);
    2421         ui_destroy(ui);
    2422 }
    2423 
    2424 PCUT_TEST(scroll_pos)
    2425 {
    2426         ui_t *ui;
    2427         ui_window_t *window;
    2428         ui_wnd_params_t params;
    2429         ui_file_list_t *flist;
    2430         ui_file_list_entry_attr_t attr;
    2431         gfx_rect_t rect;
    2432         errno_t rc;
    2433 
    2434         rc = ui_create_disp(NULL, &ui);
    2435         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2436 
    2437         ui_wnd_params_init(&params);
    2438         params.caption = "Test";
    2439 
    2440         rc = ui_window_create(ui, &params, &window);
    2441         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2442 
    2443         rc = ui_file_list_create(window, true, &flist);
    2444         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2445 
    2446         rect.p0.x = 0;
    2447         rect.p0.y = 0;
    2448         rect.p1.x = 10;
    2449         rect.p1.y = 38; /* Assuming this makes page size 2 */
    2450         ui_file_list_set_rect(flist, &rect);
    2451 
    2452         PCUT_ASSERT_INT_EQUALS(2, ui_file_list_page_size(flist));
    2453 
    2454         /* Add five entries (more than twice the page size, which is 2) */
    2455 
    2456         ui_file_list_entry_attr_init(&attr);
    2457 
    2458         attr.name = "a";
    2459         attr.size = 1;
    2460         rc = ui_file_list_entry_append(flist, &attr);
    2461         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2462 
    2463         attr.name = "b";
    2464         attr.size = 2;
    2465         rc = ui_file_list_entry_append(flist, &attr);
    2466         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2467 
    2468         attr.name = "c";
    2469         attr.size = 3;
    2470         rc = ui_file_list_entry_append(flist, &attr);
    2471         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2472 
    2473         attr.name = "d";
    2474         attr.size = 4;
    2475         rc = ui_file_list_entry_append(flist, &attr);
    2476         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2477 
    2478         attr.name = "e";
    2479         attr.size = 5;
    2480         rc = ui_file_list_entry_append(flist, &attr);
    2481         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2482 
    2483         /* Cursor and page to the first entry */
    2484         flist->cursor = ui_file_list_first(flist);
    2485         flist->cursor_idx = 0;
    2486         flist->page = ui_file_list_first(flist);
    2487         flist->page_idx = 0;
    2488 
    2489         /* Scroll to entry 1 (one down) */
    2490         ui_file_list_scroll_pos(flist, 1);
    2491 
    2492         /* Page should start on 'b', cursor unchanged */
    2493         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2494         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2495         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2496         PCUT_ASSERT_STR_EQUALS("b", flist->page->name);
    2497         PCUT_ASSERT_INT_EQUALS(2, flist->page->size);
    2498         PCUT_ASSERT_INT_EQUALS(1, flist->page_idx);
    2499 
    2500         /* Scroll to entry 3 (i.e. the end) */
    2501         ui_file_list_scroll_pos(flist, 3);
    2502 
    2503         /* Page should now start at 'd', cursor unchanged */
    2504         PCUT_ASSERT_STR_EQUALS("a", flist->cursor->name);
    2505         PCUT_ASSERT_INT_EQUALS(1, flist->cursor->size);
    2506         PCUT_ASSERT_INT_EQUALS(0, flist->cursor_idx);
    2507         PCUT_ASSERT_STR_EQUALS("d", flist->page->name);
    2508         PCUT_ASSERT_INT_EQUALS(4, flist->page->size);
    2509         PCUT_ASSERT_INT_EQUALS(3, flist->page_idx);
    2510 
    2511         ui_file_list_destroy(flist);
    2512         ui_window_destroy(window);
    2513         ui_destroy(ui);
    2514 }
    2515 
    2516969/** ui_file_list_open_dir() opens a directory entry */
    2517970PCUT_TEST(open_dir)
    … …  
    25591012        PCUT_ASSERT_STR_EQUALS(p, flist->dir);
    25601013
    2561         PCUT_ASSERT_INT_EQUALS(2, list_count(&flist->entries));
     1014        PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
    25621015
    25631016        entry = ui_file_list_first(flist);
    … …  
    27061159}
    27071160
     1161/** ui_file_list_get_cursor() returns the current cursor position */
     1162PCUT_TEST(get_cursor)
     1163{
     1164        ui_t *ui;
     1165        ui_window_t *window;
     1166        ui_wnd_params_t params;
     1167        ui_file_list_t *flist;
     1168        ui_file_list_entry_attr_t attr;
     1169        ui_file_list_entry_t *entry;
     1170        ui_file_list_entry_t *cursor;
     1171        errno_t rc;
     1172
     1173        rc = ui_create_disp(NULL, &ui);
     1174        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1175
     1176        ui_wnd_params_init(&params);
     1177        params.caption = "Test";
     1178
     1179        rc = ui_window_create(ui, &params, &window);
     1180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1181
     1182        rc = ui_file_list_create(window, true, &flist);
     1183        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1184
     1185        ui_file_list_entry_attr_init(&attr);
     1186
     1187        /* Append entry */
     1188        attr.name = "a";
     1189        attr.size = 1;
     1190        rc = ui_file_list_entry_append(flist, &attr);
     1191        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1192
     1193        entry = ui_file_list_first(flist);
     1194        PCUT_ASSERT_NOT_NULL(entry);
     1195
     1196        /* Cursor should be at the only entry */
     1197        cursor = ui_file_list_get_cursor(flist);
     1198        PCUT_ASSERT_EQUALS(entry, cursor);
     1199
     1200        ui_file_list_destroy(flist);
     1201        ui_window_destroy(window);
     1202        ui_destroy(ui);
     1203}
     1204
    27081205static void test_file_list_activate_req(ui_file_list_t *flist, void *arg)
    27091206{
Note: See TracChangeset for help on using the changeset viewer.