Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ui/test/menu.c

    rff6e91b r46bd63c9  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
     
    3636#include <ui/menu.h>
    3737#include <ui/menubar.h>
     38#include <ui/menuentry.h>
    3839#include <ui/ui.h>
    3940#include <ui/window.h>
     
    4546PCUT_TEST_SUITE(menu);
    4647
     48typedef struct {
     49        bool left_called;
     50        bool right_called;
     51        bool close_req_called;
     52        bool press_accel_called;
     53        ui_menu_t *menu;
     54        sysarg_t idev_id;
     55        char32_t c;
     56} test_resp_t;
     57
     58static void testmenu_left(ui_menu_t *, void *, sysarg_t);
     59static void testmenu_right(ui_menu_t *, void *, sysarg_t);
     60static void testmenu_close_req(ui_menu_t *, void *);
     61static void testmenu_press_accel(ui_menu_t *, void *, char32_t, sysarg_t);
     62
     63ui_menu_cb_t testmenu_cb = {
     64        .left = testmenu_left,
     65        .right = testmenu_right,
     66        .close_req = testmenu_close_req,
     67        .press_accel = testmenu_press_accel
     68};
     69
     70ui_menu_cb_t dummy_cb = {
     71};
     72
    4773/** Create and destroy menu */
    4874PCUT_TEST(create_destroy)
    4975{
    50         ui_menu_bar_t *mbar = NULL;
    51         ui_menu_t *menu = NULL;
    52         errno_t rc;
    53 
    54         rc = ui_menu_bar_create(NULL, NULL, &mbar);
    55         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    56 
    57         rc = ui_menu_create(mbar, "Test", &menu);
    58         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    59         PCUT_ASSERT_NOT_NULL(menu);
    60 
    61         /*
    62          * Normally we don't need to destroy a menu explicitly, it will
    63          * be destroyed along with menu bar, but here we'll test destroying
    64          * it explicitly.
    65          */
    66         ui_menu_destroy(menu);
    67         ui_menu_bar_destroy(mbar);
     76        ui_menu_t *menu = NULL;
     77        errno_t rc;
     78
     79        rc = ui_menu_create(NULL, &menu);
     80        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     81        PCUT_ASSERT_NOT_NULL(menu);
     82
     83        ui_menu_destroy(menu);
    6884}
    6985
     
    7490}
    7591
    76 /** ui_menu_first() / ui_menu_next() iterate over menus */
    77 PCUT_TEST(first_next)
    78 {
    79         ui_t *ui = NULL;
    80         ui_window_t *window = NULL;
    81         ui_wnd_params_t params;
    82         ui_menu_bar_t *mbar = NULL;
    83         ui_menu_t *menu1 = NULL;
    84         ui_menu_t *menu2 = NULL;
    85         ui_menu_t *m;
    86         errno_t rc;
    87 
    88         rc = ui_create_disp(NULL, &ui);
    89         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    90 
    91         ui_wnd_params_init(&params);
    92         params.caption = "Hello";
    93 
    94         rc = ui_window_create(ui, &params, &window);
    95         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    96         PCUT_ASSERT_NOT_NULL(window);
    97 
    98         rc = ui_menu_bar_create(ui, window, &mbar);
    99         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    100         PCUT_ASSERT_NOT_NULL(mbar);
    101 
    102         rc = ui_menu_create(mbar, "Test 1", &menu1);
    103         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    104         PCUT_ASSERT_NOT_NULL(menu1);
    105 
    106         rc = ui_menu_create(mbar, "Test 1", &menu2);
    107         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    108         PCUT_ASSERT_NOT_NULL(menu2);
    109 
    110         m = ui_menu_first(mbar);
    111         PCUT_ASSERT_EQUALS(menu1, m);
    112 
    113         m = ui_menu_next(m);
    114         PCUT_ASSERT_EQUALS(menu2, m);
    115 
    116         m = ui_menu_next(m);
    117         PCUT_ASSERT_NULL(m);
    118 
    119         ui_menu_bar_destroy(mbar);
    120         ui_window_destroy(window);
    121         ui_destroy(ui);
    122 }
    123 
    124 /** ui_menu_caption() returns the menu's caption */
    125 PCUT_TEST(caption)
    126 {
    127         ui_t *ui = NULL;
    128         ui_window_t *window = NULL;
    129         ui_wnd_params_t params;
    130         ui_menu_bar_t *mbar = NULL;
    131         ui_menu_t *menu = NULL;
    132         const char *caption;
    133         errno_t rc;
    134 
    135         rc = ui_create_disp(NULL, &ui);
    136         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    137 
    138         ui_wnd_params_init(&params);
    139         params.caption = "Hello";
    140 
    141         rc = ui_window_create(ui, &params, &window);
    142         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    143         PCUT_ASSERT_NOT_NULL(window);
    144 
    145         rc = ui_menu_bar_create(ui, window, &mbar);
    146         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    147         PCUT_ASSERT_NOT_NULL(mbar);
    148 
    149         rc = ui_menu_create(mbar, "Test", &menu);
    150         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    151         PCUT_ASSERT_NOT_NULL(menu);
    152 
    153         caption = ui_menu_caption(menu);
    154         PCUT_ASSERT_NOT_NULL(caption);
    155 
    156         PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, "Test"));
    157 
    158         ui_menu_bar_destroy(mbar);
    159         ui_window_destroy(window);
    160         ui_destroy(ui);
    161 }
    162 
    163 /** ui_menu_get_rect() returns outer menu rectangle */
    164 PCUT_TEST(get_rect)
    165 {
    166         ui_t *ui = NULL;
    167         ui_window_t *window = NULL;
    168         ui_wnd_params_t params;
    169         ui_menu_bar_t *mbar = NULL;
    170         ui_menu_t *menu = NULL;
    171         gfx_coord2_t pos;
    172         gfx_rect_t rect;
    173         const char *caption;
    174         errno_t rc;
    175 
    176         rc = ui_create_disp(NULL, &ui);
    177         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178 
    179         ui_wnd_params_init(&params);
    180         params.caption = "Hello";
    181 
    182         rc = ui_window_create(ui, &params, &window);
    183         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    184         PCUT_ASSERT_NOT_NULL(window);
    185 
    186         rc = ui_menu_bar_create(ui, window, &mbar);
    187         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    188         PCUT_ASSERT_NOT_NULL(mbar);
    189 
    190         rc = ui_menu_create(mbar, "Test", &menu);
    191         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    192         PCUT_ASSERT_NOT_NULL(menu);
    193 
    194         caption = ui_menu_caption(menu);
    195         PCUT_ASSERT_NOT_NULL(caption);
    196 
    197         pos.x = 0;
    198         pos.y = 0;
    199         ui_menu_get_rect(menu, &pos, &rect);
    200 
    201         PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
    202         PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
    203         PCUT_ASSERT_INT_EQUALS(16, rect.p1.x);
    204         PCUT_ASSERT_INT_EQUALS(8, rect.p1.y);
    205 
    206         ui_menu_bar_destroy(mbar);
    207         ui_window_destroy(window);
    208         ui_destroy(ui);
    209 }
    210 
    211 /** Paint background in graphics mode */
    212 PCUT_TEST(paint_bg_gfx)
    213 {
    214         ui_t *ui = NULL;
    215         ui_window_t *window = NULL;
    216         ui_wnd_params_t params;
    217         ui_menu_bar_t *mbar = NULL;
    218         ui_menu_t *menu = NULL;
    219         gfx_rect_t prect;
    220         gfx_coord2_t pos;
    221         errno_t rc;
    222 
    223         rc = ui_create_disp(NULL, &ui);
    224         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    225 
    226         ui_wnd_params_init(&params);
    227         params.caption = "Hello";
    228 
    229         rc = ui_window_create(ui, &params, &window);
    230         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    231         PCUT_ASSERT_NOT_NULL(window);
    232 
    233         rc = ui_menu_bar_create(ui, window, &mbar);
    234         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    235         PCUT_ASSERT_NOT_NULL(mbar);
    236 
    237         rc = ui_menu_create(mbar, "Test", &menu);
    238         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    239         PCUT_ASSERT_NOT_NULL(menu);
    240 
    241         prect.p0.x = 0;
    242         prect.p0.y = 0;
    243         prect.p1.x = 0;
    244         prect.p1.y = 0;
    245 
    246         /* Menu needs to be open to be able to paint it */
    247         rc = ui_menu_open(menu, &prect);
    248         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    249 
    250         pos.x = 0;
    251         pos.y = 0;
    252         rc = ui_menu_paint_bg_gfx(menu, &pos);
    253         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    254 
    255         ui_menu_bar_destroy(mbar);
    256         ui_window_destroy(window);
    257         ui_destroy(ui);
    258 }
    259 
    260 /** Paint background in text mode */
    261 PCUT_TEST(paint_bg_text)
    262 {
    263         ui_t *ui = NULL;
    264         ui_window_t *window = NULL;
    265         ui_wnd_params_t params;
    266         ui_menu_bar_t *mbar = NULL;
    267         ui_menu_t *menu = NULL;
    268         gfx_rect_t prect;
    269         gfx_coord2_t pos;
    270         errno_t rc;
    271 
    272         rc = ui_create_disp(NULL, &ui);
    273         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    274 
    275         ui_wnd_params_init(&params);
    276         params.caption = "Hello";
    277 
    278         rc = ui_window_create(ui, &params, &window);
    279         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    280         PCUT_ASSERT_NOT_NULL(window);
    281 
    282         rc = ui_menu_bar_create(ui, window, &mbar);
    283         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    284         PCUT_ASSERT_NOT_NULL(mbar);
    285 
    286         rc = ui_menu_create(mbar, "Test", &menu);
    287         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    288         PCUT_ASSERT_NOT_NULL(menu);
    289 
    290         prect.p0.x = 0;
    291         prect.p0.y = 0;
    292         prect.p1.x = 0;
    293         prect.p1.y = 0;
    294 
    295         /* Menu needs to be open to be able to paint it */
    296         rc = ui_menu_open(menu, &prect);
    297         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    298 
    299         pos.x = 0;
    300         pos.y = 0;
    301         rc = ui_menu_paint_bg_text(menu, &pos);
    302         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    303 
    304         ui_menu_bar_destroy(mbar);
    305         ui_window_destroy(window);
    306         ui_destroy(ui);
    307 }
    308 
    309 /** Paint menu */
    310 PCUT_TEST(paint)
    311 {
    312         ui_t *ui = NULL;
    313         ui_window_t *window = NULL;
    314         ui_wnd_params_t params;
    315         ui_menu_bar_t *mbar = NULL;
    316         ui_menu_t *menu = NULL;
    317         gfx_rect_t prect;
    318         gfx_coord2_t pos;
    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 = "Hello";
    326 
    327         rc = ui_window_create(ui, &params, &window);
    328         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    329         PCUT_ASSERT_NOT_NULL(window);
    330 
    331         rc = ui_menu_bar_create(ui, window, &mbar);
    332         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    333         PCUT_ASSERT_NOT_NULL(mbar);
    334 
    335         rc = ui_menu_create(mbar, "Test", &menu);
    336         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    337         PCUT_ASSERT_NOT_NULL(menu);
    338 
    339         prect.p0.x = 0;
    340         prect.p0.y = 0;
    341         prect.p1.x = 0;
    342         prect.p1.y = 0;
    343 
    344         /* Menu needs to be open to be able to paint it */
    345         rc = ui_menu_open(menu, &prect);
    346         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    347 
    348         pos.x = 0;
    349         pos.y = 0;
    350         rc = ui_menu_paint(menu, &pos);
    351         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    352 
    353         ui_menu_bar_destroy(mbar);
    354         ui_window_destroy(window);
    355         ui_destroy(ui);
    356 }
    357 
    358 /** ui_menu_pos_event() inside menu is claimed */
    359 PCUT_TEST(pos_event_inside)
    360 {
    361         ui_t *ui = NULL;
    362         ui_window_t *window = NULL;
    363         ui_wnd_params_t params;
    364         ui_menu_bar_t *mbar = NULL;
    365         ui_menu_t *menu = NULL;
    366         ui_evclaim_t claimed;
    367         gfx_coord2_t pos;
    368         pos_event_t event;
    369         errno_t rc;
    370 
    371         rc = ui_create_disp(NULL, &ui);
    372         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    373 
    374         ui_wnd_params_init(&params);
    375         params.caption = "Hello";
    376 
    377         rc = ui_window_create(ui, &params, &window);
    378         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    379         PCUT_ASSERT_NOT_NULL(window);
    380 
    381         rc = ui_menu_bar_create(ui, window, &mbar);
    382         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    383         PCUT_ASSERT_NOT_NULL(mbar);
    384 
    385         rc = ui_menu_create(mbar, "Test", &menu);
    386         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    387         PCUT_ASSERT_NOT_NULL(menu);
    388 
    389         pos.x = 0;
    390         pos.y = 0;
    391         event.type = POS_PRESS;
    392         event.hpos = 0;
    393         event.vpos = 0;
    394         claimed = ui_menu_pos_event(menu, &pos, &event);
    395         PCUT_ASSERT_EQUALS(ui_claimed, claimed);
    396 
    397         ui_menu_bar_destroy(mbar);
    398         ui_window_destroy(window);
    399         ui_destroy(ui);
     92/** ui_menu_set_cb() sets the internal fields */
     93PCUT_TEST(set_cb)
     94{
     95        ui_menu_t *menu = NULL;
     96        ui_menu_cb_t cb;
     97        int obj;
     98        errno_t rc;
     99
     100        rc = ui_menu_create(NULL, &menu);
     101        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     102        PCUT_ASSERT_NOT_NULL(menu);
     103
     104        ui_menu_set_cb(menu, &cb, (void *)&obj);
     105        PCUT_ASSERT_EQUALS(&cb, menu->cb);
     106        PCUT_ASSERT_EQUALS((void *)&obj, menu->arg);
     107
     108        ui_menu_destroy(menu);
    400109}
    401110
     
    406115        ui_window_t *window = NULL;
    407116        ui_wnd_params_t params;
    408         ui_menu_bar_t *mbar = NULL;
    409117        ui_menu_t *menu = NULL;
    410118        ui_menu_geom_t geom;
     
    422130        PCUT_ASSERT_NOT_NULL(window);
    423131
    424         rc = ui_menu_bar_create(ui, window, &mbar);
    425         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    426         PCUT_ASSERT_NOT_NULL(mbar);
    427 
    428         rc = ui_menu_create(mbar, "Test", &menu);
     132        rc = ui_menu_create(window, &menu);
    429133        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    430134        PCUT_ASSERT_NOT_NULL(menu);
     
    443147        PCUT_ASSERT_INT_EQUALS(4, geom.entries_rect.p1.y);
    444148
    445         ui_menu_bar_destroy(mbar);
    446         ui_window_destroy(window);
    447         ui_destroy(ui);
     149        ui_menu_destroy(menu);
     150        ui_window_destroy(window);
     151        ui_destroy(ui);
     152}
     153
     154/** ui_menu_get_res() gets the menu's resource */
     155PCUT_TEST(get_res)
     156{
     157        ui_t *ui = NULL;
     158        ui_window_t *window = NULL;
     159        ui_wnd_params_t params;
     160        ui_menu_t *menu = NULL;
     161        ui_resource_t *res;
     162        gfx_rect_t prect;
     163        errno_t rc;
     164
     165        rc = ui_create_disp(NULL, &ui);
     166        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     167
     168        ui_wnd_params_init(&params);
     169        params.caption = "Hello";
     170
     171        rc = ui_window_create(ui, &params, &window);
     172        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     173        PCUT_ASSERT_NOT_NULL(window);
     174
     175        rc = ui_menu_create(window, &menu);
     176        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     177        PCUT_ASSERT_NOT_NULL(menu);
     178
     179        prect.p0.x = 0;
     180        prect.p0.y = 0;
     181        prect.p1.x = 0;
     182        prect.p1.y = 0;
     183
     184        /* The menu must be open first */
     185        rc = ui_menu_open(menu, &prect, 0);
     186        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     187
     188        res = ui_menu_get_res(menu);
     189        PCUT_ASSERT_NOT_NULL(res);
     190
     191        ui_menu_destroy(menu);
     192
     193        ui_window_destroy(window);
     194        ui_destroy(ui);
     195}
     196
     197/** Open and close menu with ui_menu_open() / ui_menu_close() */
     198PCUT_TEST(open_close)
     199{
     200        ui_t *ui = NULL;
     201        ui_window_t *window = NULL;
     202        ui_wnd_params_t params;
     203        ui_menu_t *menu = NULL;
     204        gfx_rect_t prect;
     205        errno_t rc;
     206
     207        rc = ui_create_disp(NULL, &ui);
     208        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     209
     210        ui_wnd_params_init(&params);
     211        params.caption = "Hello";
     212
     213        rc = ui_window_create(ui, &params, &window);
     214        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     215        PCUT_ASSERT_NOT_NULL(window);
     216
     217        rc = ui_menu_create(window, &menu);
     218        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     219        PCUT_ASSERT_NOT_NULL(menu);
     220
     221        prect.p0.x = 0;
     222        prect.p0.y = 0;
     223        prect.p1.x = 0;
     224        prect.p1.y = 0;
     225
     226        /* Open and close */
     227        rc = ui_menu_open(menu, &prect, 0);
     228        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     229
     230        ui_menu_close(menu);
     231
     232        ui_menu_destroy(menu);
     233        ui_window_destroy(window);
     234        ui_destroy(ui);
     235}
     236
     237/** ui_menu_is_open() correctly returns menu state */
     238PCUT_TEST(is_open)
     239{
     240        ui_t *ui = NULL;
     241        ui_window_t *window = NULL;
     242        ui_wnd_params_t params;
     243        ui_menu_t *menu = NULL;
     244        gfx_rect_t prect;
     245        bool open;
     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        rc = ui_menu_create(window, &menu);
     259        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     260        PCUT_ASSERT_NOT_NULL(menu);
     261
     262        prect.p0.x = 0;
     263        prect.p0.y = 0;
     264        prect.p1.x = 0;
     265        prect.p1.y = 0;
     266
     267        open = ui_menu_is_open(menu);
     268        PCUT_ASSERT_FALSE(open);
     269
     270        rc = ui_menu_open(menu, &prect, 0);
     271        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     272
     273        open = ui_menu_is_open(menu);
     274        PCUT_ASSERT_TRUE(open);
     275
     276        ui_menu_close(menu);
     277
     278        open = ui_menu_is_open(menu);
     279        PCUT_ASSERT_FALSE(open);
     280
     281        ui_menu_destroy(menu);
     282        ui_window_destroy(window);
     283        ui_destroy(ui);
     284}
     285
     286/** Paint background in graphics mode */
     287PCUT_TEST(paint_bg_gfx)
     288{
     289        ui_t *ui = NULL;
     290        ui_window_t *window = NULL;
     291        ui_wnd_params_t params;
     292        ui_menu_t *menu = NULL;
     293        gfx_rect_t prect;
     294        gfx_coord2_t pos;
     295        errno_t rc;
     296
     297        rc = ui_create_disp(NULL, &ui);
     298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     299
     300        ui_wnd_params_init(&params);
     301        params.caption = "Hello";
     302
     303        rc = ui_window_create(ui, &params, &window);
     304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     305        PCUT_ASSERT_NOT_NULL(window);
     306
     307        rc = ui_menu_create(window, &menu);
     308        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     309        PCUT_ASSERT_NOT_NULL(menu);
     310
     311        prect.p0.x = 0;
     312        prect.p0.y = 0;
     313        prect.p1.x = 0;
     314        prect.p1.y = 0;
     315
     316        /* Menu needs to be open to be able to paint it */
     317        rc = ui_menu_open(menu, &prect, 0);
     318        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319
     320        pos.x = 0;
     321        pos.y = 0;
     322        rc = ui_menu_paint_bg_gfx(menu, &pos);
     323        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     324
     325        ui_window_destroy(window);
     326        ui_destroy(ui);
     327}
     328
     329/** Paint background in text mode */
     330PCUT_TEST(paint_bg_text)
     331{
     332        ui_t *ui = NULL;
     333        ui_window_t *window = NULL;
     334        ui_wnd_params_t params;
     335        ui_menu_t *menu = NULL;
     336        gfx_rect_t prect;
     337        gfx_coord2_t pos;
     338        errno_t rc;
     339
     340        rc = ui_create_disp(NULL, &ui);
     341        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     342
     343        ui_wnd_params_init(&params);
     344        params.caption = "Hello";
     345
     346        rc = ui_window_create(ui, &params, &window);
     347        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     348        PCUT_ASSERT_NOT_NULL(window);
     349
     350        rc = ui_menu_create(window, &menu);
     351        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     352        PCUT_ASSERT_NOT_NULL(menu);
     353
     354        prect.p0.x = 0;
     355        prect.p0.y = 0;
     356        prect.p1.x = 0;
     357        prect.p1.y = 0;
     358
     359        /* Menu needs to be open to be able to paint it */
     360        rc = ui_menu_open(menu, &prect, 0);
     361        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     362
     363        pos.x = 0;
     364        pos.y = 0;
     365        rc = ui_menu_paint_bg_text(menu, &pos);
     366        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     367
     368        ui_window_destroy(window);
     369        ui_destroy(ui);
     370}
     371
     372/** Paint menu */
     373PCUT_TEST(paint)
     374{
     375        ui_t *ui = NULL;
     376        ui_window_t *window = NULL;
     377        ui_wnd_params_t params;
     378        ui_menu_t *menu = NULL;
     379        gfx_rect_t prect;
     380        gfx_coord2_t pos;
     381        errno_t rc;
     382
     383        rc = ui_create_disp(NULL, &ui);
     384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     385
     386        ui_wnd_params_init(&params);
     387        params.caption = "Hello";
     388
     389        rc = ui_window_create(ui, &params, &window);
     390        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     391        PCUT_ASSERT_NOT_NULL(window);
     392
     393        rc = ui_menu_create(window, &menu);
     394        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     395        PCUT_ASSERT_NOT_NULL(menu);
     396
     397        prect.p0.x = 0;
     398        prect.p0.y = 0;
     399        prect.p1.x = 0;
     400        prect.p1.y = 0;
     401
     402        /* Menu needs to be open to be able to paint it */
     403        rc = ui_menu_open(menu, &prect, 0);
     404        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     405
     406        pos.x = 0;
     407        pos.y = 0;
     408        rc = ui_menu_paint(menu, &pos);
     409        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     410
     411        ui_window_destroy(window);
     412        ui_destroy(ui);
     413}
     414
     415/** ui_menu_pos_event() inside menu is claimed */
     416PCUT_TEST(pos_event_inside)
     417{
     418        ui_t *ui = NULL;
     419        ui_window_t *window = NULL;
     420        ui_wnd_params_t params;
     421        ui_menu_t *menu = NULL;
     422        ui_evclaim_t claimed;
     423        gfx_coord2_t pos;
     424        pos_event_t event;
     425        errno_t rc;
     426
     427        rc = ui_create_disp(NULL, &ui);
     428        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     429
     430        ui_wnd_params_init(&params);
     431        params.caption = "Hello";
     432
     433        rc = ui_window_create(ui, &params, &window);
     434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     435        PCUT_ASSERT_NOT_NULL(window);
     436
     437        rc = ui_menu_create(window, &menu);
     438        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     439        PCUT_ASSERT_NOT_NULL(menu);
     440
     441        pos.x = 0;
     442        pos.y = 0;
     443        event.type = POS_PRESS;
     444        event.hpos = 0;
     445        event.vpos = 0;
     446        claimed = ui_menu_pos_event(menu, &pos, &event);
     447        PCUT_ASSERT_EQUALS(ui_claimed, claimed);
     448
     449        ui_window_destroy(window);
     450        ui_destroy(ui);
     451}
     452
     453/** ui_menu_up() with empty menu does nothing */
     454PCUT_TEST(up_empty)
     455{
     456        ui_t *ui = NULL;
     457        ui_window_t *window = NULL;
     458        ui_wnd_params_t params;
     459        ui_menu_t *menu = NULL;
     460        gfx_rect_t prect;
     461        errno_t rc;
     462
     463        rc = ui_create_disp(NULL, &ui);
     464        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     465
     466        ui_wnd_params_init(&params);
     467        params.caption = "Hello";
     468
     469        rc = ui_window_create(ui, &params, &window);
     470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     471        PCUT_ASSERT_NOT_NULL(window);
     472
     473        rc = ui_menu_create(window, &menu);
     474        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     475        PCUT_ASSERT_NOT_NULL(menu);
     476
     477        prect.p0.x = 0;
     478        prect.p0.y = 0;
     479        prect.p1.x = 0;
     480        prect.p1.y = 0;
     481
     482        /* Menu needs to be open to be able to move around it */
     483        rc = ui_menu_open(menu, &prect, 0);
     484        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     485
     486        ui_menu_up(menu);
     487
     488        ui_window_destroy(window);
     489        ui_destroy(ui);
     490}
     491
     492/** ui_menu_up() moves one entry up, skips separators, wraps around */
     493PCUT_TEST(up)
     494{
     495        ui_t *ui = NULL;
     496        ui_window_t *window = NULL;
     497        ui_wnd_params_t params;
     498        ui_menu_t *menu = NULL;
     499        ui_menu_entry_t *mentry1 = NULL;
     500        ui_menu_entry_t *mentry2 = NULL;
     501        ui_menu_entry_t *mentry3 = NULL;
     502        gfx_rect_t prect;
     503        errno_t rc;
     504
     505        rc = ui_create_disp(NULL, &ui);
     506        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     507
     508        ui_wnd_params_init(&params);
     509        params.caption = "Hello";
     510
     511        rc = ui_window_create(ui, &params, &window);
     512        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     513        PCUT_ASSERT_NOT_NULL(window);
     514
     515        rc = ui_menu_create(window, &menu);
     516        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     517        PCUT_ASSERT_NOT_NULL(menu);
     518
     519        rc = ui_menu_entry_create(menu, "Foo", "F1", &mentry1);
     520        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     521        PCUT_ASSERT_NOT_NULL(mentry1);
     522
     523        rc = ui_menu_entry_sep_create(menu, &mentry2);
     524        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     525        PCUT_ASSERT_NOT_NULL(mentry2);
     526
     527        rc = ui_menu_entry_create(menu, "Bar", "F2", &mentry3);
     528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     529        PCUT_ASSERT_NOT_NULL(mentry3);
     530
     531        prect.p0.x = 0;
     532        prect.p0.y = 0;
     533        prect.p1.x = 0;
     534        prect.p1.y = 0;
     535
     536        /* Menu needs to be open to be able to move around it */
     537        rc = ui_menu_open(menu, &prect, 0);
     538        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     539
     540        /* When menu is open, the first entry is selected */
     541        PCUT_ASSERT_EQUALS(mentry1, menu->selected);
     542
     543        ui_menu_up(menu);
     544
     545        /* Now we've wrapped around to the last entry */
     546        PCUT_ASSERT_EQUALS(mentry3, menu->selected);
     547
     548        ui_menu_up(menu);
     549
     550        /* mentry2 is a separator and was skipped */
     551        PCUT_ASSERT_EQUALS(mentry1, menu->selected);
     552
     553        ui_window_destroy(window);
     554        ui_destroy(ui);
     555}
     556
     557/** ui_menu_down() with empty menu does nothing */
     558PCUT_TEST(down_empty)
     559{
     560        ui_t *ui = NULL;
     561        ui_window_t *window = NULL;
     562        ui_wnd_params_t params;
     563        ui_menu_t *menu = NULL;
     564        gfx_rect_t prect;
     565        errno_t rc;
     566
     567        rc = ui_create_disp(NULL, &ui);
     568        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     569
     570        ui_wnd_params_init(&params);
     571        params.caption = "Hello";
     572
     573        rc = ui_window_create(ui, &params, &window);
     574        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     575        PCUT_ASSERT_NOT_NULL(window);
     576
     577        rc = ui_menu_create(window, &menu);
     578        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     579        PCUT_ASSERT_NOT_NULL(menu);
     580
     581        prect.p0.x = 0;
     582        prect.p0.y = 0;
     583        prect.p1.x = 0;
     584        prect.p1.y = 0;
     585
     586        /* Menu needs to be open to be able to move around it */
     587        rc = ui_menu_open(menu, &prect, 0);
     588        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     589
     590        ui_menu_down(menu);
     591
     592        ui_window_destroy(window);
     593        ui_destroy(ui);
     594}
     595
     596/** ui_menu_down() moves one entry down, skips separators, wraps around */
     597PCUT_TEST(down)
     598{
     599        ui_t *ui = NULL;
     600        ui_window_t *window = NULL;
     601        ui_wnd_params_t params;
     602        ui_menu_t *menu = NULL;
     603        ui_menu_entry_t *mentry1 = NULL;
     604        ui_menu_entry_t *mentry2 = NULL;
     605        ui_menu_entry_t *mentry3 = NULL;
     606        gfx_rect_t prect;
     607        errno_t rc;
     608
     609        rc = ui_create_disp(NULL, &ui);
     610        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     611
     612        ui_wnd_params_init(&params);
     613        params.caption = "Hello";
     614
     615        rc = ui_window_create(ui, &params, &window);
     616        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     617        PCUT_ASSERT_NOT_NULL(window);
     618
     619        rc = ui_menu_create(window, &menu);
     620        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     621        PCUT_ASSERT_NOT_NULL(menu);
     622
     623        rc = ui_menu_entry_create(menu, "Foo", "F1", &mentry1);
     624        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     625        PCUT_ASSERT_NOT_NULL(mentry1);
     626
     627        rc = ui_menu_entry_sep_create(menu, &mentry2);
     628        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     629        PCUT_ASSERT_NOT_NULL(mentry2);
     630
     631        rc = ui_menu_entry_create(menu, "Bar", "F2", &mentry3);
     632        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     633        PCUT_ASSERT_NOT_NULL(mentry3);
     634
     635        prect.p0.x = 0;
     636        prect.p0.y = 0;
     637        prect.p1.x = 0;
     638        prect.p1.y = 0;
     639
     640        /* Menu needs to be open to be able to move around it */
     641        rc = ui_menu_open(menu, &prect, 0);
     642        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     643
     644        /* When menu is open, the first entry is selected */
     645        PCUT_ASSERT_EQUALS(mentry1, menu->selected);
     646
     647        ui_menu_down(menu);
     648
     649        /* mentry2 is a separator and was skipped */
     650        PCUT_ASSERT_EQUALS(mentry3, menu->selected);
     651
     652        ui_menu_up(menu);
     653
     654        /* Now we've wrapped around to the first entry */
     655        PCUT_ASSERT_EQUALS(mentry1, menu->selected);
     656
     657        ui_window_destroy(window);
     658        ui_destroy(ui);
     659}
     660
     661/** Sending an unhandled event does nothing. */
     662PCUT_TEST(send_unhandled)
     663{
     664        ui_menu_t *menu = NULL;
     665        errno_t rc;
     666        sysarg_t idev_id;
     667        char32_t c;
     668
     669        rc = ui_menu_create(NULL, &menu);
     670        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     671        PCUT_ASSERT_NOT_NULL(menu);
     672
     673        /* Send events without setting callback */
     674        c = 'A';
     675        idev_id = 42;
     676        ui_menu_left(menu, idev_id);
     677        ui_menu_right(menu, idev_id);
     678        ui_menu_close_req(menu);
     679        ui_menu_press_accel(menu, c, idev_id);
     680
     681        /* Set dummy callback structure */
     682        ui_menu_set_cb(menu, &dummy_cb, NULL);
     683
     684        /* Send unhandled events */
     685        ui_menu_left(menu, idev_id);
     686        ui_menu_right(menu, idev_id);
     687        ui_menu_close_req(menu);
     688        ui_menu_press_accel(menu, c, idev_id);
     689
     690        ui_menu_destroy(menu);
     691}
     692
     693/** ui_menu_left() sends left event */
     694PCUT_TEST(left)
     695{
     696        ui_menu_t *menu = NULL;
     697        errno_t rc;
     698        test_resp_t resp;
     699        sysarg_t idev_id;
     700
     701        rc = ui_menu_create(NULL, &menu);
     702        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     703        PCUT_ASSERT_NOT_NULL(menu);
     704
     705        ui_menu_set_cb(menu, &testmenu_cb, (void *)&resp);
     706
     707        memset(&resp, 0, sizeof(resp));
     708        PCUT_ASSERT_FALSE(resp.left_called);
     709
     710        idev_id = 42;
     711        ui_menu_left(menu, idev_id);
     712
     713        PCUT_ASSERT_TRUE(resp.left_called);
     714        PCUT_ASSERT_EQUALS(menu, resp.menu);
     715        PCUT_ASSERT_INT_EQUALS(idev_id, resp.idev_id);
     716
     717        ui_menu_destroy(menu);
     718}
     719
     720/** ui_menu_right() sends right event */
     721PCUT_TEST(right)
     722{
     723        ui_menu_t *menu = NULL;
     724        errno_t rc;
     725        test_resp_t resp;
     726        sysarg_t idev_id;
     727
     728        rc = ui_menu_create(NULL, &menu);
     729        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     730        PCUT_ASSERT_NOT_NULL(menu);
     731
     732        ui_menu_set_cb(menu, &testmenu_cb, (void *)&resp);
     733
     734        memset(&resp, 0, sizeof(resp));
     735        PCUT_ASSERT_FALSE(resp.right_called);
     736
     737        idev_id = 42;
     738        ui_menu_right(menu, idev_id);
     739
     740        PCUT_ASSERT_TRUE(resp.right_called);
     741        PCUT_ASSERT_EQUALS(menu, resp.menu);
     742        PCUT_ASSERT_INT_EQUALS(idev_id, resp.idev_id);
     743
     744        ui_menu_destroy(menu);
     745}
     746
     747/** ui_menu_close_req() sends close_req event */
     748PCUT_TEST(close_req)
     749{
     750        ui_menu_t *menu = NULL;
     751        errno_t rc;
     752        test_resp_t resp;
     753
     754        rc = ui_menu_create(NULL, &menu);
     755        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     756        PCUT_ASSERT_NOT_NULL(menu);
     757
     758        ui_menu_set_cb(menu, &testmenu_cb, (void *)&resp);
     759
     760        memset(&resp, 0, sizeof(resp));
     761        PCUT_ASSERT_FALSE(resp.close_req_called);
     762
     763        ui_menu_close_req(menu);
     764
     765        PCUT_ASSERT_TRUE(resp.close_req_called);
     766        PCUT_ASSERT_EQUALS(menu, resp.menu);
     767
     768        ui_menu_destroy(menu);
     769}
     770
     771/** ui_menu_press_accel() sends press_accel event */
     772PCUT_TEST(press_accel)
     773{
     774        ui_menu_t *menu = NULL;
     775        errno_t rc;
     776        test_resp_t resp;
     777        char32_t c;
     778        sysarg_t idev_id;
     779
     780        rc = ui_menu_create(NULL, &menu);
     781        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     782        PCUT_ASSERT_NOT_NULL(menu);
     783
     784        ui_menu_set_cb(menu, &testmenu_cb, (void *)&resp);
     785
     786        memset(&resp, 0, sizeof(resp));
     787        PCUT_ASSERT_FALSE(resp.press_accel_called);
     788
     789        c = 'A';
     790        idev_id = 42;
     791        ui_menu_press_accel(menu, c, idev_id);
     792
     793        PCUT_ASSERT_TRUE(resp.press_accel_called);
     794        PCUT_ASSERT_EQUALS(menu, resp.menu);
     795        PCUT_ASSERT_EQUALS(c, resp.c);
     796        PCUT_ASSERT_INT_EQUALS(idev_id, resp.idev_id);
     797
     798        ui_menu_destroy(menu);
     799}
     800
     801/** Test menu left callback */
     802static void testmenu_left(ui_menu_t *menu, void *arg, sysarg_t idev_id)
     803{
     804        test_resp_t *resp = (test_resp_t *)arg;
     805
     806        resp->left_called = true;
     807        resp->menu = menu;
     808        resp->idev_id = idev_id;
     809}
     810
     811/** Test menu right callback */
     812static void testmenu_right(ui_menu_t *menu, void *arg, sysarg_t idev_id)
     813{
     814        test_resp_t *resp = (test_resp_t *)arg;
     815
     816        resp->right_called = true;
     817        resp->menu = menu;
     818        resp->idev_id = idev_id;
     819}
     820
     821/** Test menu close callback */
     822static void testmenu_close_req(ui_menu_t *menu, void *arg)
     823{
     824        test_resp_t *resp = (test_resp_t *)arg;
     825
     826        resp->close_req_called = true;
     827        resp->menu = menu;
     828}
     829
     830/** Test menu press accel callback */
     831static void testmenu_press_accel(ui_menu_t *menu, void *arg,
     832    char32_t c, sysarg_t kbd_id)
     833{
     834        test_resp_t *resp = (test_resp_t *)arg;
     835
     836        resp->press_accel_called = true;
     837        resp->menu = menu;
     838        resp->c = c;
     839        resp->idev_id = kbd_id;
    448840}
    449841
Note: See TracChangeset for help on using the changeset viewer.