Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rca48672 rc9927c66  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
     2 * Copyright (c) 2021 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 *);
    6261static 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 *);
    6462static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
    65     gfx_coord2_t *, sysarg_t);
     63    gfx_coord2_t *);
    6664static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6765    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);
    7166static 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 *);
    7367static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    7468static errno_t test_get_info(void *, display_info_t *);
    … …  
    8276        .window_move = test_window_move,
    8377        .window_get_pos = test_window_get_pos,
    84         .window_get_max_rect = test_window_get_max_rect,
    8578        .window_resize_req = test_window_resize_req,
    8679        .window_resize = test_window_resize,
    87         .window_minimize = test_window_minimize,
    88         .window_maximize = test_window_maximize,
    89         .window_unmaximize = test_window_unmaximize,
    9080        .window_set_cursor = test_window_set_cursor,
    91         .window_set_caption = test_window_set_caption,
    9281        .get_event = test_get_event,
    9382        .get_info = test_get_info
    … …  
    118107        gfx_rect_t create_rect;
    119108        gfx_coord2_t create_min_size;
    120         sysarg_t create_idev_id;
    121109        bool window_destroy_called;
    122110        sysarg_t destroy_wnd_id;
    … …  
    125113        sysarg_t move_req_wnd_id;
    126114        gfx_coord2_t move_req_pos;
    127         sysarg_t move_req_pos_id;
    128115
    129116        bool window_move_called;
    … …  
    134121        sysarg_t get_pos_wnd_id;
    135122        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;
    140123
    141124        bool window_resize_req_called;
    … …  
    143126        display_wnd_rsztype_t resize_req_rsztype;
    144127        gfx_coord2_t resize_req_pos;
    145         sysarg_t resize_req_pos_id;
    146128
    147129        bool window_resize_called;
    … …  
    150132        sysarg_t resize_wnd_id;
    151133
    152         bool window_minimize_called;
    153         bool window_maximize_called;
    154         bool window_unmaximize_called;
    155 
    156134        bool window_set_cursor_called;
    157135        sysarg_t set_cursor_wnd_id;
    158136        display_stock_cursor_t set_cursor_cursor;
    159137
    160         bool window_set_caption_called;
    161         sysarg_t set_caption_wnd_id;
    162         char *set_caption_caption;
    163 
    164138        bool get_event_called;
    165139
    … …  
    169143        bool set_color_called;
    170144        bool close_event_called;
    171 
    172145        bool focus_event_called;
    173146        bool kbd_event_called;
    … …  
    186159        display_t *disp = NULL;
    187160        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);
     161
     162        async_set_fallback_port_handler(test_display_conn, &resp);
     163
     164        // FIXME This causes this test to be non-reentrant!
     165        rc = loc_server_register(test_display_server);
     166        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     167
     168        rc = loc_service_register(test_display_svc, &sid);
     169        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     170
     171        rc = display_open(test_display_svc, &disp);
     172        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     173        PCUT_ASSERT_NOT_NULL(disp);
     174
     175        display_close(disp);
     176        rc = loc_service_unregister(sid);
     177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    208178}
    209179
    … …  
    217187        display_window_t *wnd;
    218188        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);
     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);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195
     196        rc = loc_service_register(test_display_svc, &sid);
    229197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    230198
    … …  
    243211        params.min_size.x = 11;
    244212        params.min_size.y = 12;
    245         params.idev_id = 42;
    246213
    247214        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    254221        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    255222        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
    256         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    257223        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    258224        PCUT_ASSERT_NULL(wnd);
    259225
    260226        display_close(disp);
    261         rc = loc_service_unregister(srv, sid);
    262         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    263         loc_server_unregister(srv);
     227        rc = loc_service_unregister(sid);
     228        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    264229}
    265230
    … …  
    276241        display_window_t *wnd;
    277242        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);
     243
     244        async_set_fallback_port_handler(test_display_conn, &resp);
     245
     246        // FIXME This causes this test to be non-reentrant!
     247        rc = loc_server_register(test_display_server);
     248        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     249
     250        rc = loc_service_register(test_display_svc, &sid);
    288251        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    289252
    … …  
    300263        params.rect.p0.x = 100;
    301264        params.rect.p0.y = 100;
    302         params.idev_id = 42;
    303265
    304266        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    309271        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    310272        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
    311         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    312273        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    313274        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    320281
    321282        display_close(disp);
    322         rc = loc_service_unregister(srv, sid);
    323         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    324         loc_server_unregister(srv);
     283        rc = loc_service_unregister(sid);
     284        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    325285}
    326286
    … …  
    334294        display_window_t *wnd;
    335295        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);
     296
     297        async_set_fallback_port_handler(test_display_conn, &resp);
     298
     299        // FIXME This causes this test to be non-reentrant!
     300        rc = loc_server_register(test_display_server);
     301        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     302
     303        rc = loc_service_register(test_display_svc, &sid);
    346304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    347305
    … …  
    376334
    377335        display_close(disp);
    378         rc = loc_service_unregister(srv, sid);
    379         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    380         loc_server_unregister(srv);
     336        rc = loc_service_unregister(sid);
     337        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    381338}
    382339
    … …  
    397354        test_response_t resp;
    398355        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);
     356
     357        async_set_fallback_port_handler(test_display_conn, &resp);
     358
     359        // FIXME This causes this test to be non-reentrant!
     360        rc = loc_server_register(test_display_server);
     361        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     362
     363        rc = loc_service_register(test_display_svc, &sid);
    410364        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    411365
    … …  
    431385        pos.x = 42;
    432386        pos.y = 43;
    433         pos_id = 44;
    434 
    435         rc = display_window_move_req(wnd, &pos, pos_id);
     387
     388        rc = display_window_move_req(wnd, &pos);
    436389        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    437390        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    439392        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    440393        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    441         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    442394
    443395        display_window_destroy(wnd);
    444396        display_close(disp);
    445         rc = loc_service_unregister(srv, sid);
    446         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    447         loc_server_unregister(srv);
     397        rc = loc_service_unregister(sid);
     398        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    448399}
    449400
    … …  
    458409        test_response_t resp;
    459410        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);
     411
     412        async_set_fallback_port_handler(test_display_conn, &resp);
     413
     414        // FIXME This causes this test to be non-reentrant!
     415        rc = loc_server_register(test_display_server);
     416        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     417
     418        rc = loc_service_register(test_display_svc, &sid);
    471419        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    472420
    … …  
    492440        pos.x = 42;
    493441        pos.y = 43;
    494         pos_id = 44;
    495 
    496         rc = display_window_move_req(wnd, &pos, pos_id);
     442
     443        rc = display_window_move_req(wnd, &pos);
    497444        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    498445        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    500447        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    501448        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    502         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    503449
    504450        display_window_destroy(wnd);
    505451        display_close(disp);
    506         rc = loc_service_unregister(srv, sid);
    507         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    508         loc_server_unregister(srv);
     452        rc = loc_service_unregister(sid);
     453        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    509454}
    510455
    … …  
    519464        gfx_coord2_t dpos;
    520465        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);
     466
     467        async_set_fallback_port_handler(test_display_conn, &resp);
     468
     469        // FIXME This causes this test to be non-reentrant!
     470        rc = loc_server_register(test_display_server);
     471        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     472
     473        rc = loc_service_register(test_display_svc, &sid);
    531474        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    532475
    … …  
    561504        display_window_destroy(wnd);
    562505        display_close(disp);
    563         rc = loc_service_unregister(srv, sid);
    564         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    565         loc_server_unregister(srv);
     506        rc = loc_service_unregister(sid);
     507        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    566508}
    567509
    … …  
    576518        gfx_coord2_t dpos;
    577519        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);
     520
     521        async_set_fallback_port_handler(test_display_conn, &resp);
     522
     523        // FIXME This causes this test to be non-reentrant!
     524        rc = loc_server_register(test_display_server);
     525        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     526
     527        rc = loc_service_register(test_display_svc, &sid);
    588528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    589529
    … …  
    618558        display_window_destroy(wnd);
    619559        display_close(disp);
    620         rc = loc_service_unregister(srv, sid);
    621         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    622         loc_server_unregister(srv);
     560        rc = loc_service_unregister(sid);
     561        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    623562}
    624563
    … …  
    633572        gfx_coord2_t dpos;
    634573        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);
     574
     575        async_set_fallback_port_handler(test_display_conn, &resp);
     576
     577        // FIXME This causes this test to be non-reentrant!
     578        rc = loc_server_register(test_display_server);
     579        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     580
     581        rc = loc_service_register(test_display_svc, &sid);
    645582        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    646583
    … …  
    676613        display_window_destroy(wnd);
    677614        display_close(disp);
    678         rc = loc_service_unregister(srv, sid);
    679         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    680         loc_server_unregister(srv);
     615        rc = loc_service_unregister(sid);
     616        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681617}
    682618
    … …  
    691627        gfx_coord2_t dpos;
    692628        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);
     629
     630        async_set_fallback_port_handler(test_display_conn, &resp);
     631
     632        // FIXME This causes this test to be non-reentrant!
     633        rc = loc_server_register(test_display_server);
     634        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     635
     636        rc = loc_service_register(test_display_svc, &sid);
    703637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    704638
    … …  
    736670        display_window_destroy(wnd);
    737671        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);
     672        rc = loc_service_unregister(sid);
     673        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    869674}
    870675
    … …  
    880685        display_wnd_rsztype_t rsztype;
    881686        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);
     687
     688        async_set_fallback_port_handler(test_display_conn, &resp);
     689
     690        // FIXME This causes this test to be non-reentrant!
     691        rc = loc_server_register(test_display_server);
     692        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     693
     694        rc = loc_service_register(test_display_svc, &sid);
    893695        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    894696
    … …  
    915717        pos.x = 42;
    916718        pos.y = 43;
    917         pos_id = 44;
    918 
    919         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     719
     720        rc = display_window_resize_req(wnd, rsztype, &pos);
    920721        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    921722        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    924725        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    925726        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    926         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    927727
    928728        display_window_destroy(wnd);
    929729        display_close(disp);
    930         rc = loc_service_unregister(srv, sid);
    931         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    932         loc_server_unregister(srv);
     730        rc = loc_service_unregister(sid);
     731        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    933732}
    934733
    … …  
    944743        display_wnd_rsztype_t rsztype;
    945744        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);
     745
     746        async_set_fallback_port_handler(test_display_conn, &resp);
     747
     748        // FIXME This causes this test to be non-reentrant!
     749        rc = loc_server_register(test_display_server);
     750        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     751
     752        rc = loc_service_register(test_display_svc, &sid);
    957753        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    958754
    … …  
    979775        pos.x = 42;
    980776        pos.y = 43;
    981         pos_id = 44;
    982 
    983         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     777
     778        rc = display_window_resize_req(wnd, rsztype, &pos);
    984779        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    985780        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    988783        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    989784        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    990         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    991785
    992786        display_window_destroy(wnd);
    993787        display_close(disp);
    994         rc = loc_service_unregister(srv, sid);
    995         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    996         loc_server_unregister(srv);
     788        rc = loc_service_unregister(sid);
     789        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    997790}
    998791
    … …  
    1008801        gfx_rect_t nrect;
    1009802        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);
     803
     804        async_set_fallback_port_handler(test_display_conn, &resp);
     805
     806        // FIXME This causes this test to be non-reentrant!
     807        rc = loc_server_register(test_display_server);
     808        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     809
     810        rc = loc_service_register(test_display_svc, &sid);
    1020811        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1021812
    … …  
    1058849        display_window_destroy(wnd);
    1059850        display_close(disp);
    1060         rc = loc_service_unregister(srv, sid);
    1061         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1062         loc_server_unregister(srv);
     851        rc = loc_service_unregister(sid);
     852        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1063853}
    1064854
    … …  
    1074864        gfx_rect_t nrect;
    1075865        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);
     866
     867        async_set_fallback_port_handler(test_display_conn, &resp);
     868
     869        // FIXME This causes this test to be non-reentrant!
     870        rc = loc_server_register(test_display_server);
     871        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     872
     873        rc = loc_service_register(test_display_svc, &sid);
    1086874        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1087875
    … …  
    1123911        display_window_destroy(wnd);
    1124912        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);
     913        rc = loc_service_unregister(sid);
     914        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1332915}
    1333916
    … …  
    1341924        display_window_t *wnd;
    1342925        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);
     926
     927        async_set_fallback_port_handler(test_display_conn, &resp);
     928
     929        // FIXME This causes this test to be non-reentrant!
     930        rc = loc_server_register(test_display_server);
     931        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     932
     933        rc = loc_service_register(test_display_svc, &sid);
    1353934        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1354935
    … …  
    1380961        display_window_destroy(wnd);
    1381962        display_close(disp);
    1382         rc = loc_service_unregister(srv, sid);
    1383         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1384         loc_server_unregister(srv);
     963        rc = loc_service_unregister(sid);
     964        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1385965}
    1386966
    … …  
    1394974        display_window_t *wnd;
    1395975        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);
     976
     977        async_set_fallback_port_handler(test_display_conn, &resp);
     978
     979        // FIXME This causes this test to be non-reentrant!
     980        rc = loc_server_register(test_display_server);
     981        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     982
     983        rc = loc_service_register(test_display_svc, &sid);
    1406984        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1407985
    … …  
    14331011        display_window_destroy(wnd);
    14341012        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);
     1013        rc = loc_service_unregister(sid);
     1014        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15521015}
    15531016
    … …  
    15621025        test_response_t resp;
    15631026        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);
     1027
     1028        async_set_fallback_port_handler(test_display_conn, &resp);
     1029
     1030        // FIXME This causes this test to be non-reentrant!
     1031        rc = loc_server_register(test_display_server);
     1032        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1033
     1034        rc = loc_service_register(test_display_svc, &sid);
    15741035        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15751036
    … …  
    16021063
    16031064        display_close(disp);
    1604         rc = loc_service_unregister(srv, sid);
    1605         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1606         loc_server_unregister(srv);
     1065        rc = loc_service_unregister(sid);
     1066        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16071067}
    16081068
    … …  
    16181078        gfx_context_t *gc;
    16191079        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);
     1080
     1081        async_set_fallback_port_handler(test_display_conn, &resp);
     1082
     1083        // FIXME This causes this test to be non-reentrant!
     1084        rc = loc_server_register(test_display_server);
     1085        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1086
     1087        rc = loc_service_register(test_display_svc, &sid);
    16301088        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16311089
    … …  
    16661124
    16671125        display_close(disp);
    1668         rc = loc_service_unregister(srv, sid);
    1669         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1670         loc_server_unregister(srv);
     1126        rc = loc_service_unregister(sid);
     1127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16711128}
    16721129
    … …  
    16801137        display_window_t *wnd;
    16811138        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);
     1139
     1140        async_set_fallback_port_handler(test_display_conn, &resp);
     1141
     1142        // FIXME This causes this test to be non-reentrant!
     1143        rc = loc_server_register(test_display_server);
     1144        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1145
     1146        rc = loc_service_register(test_display_svc, &sid);
    16921147        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16931148
    … …  
    17341189        display_close(disp);
    17351190
    1736         rc = loc_service_unregister(srv, sid);
    1737         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1738         loc_server_unregister(srv);
     1191        rc = loc_service_unregister(sid);
     1192        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17391193}
    17401194
    … …  
    17481202        display_window_t *wnd;
    17491203        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);
     1204
     1205        async_set_fallback_port_handler(test_display_conn, &resp);
     1206
     1207        // FIXME This causes this test to be non-reentrant!
     1208        rc = loc_server_register(test_display_server);
     1209        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1210
     1211        rc = loc_service_register(test_display_svc, &sid);
    17601212        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17611213
    … …  
    17801232        resp.event_cnt = 1;
    17811233        resp.event.etype = wev_focus;
    1782         resp.event.ev.focus.nfocus = 42;
    17831234        resp.wnd_id = wnd->id;
    17841235        resp.focus_event_called = false;
    … …  
    17971248        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    17981249            resp.revent.etype);
    1799         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    1800             resp.revent.ev.focus.nfocus);
    18011250
    18021251        rc = display_window_destroy(wnd);
    … …  
    18051254        display_close(disp);
    18061255
    1807         rc = loc_service_unregister(srv, sid);
    1808         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1809         loc_server_unregister(srv);
     1256        rc = loc_service_unregister(sid);
     1257        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18101258}
    18111259
    … …  
    18191267        display_window_t *wnd;
    18201268        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);
     1269
     1270        async_set_fallback_port_handler(test_display_conn, &resp);
     1271
     1272        // FIXME This causes this test to be non-reentrant!
     1273        rc = loc_server_register(test_display_server);
     1274        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1275
     1276        rc = loc_service_register(test_display_svc, &sid);
    18311277        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18321278
    … …  
    18851331        display_close(disp);
    18861332
    1887         rc = loc_service_unregister(srv, sid);
    1888         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1889         loc_server_unregister(srv);
     1333        rc = loc_service_unregister(sid);
     1334        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18901335}
    18911336
    … …  
    18991344        display_window_t *wnd;
    19001345        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);
     1346
     1347        async_set_fallback_port_handler(test_display_conn, &resp);
     1348
     1349        // FIXME This causes this test to be non-reentrant!
     1350        rc = loc_server_register(test_display_server);
     1351        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1352
     1353        rc = loc_service_register(test_display_svc, &sid);
    19111354        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19121355
    … …  
    19651408        display_close(disp);
    19661409
    1967         rc = loc_service_unregister(srv, sid);
    1968         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1969         loc_server_unregister(srv);
     1410        rc = loc_service_unregister(sid);
     1411        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19701412}
    19711413
    … …  
    19791421        display_window_t *wnd;
    19801422        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);
     1423
     1424        async_set_fallback_port_handler(test_display_conn, &resp);
     1425
     1426        // FIXME This causes this test to be non-reentrant!
     1427        rc = loc_server_register(test_display_server);
     1428        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1429
     1430        rc = loc_service_register(test_display_svc, &sid);
    19911431        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19921432
    … …  
    20111451        resp.event_cnt = 1;
    20121452        resp.event.etype = wev_unfocus;
    2013         resp.event.ev.unfocus.nfocus = 42;
    20141453        resp.wnd_id = wnd->id;
    20151454        resp.unfocus_event_called = false;
    … …  
    20281467        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    20291468            resp.revent.etype);
    2030         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    2031             resp.revent.ev.focus.nfocus);
    20321469
    20331470        rc = display_window_destroy(wnd);
    … …  
    20361473        display_close(disp);
    20371474
    2038         rc = loc_service_unregister(srv, sid);
    2039         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2040         loc_server_unregister(srv);
     1475        rc = loc_service_unregister(sid);
     1476        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20411477}
    20421478
    … …  
    20491485        display_info_t info;
    20501486        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);
     1487
     1488        async_set_fallback_port_handler(test_display_conn, &resp);
     1489
     1490        // FIXME This causes this test to be non-reentrant!
     1491        rc = loc_server_register(test_display_server);
     1492        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1493
     1494        rc = loc_service_register(test_display_svc, &sid);
    20611495        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20621496
    … …  
    20731507
    20741508        display_close(disp);
    2075         rc = loc_service_unregister(srv, sid);
    2076         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2077         loc_server_unregister(srv);
     1509        rc = loc_service_unregister(sid);
     1510        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20781511}
    20791512
    … …  
    20861519        display_info_t info;
    20871520        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);
     1521
     1522        async_set_fallback_port_handler(test_display_conn, &resp);
     1523
     1524        // FIXME This causes this test to be non-reentrant!
     1525        rc = loc_server_register(test_display_server);
     1526        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1527
     1528        rc = loc_service_register(test_display_svc, &sid);
    20981529        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20991530
    … …  
    21181549
    21191550        display_close(disp);
    2120         rc = loc_service_unregister(srv, sid);
    2121         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2122         loc_server_unregister(srv);
     1551        rc = loc_service_unregister(sid);
     1552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    21231553}
    21241554
    … …  
    21821612}
    21831613
    2184 static void test_focus_event(void *arg, unsigned nfocus)
     1614static void test_focus_event(void *arg)
    21851615{
    21861616        test_response_t *resp = (test_response_t *) arg;
    21871617
    21881618        resp->revent.etype = wev_focus;
    2189         resp->revent.ev.focus.nfocus = nfocus;
    21901619
    21911620        fibril_mutex_lock(&resp->event_lock);
    … …  
    22211650}
    22221651
    2223 static void test_unfocus_event(void *arg, unsigned nfocus)
     1652static void test_unfocus_event(void *arg)
    22241653{
    22251654        test_response_t *resp = (test_response_t *) arg;
    22261655
    22271656        resp->revent.etype = wev_unfocus;
    2228         resp->revent.ev.unfocus.nfocus = nfocus;
    22291657
    22301658        fibril_mutex_lock(&resp->event_lock);
    … …  
    22421670        resp->create_rect = params->rect;
    22431671        resp->create_min_size = params->min_size;
    2244         resp->create_idev_id = params->idev_id;
    22451672        if (resp->rc == EOK)
    22461673                *rwnd_id = resp->wnd_id;
    … …  
    22591686
    22601687static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    2261     gfx_coord2_t *pos, sysarg_t pos_id)
     1688    gfx_coord2_t *pos)
    22621689{
    22631690        test_response_t *resp = (test_response_t *) arg;
    … …  
    22661693        resp->move_req_wnd_id = wnd_id;
    22671694        resp->move_req_pos = *pos;
    2268         resp->move_req_pos_id = pos_id;
    22691695        return resp->rc;
    22701696}
    … …  
    22931719}
    22941720
    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 
    23091721static 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)
     1722    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
    23111723{
    23121724        test_response_t *resp = (test_response_t *) arg;
    … …  
    23161728        resp->resize_req_wnd_id = wnd_id;
    23171729        resp->resize_req_pos = *pos;
    2318         resp->resize_req_pos_id = pos_id;
    23191730        return resp->rc;
    23201731}
    … …  
    23321743}
    23331744
    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 
    23611745static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    23621746    display_stock_cursor_t cursor)
    … …  
    23671751        resp->set_cursor_wnd_id = wnd_id;
    23681752        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);
    23811753
    23821754        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.