Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/display/test/display.c

    rca48672 r4ac11ff  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#include <loc.h>
    3939#include <pcut/pcut.h>
    40 #include <str.h>
    4140#include "../private/display.h"
    4241
    … …  
    5150
    5251static void test_close_event(void *);
    53 static void test_focus_event(void *, unsigned);
     52static void test_focus_event(void *);
    5453static void test_kbd_event(void *, kbd_event_t *);
    5554static void test_pos_event(void *, pos_event_t *);
    56 static void test_unfocus_event(void *, unsigned);
     55static void test_unfocus_event(void *);
    5756
    5857static errno_t test_window_create(void *, display_wnd_params_t *, sysarg_t *);
    5958static errno_t test_window_destroy(void *, sysarg_t);
    60 static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *, sysarg_t);
     59static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *);
    6160static errno_t test_window_move(void *, sysarg_t, gfx_coord2_t *);
    62 static errno_t test_window_get_pos(void *, sysarg_t, gfx_coord2_t *);
    63 static errno_t test_window_get_max_rect(void *, sysarg_t, gfx_rect_t *);
    6461static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
    65     gfx_coord2_t *, sysarg_t);
     62    gfx_coord2_t *);
    6663static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6764    gfx_rect_t *);
    68 static errno_t test_window_minimize(void *, sysarg_t);
    69 static errno_t test_window_maximize(void *, sysarg_t);
    70 static errno_t test_window_unmaximize(void *, sysarg_t);
    7165static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t);
    72 static errno_t test_window_set_caption(void *, sysarg_t, const char *);
    7366static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    7467static errno_t test_get_info(void *, display_info_t *);
    … …  
    8174        .window_move_req = test_window_move_req,
    8275        .window_move = test_window_move,
    83         .window_get_pos = test_window_get_pos,
    84         .window_get_max_rect = test_window_get_max_rect,
    8576        .window_resize_req = test_window_resize_req,
    8677        .window_resize = test_window_resize,
    87         .window_minimize = test_window_minimize,
    88         .window_maximize = test_window_maximize,
    89         .window_unmaximize = test_window_unmaximize,
    9078        .window_set_cursor = test_window_set_cursor,
    91         .window_set_caption = test_window_set_caption,
    9279        .get_event = test_get_event,
    9380        .get_info = test_get_info
    … …  
    118105        gfx_rect_t create_rect;
    119106        gfx_coord2_t create_min_size;
    120         sysarg_t create_idev_id;
    121107        bool window_destroy_called;
    122108        sysarg_t destroy_wnd_id;
    … …  
    125111        sysarg_t move_req_wnd_id;
    126112        gfx_coord2_t move_req_pos;
    127         sysarg_t move_req_pos_id;
    128113
    129114        bool window_move_called;
    130115        sysarg_t move_wnd_id;
    131116        gfx_coord2_t move_dpos;
    132 
    133         bool window_get_pos_called;
    134         sysarg_t get_pos_wnd_id;
    135         gfx_coord2_t get_pos_rpos;
    136 
    137         bool window_get_max_rect_called;
    138         sysarg_t get_max_rect_wnd_id;
    139         gfx_rect_t get_max_rect_rrect;
    140117
    141118        bool window_resize_req_called;
    … …  
    143120        display_wnd_rsztype_t resize_req_rsztype;
    144121        gfx_coord2_t resize_req_pos;
    145         sysarg_t resize_req_pos_id;
    146122
    147123        bool window_resize_called;
    … …  
    150126        sysarg_t resize_wnd_id;
    151127
    152         bool window_minimize_called;
    153         bool window_maximize_called;
    154         bool window_unmaximize_called;
    155 
    156128        bool window_set_cursor_called;
    157129        sysarg_t set_cursor_wnd_id;
    158130        display_stock_cursor_t set_cursor_cursor;
    159131
    160         bool window_set_caption_called;
    161         sysarg_t set_caption_wnd_id;
    162         char *set_caption_caption;
    163 
    164132        bool get_event_called;
    165133
    … …  
    169137        bool set_color_called;
    170138        bool close_event_called;
    171 
    172139        bool focus_event_called;
    173140        bool kbd_event_called;
    … …  
    186153        display_t *disp = NULL;
    187154        test_response_t resp;
    188         loc_srv_t *srv;
    189 
    190         async_set_fallback_port_handler(test_display_conn, &resp);
    191 
    192         // FIXME This causes this test to be non-reentrant!
    193         rc = loc_server_register(test_display_server, &srv);
    194         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    195 
    196         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    197             &sid);
    198         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    199 
    200         rc = display_open(test_display_svc, &disp);
    201         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    202         PCUT_ASSERT_NOT_NULL(disp);
    203 
    204         display_close(disp);
    205         rc = loc_service_unregister(srv, sid);
    206         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    207         loc_server_unregister(srv);
     155
     156        async_set_fallback_port_handler(test_display_conn, &resp);
     157
     158        // FIXME This causes this test to be non-reentrant!
     159        rc = loc_server_register(test_display_server);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161
     162        rc = loc_service_register(test_display_svc, &sid);
     163        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     164
     165        rc = display_open(test_display_svc, &disp);
     166        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     167        PCUT_ASSERT_NOT_NULL(disp);
     168
     169        display_close(disp);
     170        rc = loc_service_unregister(sid);
     171        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    208172}
    209173
    … …  
    217181        display_window_t *wnd;
    218182        test_response_t resp;
    219         loc_srv_t *srv;
    220 
    221         async_set_fallback_port_handler(test_display_conn, &resp);
    222 
    223         // FIXME This causes this test to be non-reentrant!
    224         rc = loc_server_register(test_display_server, &srv);
    225         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    226 
    227         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    228             &sid);
     183
     184        async_set_fallback_port_handler(test_display_conn, &resp);
     185
     186        // FIXME This causes this test to be non-reentrant!
     187        rc = loc_server_register(test_display_server);
     188        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     189
     190        rc = loc_service_register(test_display_svc, &sid);
    229191        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    230192
    … …  
    243205        params.min_size.x = 11;
    244206        params.min_size.y = 12;
    245         params.idev_id = 42;
    246207
    247208        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    254215        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    255216        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
    256         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    257217        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    258218        PCUT_ASSERT_NULL(wnd);
    259219
    260220        display_close(disp);
    261         rc = loc_service_unregister(srv, sid);
    262         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    263         loc_server_unregister(srv);
     221        rc = loc_service_unregister(sid);
     222        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    264223}
    265224
    … …  
    276235        display_window_t *wnd;
    277236        test_response_t resp;
    278         loc_srv_t *srv;
    279 
    280         async_set_fallback_port_handler(test_display_conn, &resp);
    281 
    282         // FIXME This causes this test to be non-reentrant!
    283         rc = loc_server_register(test_display_server, &srv);
    284         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    285 
    286         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    287             &sid);
     237
     238        async_set_fallback_port_handler(test_display_conn, &resp);
     239
     240        // FIXME This causes this test to be non-reentrant!
     241        rc = loc_server_register(test_display_server);
     242        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     243
     244        rc = loc_service_register(test_display_svc, &sid);
    288245        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    289246
    … …  
    300257        params.rect.p0.x = 100;
    301258        params.rect.p0.y = 100;
    302         params.idev_id = 42;
    303259
    304260        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    309265        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    310266        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
    311         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    312267        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    313268        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    320275
    321276        display_close(disp);
    322         rc = loc_service_unregister(srv, sid);
    323         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    324         loc_server_unregister(srv);
     277        rc = loc_service_unregister(sid);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    325279}
    326280
    … …  
    334288        display_window_t *wnd;
    335289        test_response_t resp;
    336         loc_srv_t *srv;
    337 
    338         async_set_fallback_port_handler(test_display_conn, &resp);
    339 
    340         // FIXME This causes this test to be non-reentrant!
    341         rc = loc_server_register(test_display_server, &srv);
    342         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    343 
    344         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    345             &sid);
     290
     291        async_set_fallback_port_handler(test_display_conn, &resp);
     292
     293        // FIXME This causes this test to be non-reentrant!
     294        rc = loc_server_register(test_display_server);
     295        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     296
     297        rc = loc_service_register(test_display_svc, &sid);
    346298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    347299
    … …  
    376328
    377329        display_close(disp);
    378         rc = loc_service_unregister(srv, sid);
    379         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    380         loc_server_unregister(srv);
     330        rc = loc_service_unregister(sid);
     331        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    381332}
    382333
    … …  
    397348        test_response_t resp;
    398349        gfx_coord2_t pos;
    399         sysarg_t pos_id;
    400         loc_srv_t *srv;
    401 
    402         async_set_fallback_port_handler(test_display_conn, &resp);
    403 
    404         // FIXME This causes this test to be non-reentrant!
    405         rc = loc_server_register(test_display_server, &srv);
    406         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    407 
    408         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    409             &sid);
     350
     351        async_set_fallback_port_handler(test_display_conn, &resp);
     352
     353        // FIXME This causes this test to be non-reentrant!
     354        rc = loc_server_register(test_display_server);
     355        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     356
     357        rc = loc_service_register(test_display_svc, &sid);
    410358        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    411359
    … …  
    431379        pos.x = 42;
    432380        pos.y = 43;
    433         pos_id = 44;
    434 
    435         rc = display_window_move_req(wnd, &pos, pos_id);
     381
     382        rc = display_window_move_req(wnd, &pos);
    436383        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    437384        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    439386        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    440387        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    441         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    442388
    443389        display_window_destroy(wnd);
    444390        display_close(disp);
    445         rc = loc_service_unregister(srv, sid);
    446         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    447         loc_server_unregister(srv);
     391        rc = loc_service_unregister(sid);
     392        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    448393}
    449394
    … …  
    458403        test_response_t resp;
    459404        gfx_coord2_t pos;
    460         sysarg_t pos_id;
    461         loc_srv_t *srv;
    462 
    463         async_set_fallback_port_handler(test_display_conn, &resp);
    464 
    465         // FIXME This causes this test to be non-reentrant!
    466         rc = loc_server_register(test_display_server, &srv);
    467         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    468 
    469         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    470             &sid);
     405
     406        async_set_fallback_port_handler(test_display_conn, &resp);
     407
     408        // FIXME This causes this test to be non-reentrant!
     409        rc = loc_server_register(test_display_server);
     410        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     411
     412        rc = loc_service_register(test_display_svc, &sid);
    471413        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    472414
    … …  
    492434        pos.x = 42;
    493435        pos.y = 43;
    494         pos_id = 44;
    495 
    496         rc = display_window_move_req(wnd, &pos, pos_id);
     436
     437        rc = display_window_move_req(wnd, &pos);
    497438        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    498439        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    500441        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    501442        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    502         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    503443
    504444        display_window_destroy(wnd);
    505445        display_close(disp);
    506         rc = loc_service_unregister(srv, sid);
    507         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    508         loc_server_unregister(srv);
     446        rc = loc_service_unregister(sid);
     447        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    509448}
    510449
    … …  
    519458        gfx_coord2_t dpos;
    520459        test_response_t resp;
    521         loc_srv_t *srv;
    522 
    523         async_set_fallback_port_handler(test_display_conn, &resp);
    524 
    525         // FIXME This causes this test to be non-reentrant!
    526         rc = loc_server_register(test_display_server, &srv);
    527         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    528 
    529         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    530             &sid);
     460
     461        async_set_fallback_port_handler(test_display_conn, &resp);
     462
     463        // FIXME This causes this test to be non-reentrant!
     464        rc = loc_server_register(test_display_server);
     465        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     466
     467        rc = loc_service_register(test_display_svc, &sid);
    531468        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    532469
    … …  
    561498        display_window_destroy(wnd);
    562499        display_close(disp);
    563         rc = loc_service_unregister(srv, sid);
    564         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    565         loc_server_unregister(srv);
     500        rc = loc_service_unregister(sid);
     501        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    566502}
    567503
    … …  
    576512        gfx_coord2_t dpos;
    577513        test_response_t resp;
    578         loc_srv_t *srv;
    579 
    580         async_set_fallback_port_handler(test_display_conn, &resp);
    581 
    582         // FIXME This causes this test to be non-reentrant!
    583         rc = loc_server_register(test_display_server, &srv);
    584         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    585 
    586         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    587             &sid);
     514
     515        async_set_fallback_port_handler(test_display_conn, &resp);
     516
     517        // FIXME This causes this test to be non-reentrant!
     518        rc = loc_server_register(test_display_server);
     519        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     520
     521        rc = loc_service_register(test_display_svc, &sid);
    588522        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    589523
    … …  
    618552        display_window_destroy(wnd);
    619553        display_close(disp);
    620         rc = loc_service_unregister(srv, sid);
    621         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    622         loc_server_unregister(srv);
    623 }
    624 
    625 /** display_window_get_pos() with server returning error response works. */
    626 PCUT_TEST(window_get_pos_failure)
    627 {
    628         errno_t rc;
    629         service_id_t sid;
    630         display_t *disp = NULL;
    631         display_wnd_params_t params;
    632         display_window_t *wnd;
    633         gfx_coord2_t dpos;
    634         test_response_t resp;
    635         loc_srv_t *srv;
    636 
    637         async_set_fallback_port_handler(test_display_conn, &resp);
    638 
    639         // FIXME This causes this test to be non-reentrant!
    640         rc = loc_server_register(test_display_server, &srv);
    641         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    642 
    643         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    644             &sid);
    645         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    646 
    647         rc = display_open(test_display_svc, &disp);
    648         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    649         PCUT_ASSERT_NOT_NULL(disp);
    650 
    651         resp.rc = EOK;
    652         display_wnd_params_init(&params);
    653         params.rect.p0.x = 0;
    654         params.rect.p0.y = 0;
    655         params.rect.p0.x = 100;
    656         params.rect.p0.y = 100;
    657 
    658         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    659             (void *) &resp, &wnd);
    660         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    661         PCUT_ASSERT_NOT_NULL(wnd);
    662 
    663         resp.rc = EIO;
    664         resp.window_get_pos_called = false;
    665 
    666         dpos.x = 0;
    667         dpos.y = 0;
    668 
    669         rc = display_window_get_pos(wnd, &dpos);
    670         PCUT_ASSERT_TRUE(resp.window_get_pos_called);
    671         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    672         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
    673         PCUT_ASSERT_INT_EQUALS(0, dpos.x);
    674         PCUT_ASSERT_INT_EQUALS(0, dpos.y);
    675 
    676         display_window_destroy(wnd);
    677         display_close(disp);
    678         rc = loc_service_unregister(srv, sid);
    679         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    680         loc_server_unregister(srv);
    681 }
    682 
    683 /** display_window_get_pos() with server returning success response works. */
    684 PCUT_TEST(window_get_pos_success)
    685 {
    686         errno_t rc;
    687         service_id_t sid;
    688         display_t *disp = NULL;
    689         display_wnd_params_t params;
    690         display_window_t *wnd;
    691         gfx_coord2_t dpos;
    692         test_response_t resp;
    693         loc_srv_t *srv;
    694 
    695         async_set_fallback_port_handler(test_display_conn, &resp);
    696 
    697         // FIXME This causes this test to be non-reentrant!
    698         rc = loc_server_register(test_display_server, &srv);
    699         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    700 
    701         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    702             &sid);
    703         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    704 
    705         rc = display_open(test_display_svc, &disp);
    706         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    707         PCUT_ASSERT_NOT_NULL(disp);
    708 
    709         resp.rc = EOK;
    710         display_wnd_params_init(&params);
    711         params.rect.p0.x = 0;
    712         params.rect.p0.y = 0;
    713         params.rect.p0.x = 100;
    714         params.rect.p0.y = 100;
    715 
    716         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    717             (void *) &resp, &wnd);
    718         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    719         PCUT_ASSERT_NOT_NULL(wnd);
    720 
    721         resp.rc = EOK;
    722         resp.window_get_pos_called = false;
    723         resp.get_pos_rpos.x = 11;
    724         resp.get_pos_rpos.y = 12;
    725 
    726         dpos.x = 0;
    727         dpos.y = 0;
    728 
    729         rc = display_window_get_pos(wnd, &dpos);
    730         PCUT_ASSERT_TRUE(resp.window_get_pos_called);
    731         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    732         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
    733         PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.x, dpos.x);
    734         PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.y, dpos.y);
    735 
    736         display_window_destroy(wnd);
    737         display_close(disp);
    738         rc = loc_service_unregister(srv, sid);
    739         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    740         loc_server_unregister(srv);
    741 }
    742 
    743 /** display_window_get_max_rect() with server returning error response works. */
    744 PCUT_TEST(window_get_max_rect_failure)
    745 {
    746         errno_t rc;
    747         service_id_t sid;
    748         display_t *disp = NULL;
    749         display_wnd_params_t params;
    750         display_window_t *wnd;
    751         gfx_rect_t rect;
    752         test_response_t resp;
    753         loc_srv_t *srv;
    754 
    755         async_set_fallback_port_handler(test_display_conn, &resp);
    756 
    757         // FIXME This causes this test to be non-reentrant!
    758         rc = loc_server_register(test_display_server, &srv);
    759         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    760 
    761         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    762             &sid);
    763         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    764 
    765         rc = display_open(test_display_svc, &disp);
    766         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    767         PCUT_ASSERT_NOT_NULL(disp);
    768 
    769         resp.rc = EOK;
    770         display_wnd_params_init(&params);
    771         params.rect.p0.x = 0;
    772         params.rect.p0.y = 0;
    773         params.rect.p0.x = 100;
    774         params.rect.p0.y = 100;
    775 
    776         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    777             (void *) &resp, &wnd);
    778         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    779         PCUT_ASSERT_NOT_NULL(wnd);
    780 
    781         resp.rc = EIO;
    782         resp.window_get_max_rect_called = false;
    783 
    784         rect.p0.x = 0;
    785         rect.p0.y = 0;
    786         rect.p1.x = 0;
    787         rect.p1.y = 0;
    788 
    789         rc = display_window_get_max_rect(wnd, &rect);
    790         PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
    791         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    792         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
    793         PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
    794         PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
    795         PCUT_ASSERT_INT_EQUALS(0, rect.p1.x);
    796         PCUT_ASSERT_INT_EQUALS(0, rect.p1.y);
    797 
    798         display_window_destroy(wnd);
    799         display_close(disp);
    800         rc = loc_service_unregister(srv, sid);
    801         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    802         loc_server_unregister(srv);
    803 }
    804 
    805 /** display_window_get_max_rect() with server returning success response works. */
    806 PCUT_TEST(window_get_max_rect_success)
    807 {
    808         errno_t rc;
    809         service_id_t sid;
    810         display_t *disp = NULL;
    811         display_wnd_params_t params;
    812         display_window_t *wnd;
    813         gfx_rect_t rect;
    814         test_response_t resp;
    815         loc_srv_t *srv;
    816 
    817         async_set_fallback_port_handler(test_display_conn, &resp);
    818 
    819         // FIXME This causes this test to be non-reentrant!
    820         rc = loc_server_register(test_display_server, &srv);
    821         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    822 
    823         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    824             &sid);
    825         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    826 
    827         rc = display_open(test_display_svc, &disp);
    828         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    829         PCUT_ASSERT_NOT_NULL(disp);
    830 
    831         resp.rc = EOK;
    832         display_wnd_params_init(&params);
    833         params.rect.p0.x = 0;
    834         params.rect.p0.y = 0;
    835         params.rect.p0.x = 100;
    836         params.rect.p0.y = 100;
    837 
    838         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    839             (void *) &resp, &wnd);
    840         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    841         PCUT_ASSERT_NOT_NULL(wnd);
    842 
    843         resp.rc = EOK;
    844         resp.window_get_max_rect_called = false;
    845         resp.get_max_rect_rrect.p0.x = 11;
    846         resp.get_max_rect_rrect.p0.y = 12;
    847         resp.get_max_rect_rrect.p1.x = 13;
    848         resp.get_max_rect_rrect.p1.y = 14;
    849 
    850         rect.p0.x = 0;
    851         rect.p0.y = 0;
    852         rect.p1.x = 0;
    853         rect.p1.y = 0;
    854 
    855         rc = display_window_get_max_rect(wnd, &rect);
    856         PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
    857         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    858         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
    859         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x);
    860         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y);
    861         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x);
    862         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y);
    863 
    864         display_window_destroy(wnd);
    865         display_close(disp);
    866         rc = loc_service_unregister(srv, sid);
    867         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    868         loc_server_unregister(srv);
     554        rc = loc_service_unregister(sid);
     555        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    869556}
    870557
    … …  
    880567        display_wnd_rsztype_t rsztype;
    881568        gfx_coord2_t pos;
    882         sysarg_t pos_id;
    883         loc_srv_t *srv;
    884 
    885         async_set_fallback_port_handler(test_display_conn, &resp);
    886 
    887         // FIXME This causes this test to be non-reentrant!
    888         rc = loc_server_register(test_display_server, &srv);
    889         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    890 
    891         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    892             &sid);
     569
     570        async_set_fallback_port_handler(test_display_conn, &resp);
     571
     572        // FIXME This causes this test to be non-reentrant!
     573        rc = loc_server_register(test_display_server);
     574        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     575
     576        rc = loc_service_register(test_display_svc, &sid);
    893577        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    894578
    … …  
    915599        pos.x = 42;
    916600        pos.y = 43;
    917         pos_id = 44;
    918 
    919         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     601
     602        rc = display_window_resize_req(wnd, rsztype, &pos);
    920603        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    921604        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    924607        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    925608        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    926         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    927609
    928610        display_window_destroy(wnd);
    929611        display_close(disp);
    930         rc = loc_service_unregister(srv, sid);
    931         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    932         loc_server_unregister(srv);
     612        rc = loc_service_unregister(sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    933614}
    934615
    … …  
    944625        display_wnd_rsztype_t rsztype;
    945626        gfx_coord2_t pos;
    946         sysarg_t pos_id;
    947         loc_srv_t *srv;
    948 
    949         async_set_fallback_port_handler(test_display_conn, &resp);
    950 
    951         // FIXME This causes this test to be non-reentrant!
    952         rc = loc_server_register(test_display_server, &srv);
    953         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    954 
    955         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    956             &sid);
     627
     628        async_set_fallback_port_handler(test_display_conn, &resp);
     629
     630        // FIXME This causes this test to be non-reentrant!
     631        rc = loc_server_register(test_display_server);
     632        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     633
     634        rc = loc_service_register(test_display_svc, &sid);
    957635        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    958636
    … …  
    979657        pos.x = 42;
    980658        pos.y = 43;
    981         pos_id = 44;
    982 
    983         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     659
     660        rc = display_window_resize_req(wnd, rsztype, &pos);
    984661        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    985662        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    988665        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    989666        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    990         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    991667
    992668        display_window_destroy(wnd);
    993669        display_close(disp);
    994         rc = loc_service_unregister(srv, sid);
    995         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    996         loc_server_unregister(srv);
     670        rc = loc_service_unregister(sid);
     671        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    997672}
    998673
    … …  
    1008683        gfx_rect_t nrect;
    1009684        test_response_t resp;
    1010         loc_srv_t *srv;
    1011 
    1012         async_set_fallback_port_handler(test_display_conn, &resp);
    1013 
    1014         // FIXME This causes this test to be non-reentrant!
    1015         rc = loc_server_register(test_display_server, &srv);
    1016         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1017 
    1018         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1019             &sid);
     685
     686        async_set_fallback_port_handler(test_display_conn, &resp);
     687
     688        // FIXME This causes this test to be non-reentrant!
     689        rc = loc_server_register(test_display_server);
     690        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     691
     692        rc = loc_service_register(test_display_svc, &sid);
    1020693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1021694
    … …  
    1058731        display_window_destroy(wnd);
    1059732        display_close(disp);
    1060         rc = loc_service_unregister(srv, sid);
    1061         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1062         loc_server_unregister(srv);
     733        rc = loc_service_unregister(sid);
     734        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1063735}
    1064736
    … …  
    1074746        gfx_rect_t nrect;
    1075747        test_response_t resp;
    1076         loc_srv_t *srv;
    1077 
    1078         async_set_fallback_port_handler(test_display_conn, &resp);
    1079 
    1080         // FIXME This causes this test to be non-reentrant!
    1081         rc = loc_server_register(test_display_server, &srv);
    1082         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1083 
    1084         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1085             &sid);
     748
     749        async_set_fallback_port_handler(test_display_conn, &resp);
     750
     751        // FIXME This causes this test to be non-reentrant!
     752        rc = loc_server_register(test_display_server);
     753        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     754
     755        rc = loc_service_register(test_display_svc, &sid);
    1086756        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1087757
    … …  
    1123793        display_window_destroy(wnd);
    1124794        display_close(disp);
    1125         rc = loc_service_unregister(srv, sid);
    1126         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1127         loc_server_unregister(srv);
    1128 }
    1129 
    1130 /** display_window_minimize() with server returning error response works. */
    1131 PCUT_TEST(window_minimize_failure)
    1132 {
    1133         errno_t rc;
    1134         service_id_t sid;
    1135         display_t *disp = NULL;
    1136         display_wnd_params_t params;
    1137         display_window_t *wnd;
    1138         test_response_t resp;
    1139         loc_srv_t *srv;
    1140 
    1141         async_set_fallback_port_handler(test_display_conn, &resp);
    1142 
    1143         // FIXME This causes this test to be non-reentrant!
    1144         rc = loc_server_register(test_display_server, &srv);
    1145         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1146 
    1147         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1148             &sid);
    1149         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1150 
    1151         rc = display_open(test_display_svc, &disp);
    1152         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1153         PCUT_ASSERT_NOT_NULL(disp);
    1154 
    1155         resp.rc = EOK;
    1156         display_wnd_params_init(&params);
    1157         params.rect.p0.x = 0;
    1158         params.rect.p0.y = 0;
    1159         params.rect.p0.x = 100;
    1160         params.rect.p0.y = 100;
    1161 
    1162         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1163             (void *) &resp, &wnd);
    1164         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1165         PCUT_ASSERT_NOT_NULL(wnd);
    1166 
    1167         resp.rc = EIO;
    1168         resp.window_minimize_called = false;
    1169 
    1170         rc = display_window_minimize(wnd);
    1171         PCUT_ASSERT_TRUE(resp.window_minimize_called);
    1172         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1173 
    1174         display_window_destroy(wnd);
    1175         display_close(disp);
    1176         rc = loc_service_unregister(srv, sid);
    1177         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1178         loc_server_unregister(srv);
    1179 }
    1180 
    1181 /** display_window_minimize() with server returning success response works. */
    1182 PCUT_TEST(window_minimize_success)
    1183 {
    1184         errno_t rc;
    1185         service_id_t sid;
    1186         display_t *disp = NULL;
    1187         display_wnd_params_t params;
    1188         display_window_t *wnd;
    1189         test_response_t resp;
    1190         loc_srv_t *srv;
    1191 
    1192         async_set_fallback_port_handler(test_display_conn, &resp);
    1193 
    1194         // FIXME This causes this test to be non-reentrant!
    1195         rc = loc_server_register(test_display_server, &srv);
    1196         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1197 
    1198         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1199             &sid);
    1200         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1201 
    1202         rc = display_open(test_display_svc, &disp);
    1203         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1204         PCUT_ASSERT_NOT_NULL(disp);
    1205 
    1206         resp.rc = EOK;
    1207         display_wnd_params_init(&params);
    1208         params.rect.p0.x = 0;
    1209         params.rect.p0.y = 0;
    1210         params.rect.p0.x = 100;
    1211         params.rect.p0.y = 100;
    1212 
    1213         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1214             (void *) &resp, &wnd);
    1215         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1216         PCUT_ASSERT_NOT_NULL(wnd);
    1217 
    1218         resp.rc = EOK;
    1219         resp.window_minimize_called = false;
    1220 
    1221         rc = display_window_minimize(wnd);
    1222         PCUT_ASSERT_TRUE(resp.window_minimize_called);
    1223         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1224 
    1225         display_window_destroy(wnd);
    1226         display_close(disp);
    1227         rc = loc_service_unregister(srv, sid);
    1228         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1229         loc_server_unregister(srv);
    1230 }
    1231 
    1232 /** display_window_maximize() with server returning error response works. */
    1233 PCUT_TEST(window_maximize_failure)
    1234 {
    1235         errno_t rc;
    1236         service_id_t sid;
    1237         display_t *disp = NULL;
    1238         display_wnd_params_t params;
    1239         display_window_t *wnd;
    1240         test_response_t resp;
    1241         loc_srv_t *srv;
    1242 
    1243         async_set_fallback_port_handler(test_display_conn, &resp);
    1244 
    1245         // FIXME This causes this test to be non-reentrant!
    1246         rc = loc_server_register(test_display_server, &srv);
    1247         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1248 
    1249         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1250             &sid);
    1251         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1252 
    1253         rc = display_open(test_display_svc, &disp);
    1254         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1255         PCUT_ASSERT_NOT_NULL(disp);
    1256 
    1257         resp.rc = EOK;
    1258         display_wnd_params_init(&params);
    1259         params.rect.p0.x = 0;
    1260         params.rect.p0.y = 0;
    1261         params.rect.p0.x = 100;
    1262         params.rect.p0.y = 100;
    1263 
    1264         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1265             (void *) &resp, &wnd);
    1266         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1267         PCUT_ASSERT_NOT_NULL(wnd);
    1268 
    1269         resp.rc = EIO;
    1270         resp.window_maximize_called = false;
    1271 
    1272         rc = display_window_maximize(wnd);
    1273         PCUT_ASSERT_TRUE(resp.window_maximize_called);
    1274         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1275 
    1276         display_window_destroy(wnd);
    1277         display_close(disp);
    1278         rc = loc_service_unregister(srv, sid);
    1279         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1280         loc_server_unregister(srv);
    1281 }
    1282 
    1283 /** display_window_maximize() with server returning success response works. */
    1284 PCUT_TEST(window_maximize_success)
    1285 {
    1286         errno_t rc;
    1287         service_id_t sid;
    1288         display_t *disp = NULL;
    1289         display_wnd_params_t params;
    1290         display_window_t *wnd;
    1291         test_response_t resp;
    1292         loc_srv_t *srv;
    1293 
    1294         async_set_fallback_port_handler(test_display_conn, &resp);
    1295 
    1296         // FIXME This causes this test to be non-reentrant!
    1297         rc = loc_server_register(test_display_server, &srv);
    1298         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1299 
    1300         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1301             &sid);
    1302         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1303 
    1304         rc = display_open(test_display_svc, &disp);
    1305         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1306         PCUT_ASSERT_NOT_NULL(disp);
    1307 
    1308         resp.rc = EOK;
    1309         display_wnd_params_init(&params);
    1310         params.rect.p0.x = 0;
    1311         params.rect.p0.y = 0;
    1312         params.rect.p0.x = 100;
    1313         params.rect.p0.y = 100;
    1314 
    1315         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1316             (void *) &resp, &wnd);
    1317         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1318         PCUT_ASSERT_NOT_NULL(wnd);
    1319 
    1320         resp.rc = EOK;
    1321         resp.window_maximize_called = false;
    1322 
    1323         rc = display_window_maximize(wnd);
    1324         PCUT_ASSERT_TRUE(resp.window_maximize_called);
    1325         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1326 
    1327         display_window_destroy(wnd);
    1328         display_close(disp);
    1329         rc = loc_service_unregister(srv, sid);
    1330         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1331         loc_server_unregister(srv);
     795        rc = loc_service_unregister(sid);
     796        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1332797}
    1333798
    … …  
    1341806        display_window_t *wnd;
    1342807        test_response_t resp;
    1343         loc_srv_t *srv;
    1344 
    1345         async_set_fallback_port_handler(test_display_conn, &resp);
    1346 
    1347         // FIXME This causes this test to be non-reentrant!
    1348         rc = loc_server_register(test_display_server, &srv);
    1349         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1350 
    1351         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1352             &sid);
     808
     809        async_set_fallback_port_handler(test_display_conn, &resp);
     810
     811        // FIXME This causes this test to be non-reentrant!
     812        rc = loc_server_register(test_display_server);
     813        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     814
     815        rc = loc_service_register(test_display_svc, &sid);
    1353816        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1354817
    … …  
    1380843        display_window_destroy(wnd);
    1381844        display_close(disp);
    1382         rc = loc_service_unregister(srv, sid);
    1383         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1384         loc_server_unregister(srv);
     845        rc = loc_service_unregister(sid);
     846        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1385847}
    1386848
    … …  
    1394856        display_window_t *wnd;
    1395857        test_response_t resp;
    1396         loc_srv_t *srv;
    1397 
    1398         async_set_fallback_port_handler(test_display_conn, &resp);
    1399 
    1400         // FIXME This causes this test to be non-reentrant!
    1401         rc = loc_server_register(test_display_server, &srv);
    1402         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1403 
    1404         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1405             &sid);
     858
     859        async_set_fallback_port_handler(test_display_conn, &resp);
     860
     861        // FIXME This causes this test to be non-reentrant!
     862        rc = loc_server_register(test_display_server);
     863        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     864
     865        rc = loc_service_register(test_display_svc, &sid);
    1406866        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1407867
    … …  
    1433893        display_window_destroy(wnd);
    1434894        display_close(disp);
    1435         rc = loc_service_unregister(srv, sid);
    1436         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1437         loc_server_unregister(srv);
    1438 }
    1439 
    1440 /** display_window_set_caption() with server returning error response works. */
    1441 PCUT_TEST(window_set_caption_failure)
    1442 {
    1443         errno_t rc;
    1444         service_id_t sid;
    1445         display_t *disp = NULL;
    1446         display_wnd_params_t params;
    1447         display_window_t *wnd;
    1448         const char *caption;
    1449         test_response_t resp;
    1450         loc_srv_t *srv;
    1451 
    1452         async_set_fallback_port_handler(test_display_conn, &resp);
    1453 
    1454         // FIXME This causes this test to be non-reentrant!
    1455         rc = loc_server_register(test_display_server, &srv);
    1456         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1457 
    1458         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1459             &sid);
    1460         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1461 
    1462         rc = display_open(test_display_svc, &disp);
    1463         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1464         PCUT_ASSERT_NOT_NULL(disp);
    1465 
    1466         resp.rc = EOK;
    1467         display_wnd_params_init(&params);
    1468         params.rect.p0.x = 0;
    1469         params.rect.p0.y = 0;
    1470         params.rect.p0.x = 100;
    1471         params.rect.p0.y = 100;
    1472 
    1473         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1474             (void *) &resp, &wnd);
    1475         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1476         PCUT_ASSERT_NOT_NULL(wnd);
    1477 
    1478         caption = "Hello";
    1479 
    1480         resp.rc = EIO;
    1481         resp.window_set_caption_called = false;
    1482 
    1483         rc = display_window_set_caption(wnd, caption);
    1484         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
    1485         PCUT_ASSERT_TRUE(resp.window_set_caption_called);
    1486         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1487         PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
    1488 
    1489         //free(resp.set_caption_caption);
    1490         display_window_destroy(wnd);
    1491         display_close(disp);
    1492         rc = loc_service_unregister(srv, sid);
    1493         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1494         loc_server_unregister(srv);
    1495 }
    1496 
    1497 /** display_window_set_caption() with server returning success response works. */
    1498 PCUT_TEST(window_set_caption_success)
    1499 {
    1500         errno_t rc;
    1501         service_id_t sid;
    1502         display_t *disp = NULL;
    1503         display_wnd_params_t params;
    1504         display_window_t *wnd;
    1505         const char *caption;
    1506         test_response_t resp;
    1507         loc_srv_t *srv;
    1508 
    1509         async_set_fallback_port_handler(test_display_conn, &resp);
    1510 
    1511         // FIXME This causes this test to be non-reentrant!
    1512         rc = loc_server_register(test_display_server, &srv);
    1513         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1514 
    1515         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1516             &sid);
    1517         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1518 
    1519         rc = display_open(test_display_svc, &disp);
    1520         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1521         PCUT_ASSERT_NOT_NULL(disp);
    1522 
    1523         resp.rc = EOK;
    1524         display_wnd_params_init(&params);
    1525         params.rect.p0.x = 0;
    1526         params.rect.p0.y = 0;
    1527         params.rect.p0.x = 100;
    1528         params.rect.p0.y = 100;
    1529 
    1530         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1531             (void *) &resp, &wnd);
    1532         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1533         PCUT_ASSERT_NOT_NULL(wnd);
    1534 
    1535         caption = "Hello";
    1536 
    1537         resp.rc = EOK;
    1538         resp.window_set_caption_called = false;
    1539 
    1540         rc = display_window_set_caption(wnd, caption);
    1541         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
    1542         PCUT_ASSERT_TRUE(resp.window_set_caption_called);
    1543         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1544         PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
    1545 
    1546         //free(resp.set_caption_caption);
    1547         display_window_destroy(wnd);
    1548         display_close(disp);
    1549         rc = loc_service_unregister(srv, sid);
    1550         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1551         loc_server_unregister(srv);
     895        rc = loc_service_unregister(sid);
     896        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1552897}
    1553898
    … …  
    1562907        test_response_t resp;
    1563908        gfx_context_t *gc;
    1564         loc_srv_t *srv;
    1565 
    1566         async_set_fallback_port_handler(test_display_conn, &resp);
    1567 
    1568         // FIXME This causes this test to be non-reentrant!
    1569         rc = loc_server_register(test_display_server, &srv);
    1570         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1571 
    1572         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1573             &sid);
     909
     910        async_set_fallback_port_handler(test_display_conn, &resp);
     911
     912        // FIXME This causes this test to be non-reentrant!
     913        rc = loc_server_register(test_display_server);
     914        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     915
     916        rc = loc_service_register(test_display_svc, &sid);
    1574917        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1575918
    … …  
    1594937        resp.rc = ENOMEM;
    1595938        rc = display_window_get_gc(wnd, &gc);
    1596         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     939        /* async_connect_me_to() does not return specific error */
     940        PCUT_ASSERT_ERRNO_VAL(EIO, rc);
    1597941        PCUT_ASSERT_NULL(gc);
    1598942
    … …  
    1602946
    1603947        display_close(disp);
    1604         rc = loc_service_unregister(srv, sid);
    1605         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1606         loc_server_unregister(srv);
     948        rc = loc_service_unregister(sid);
     949        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1607950}
    1608951
    … …  
    1618961        gfx_context_t *gc;
    1619962        gfx_color_t *color;
    1620         loc_srv_t *srv;
    1621 
    1622         async_set_fallback_port_handler(test_display_conn, &resp);
    1623 
    1624         // FIXME This causes this test to be non-reentrant!
    1625         rc = loc_server_register(test_display_server, &srv);
    1626         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1627 
    1628         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1629             &sid);
     963
     964        async_set_fallback_port_handler(test_display_conn, &resp);
     965
     966        // FIXME This causes this test to be non-reentrant!
     967        rc = loc_server_register(test_display_server);
     968        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     969
     970        rc = loc_service_register(test_display_svc, &sid);
    1630971        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1631972
    … …  
    16661007
    16671008        display_close(disp);
    1668         rc = loc_service_unregister(srv, sid);
    1669         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1670         loc_server_unregister(srv);
     1009        rc = loc_service_unregister(sid);
     1010        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16711011}
    16721012
    … …  
    16801020        display_window_t *wnd;
    16811021        test_response_t resp;
    1682         loc_srv_t *srv;
    1683 
    1684         async_set_fallback_port_handler(test_display_conn, &resp);
    1685 
    1686         // FIXME This causes this test to be non-reentrant!
    1687         rc = loc_server_register(test_display_server, &srv);
    1688         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1689 
    1690         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1691             &sid);
     1022
     1023        async_set_fallback_port_handler(test_display_conn, &resp);
     1024
     1025        // FIXME This causes this test to be non-reentrant!
     1026        rc = loc_server_register(test_display_server);
     1027        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1028
     1029        rc = loc_service_register(test_display_svc, &sid);
    16921030        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16931031
    … …  
    17341072        display_close(disp);
    17351073
    1736         rc = loc_service_unregister(srv, sid);
    1737         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1738         loc_server_unregister(srv);
     1074        rc = loc_service_unregister(sid);
     1075        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17391076}
    17401077
    … …  
    17481085        display_window_t *wnd;
    17491086        test_response_t resp;
    1750         loc_srv_t *srv;
    1751 
    1752         async_set_fallback_port_handler(test_display_conn, &resp);
    1753 
    1754         // FIXME This causes this test to be non-reentrant!
    1755         rc = loc_server_register(test_display_server, &srv);
    1756         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1757 
    1758         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1759             &sid);
     1087
     1088        async_set_fallback_port_handler(test_display_conn, &resp);
     1089
     1090        // FIXME This causes this test to be non-reentrant!
     1091        rc = loc_server_register(test_display_server);
     1092        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1093
     1094        rc = loc_service_register(test_display_svc, &sid);
    17601095        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17611096
    … …  
    17801115        resp.event_cnt = 1;
    17811116        resp.event.etype = wev_focus;
    1782         resp.event.ev.focus.nfocus = 42;
    17831117        resp.wnd_id = wnd->id;
    17841118        resp.focus_event_called = false;
    … …  
    17971131        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    17981132            resp.revent.etype);
    1799         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    1800             resp.revent.ev.focus.nfocus);
    18011133
    18021134        rc = display_window_destroy(wnd);
    … …  
    18051137        display_close(disp);
    18061138
    1807         rc = loc_service_unregister(srv, sid);
    1808         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1809         loc_server_unregister(srv);
     1139        rc = loc_service_unregister(sid);
     1140        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18101141}
    18111142
    … …  
    18191150        display_window_t *wnd;
    18201151        test_response_t resp;
    1821         loc_srv_t *srv;
    1822 
    1823         async_set_fallback_port_handler(test_display_conn, &resp);
    1824 
    1825         // FIXME This causes this test to be non-reentrant!
    1826         rc = loc_server_register(test_display_server, &srv);
    1827         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1828 
    1829         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1830             &sid);
     1152
     1153        async_set_fallback_port_handler(test_display_conn, &resp);
     1154
     1155        // FIXME This causes this test to be non-reentrant!
     1156        rc = loc_server_register(test_display_server);
     1157        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1158
     1159        rc = loc_service_register(test_display_svc, &sid);
    18311160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18321161
    … …  
    18851214        display_close(disp);
    18861215
    1887         rc = loc_service_unregister(srv, sid);
    1888         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1889         loc_server_unregister(srv);
     1216        rc = loc_service_unregister(sid);
     1217        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18901218}
    18911219
    … …  
    18991227        display_window_t *wnd;
    19001228        test_response_t resp;
    1901         loc_srv_t *srv;
    1902 
    1903         async_set_fallback_port_handler(test_display_conn, &resp);
    1904 
    1905         // FIXME This causes this test to be non-reentrant!
    1906         rc = loc_server_register(test_display_server, &srv);
    1907         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1908 
    1909         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1910             &sid);
     1229
     1230        async_set_fallback_port_handler(test_display_conn, &resp);
     1231
     1232        // FIXME This causes this test to be non-reentrant!
     1233        rc = loc_server_register(test_display_server);
     1234        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1235
     1236        rc = loc_service_register(test_display_svc, &sid);
    19111237        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19121238
    … …  
    19651291        display_close(disp);
    19661292
    1967         rc = loc_service_unregister(srv, sid);
    1968         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1969         loc_server_unregister(srv);
     1293        rc = loc_service_unregister(sid);
     1294        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19701295}
    19711296
    … …  
    19791304        display_window_t *wnd;
    19801305        test_response_t resp;
    1981         loc_srv_t *srv;
    1982 
    1983         async_set_fallback_port_handler(test_display_conn, &resp);
    1984 
    1985         // FIXME This causes this test to be non-reentrant!
    1986         rc = loc_server_register(test_display_server, &srv);
    1987         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1988 
    1989         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    1990             &sid);
     1306
     1307        async_set_fallback_port_handler(test_display_conn, &resp);
     1308
     1309        // FIXME This causes this test to be non-reentrant!
     1310        rc = loc_server_register(test_display_server);
     1311        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1312
     1313        rc = loc_service_register(test_display_svc, &sid);
    19911314        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19921315
    … …  
    20111334        resp.event_cnt = 1;
    20121335        resp.event.etype = wev_unfocus;
    2013         resp.event.ev.unfocus.nfocus = 42;
    20141336        resp.wnd_id = wnd->id;
    20151337        resp.unfocus_event_called = false;
    … …  
    20281350        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    20291351            resp.revent.etype);
    2030         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    2031             resp.revent.ev.focus.nfocus);
    20321352
    20331353        rc = display_window_destroy(wnd);
    … …  
    20361356        display_close(disp);
    20371357
    2038         rc = loc_service_unregister(srv, sid);
    2039         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2040         loc_server_unregister(srv);
     1358        rc = loc_service_unregister(sid);
     1359        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20411360}
    20421361
    … …  
    20491368        display_info_t info;
    20501369        test_response_t resp;
    2051         loc_srv_t *srv;
    2052 
    2053         async_set_fallback_port_handler(test_display_conn, &resp);
    2054 
    2055         // FIXME This causes this test to be non-reentrant!
    2056         rc = loc_server_register(test_display_server, &srv);
    2057         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2058 
    2059         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    2060             &sid);
     1370
     1371        async_set_fallback_port_handler(test_display_conn, &resp);
     1372
     1373        // FIXME This causes this test to be non-reentrant!
     1374        rc = loc_server_register(test_display_server);
     1375        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1376
     1377        rc = loc_service_register(test_display_svc, &sid);
    20611378        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20621379
    … …  
    20731390
    20741391        display_close(disp);
    2075         rc = loc_service_unregister(srv, sid);
    2076         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2077         loc_server_unregister(srv);
     1392        rc = loc_service_unregister(sid);
     1393        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20781394}
    20791395
    … …  
    20861402        display_info_t info;
    20871403        test_response_t resp;
    2088         loc_srv_t *srv;
    2089 
    2090         async_set_fallback_port_handler(test_display_conn, &resp);
    2091 
    2092         // FIXME This causes this test to be non-reentrant!
    2093         rc = loc_server_register(test_display_server, &srv);
    2094         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2095 
    2096         rc = loc_service_register(srv, test_display_svc, fallback_port_id,
    2097             &sid);
     1404
     1405        async_set_fallback_port_handler(test_display_conn, &resp);
     1406
     1407        // FIXME This causes this test to be non-reentrant!
     1408        rc = loc_server_register(test_display_server);
     1409        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1410
     1411        rc = loc_service_register(test_display_svc, &sid);
    20981412        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20991413
    … …  
    21181432
    21191433        display_close(disp);
    2120         rc = loc_service_unregister(srv, sid);
    2121         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2122         loc_server_unregister(srv);
     1434        rc = loc_service_unregister(sid);
     1435        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    21231436}
    21241437
    … …  
    21821495}
    21831496
    2184 static void test_focus_event(void *arg, unsigned nfocus)
     1497static void test_focus_event(void *arg)
    21851498{
    21861499        test_response_t *resp = (test_response_t *) arg;
    21871500
    21881501        resp->revent.etype = wev_focus;
    2189         resp->revent.ev.focus.nfocus = nfocus;
    21901502
    21911503        fibril_mutex_lock(&resp->event_lock);
    … …  
    22211533}
    22221534
    2223 static void test_unfocus_event(void *arg, unsigned nfocus)
     1535static void test_unfocus_event(void *arg)
    22241536{
    22251537        test_response_t *resp = (test_response_t *) arg;
    22261538
    22271539        resp->revent.etype = wev_unfocus;
    2228         resp->revent.ev.unfocus.nfocus = nfocus;
    22291540
    22301541        fibril_mutex_lock(&resp->event_lock);
    … …  
    22421553        resp->create_rect = params->rect;
    22431554        resp->create_min_size = params->min_size;
    2244         resp->create_idev_id = params->idev_id;
    22451555        if (resp->rc == EOK)
    22461556                *rwnd_id = resp->wnd_id;
    … …  
    22591569
    22601570static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    2261     gfx_coord2_t *pos, sysarg_t pos_id)
     1571    gfx_coord2_t *pos)
    22621572{
    22631573        test_response_t *resp = (test_response_t *) arg;
    … …  
    22661576        resp->move_req_wnd_id = wnd_id;
    22671577        resp->move_req_pos = *pos;
    2268         resp->move_req_pos_id = pos_id;
    22691578        return resp->rc;
    22701579}
    … …  
    22801589}
    22811590
    2282 static errno_t test_window_get_pos(void *arg, sysarg_t wnd_id, gfx_coord2_t *dpos)
    2283 {
    2284         test_response_t *resp = (test_response_t *) arg;
    2285 
    2286         resp->window_get_pos_called = true;
    2287         resp->get_pos_wnd_id = wnd_id;
    2288 
    2289         if (resp->rc == EOK)
    2290                 *dpos = resp->get_pos_rpos;
    2291 
    2292         return resp->rc;
    2293 }
    2294 
    2295 static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id,
    2296     gfx_rect_t *rect)
    2297 {
    2298         test_response_t *resp = (test_response_t *) arg;
    2299 
    2300         resp->window_get_max_rect_called = true;
    2301         resp->get_max_rect_wnd_id = wnd_id;
    2302 
    2303         if (resp->rc == EOK)
    2304                 *rect = resp->get_max_rect_rrect;
    2305 
    2306         return resp->rc;
    2307 }
    2308 
    23091591static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    2310     display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
     1592    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
    23111593{
    23121594        test_response_t *resp = (test_response_t *) arg;
    … …  
    23161598        resp->resize_req_wnd_id = wnd_id;
    23171599        resp->resize_req_pos = *pos;
    2318         resp->resize_req_pos_id = pos_id;
    23191600        return resp->rc;
    23201601}
    … …  
    23321613}
    23331614
    2334 static errno_t test_window_minimize(void *arg, sysarg_t wnd_id)
    2335 {
    2336         test_response_t *resp = (test_response_t *) arg;
    2337 
    2338         resp->window_minimize_called = true;
    2339         resp->resize_wnd_id = wnd_id;
    2340         return resp->rc;
    2341 }
    2342 
    2343 static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
    2344 {
    2345         test_response_t *resp = (test_response_t *) arg;
    2346 
    2347         resp->window_maximize_called = true;
    2348         resp->resize_wnd_id = wnd_id;
    2349         return resp->rc;
    2350 }
    2351 
    2352 static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id)
    2353 {
    2354         test_response_t *resp = (test_response_t *) arg;
    2355 
    2356         resp->window_unmaximize_called = true;
    2357         resp->resize_wnd_id = wnd_id;
    2358         return resp->rc;
    2359 }
    2360 
    23611615static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    23621616    display_stock_cursor_t cursor)
    … …  
    23671621        resp->set_cursor_wnd_id = wnd_id;
    23681622        resp->set_cursor_cursor = cursor;
    2369 
    2370         return resp->rc;
    2371 }
    2372 
    2373 static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id,
    2374     const char *caption)
    2375 {
    2376         test_response_t *resp = (test_response_t *) arg;
    2377 
    2378         resp->window_set_caption_called = true;
    2379         resp->set_caption_wnd_id = wnd_id;
    2380         resp->set_caption_caption = str_dup(caption);
    23811623
    23821624        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.