Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4c6fd56 rc9927c66  
    11/*
    2  * Copyright (c) 2023 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, &sid);
    197         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    198 
    199         rc = display_open(test_display_svc, &disp);
    200         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    201         PCUT_ASSERT_NOT_NULL(disp);
    202 
    203         display_close(disp);
    204         rc = loc_service_unregister(srv, sid);
    205         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    206         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);
    207178}
    208179
    … …  
    216187        display_window_t *wnd;
    217188        test_response_t resp;
    218         loc_srv_t *srv;
    219 
    220         async_set_fallback_port_handler(test_display_conn, &resp);
    221 
    222         // FIXME This causes this test to be non-reentrant!
    223         rc = loc_server_register(test_display_server, &srv);
    224         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    225 
    226         rc = loc_service_register(srv, test_display_svc, &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);
    227197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    228198
    … …  
    241211        params.min_size.x = 11;
    242212        params.min_size.y = 12;
    243         params.idev_id = 42;
    244213
    245214        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    252221        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    253222        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
    254         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    255223        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    256224        PCUT_ASSERT_NULL(wnd);
    257225
    258226        display_close(disp);
    259         rc = loc_service_unregister(srv, sid);
    260         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    261         loc_server_unregister(srv);
     227        rc = loc_service_unregister(sid);
     228        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    262229}
    263230
    … …  
    274241        display_window_t *wnd;
    275242        test_response_t resp;
    276         loc_srv_t *srv;
    277 
    278         async_set_fallback_port_handler(test_display_conn, &resp);
    279 
    280         // FIXME This causes this test to be non-reentrant!
    281         rc = loc_server_register(test_display_server, &srv);
    282         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    283 
    284         rc = loc_service_register(srv, test_display_svc, &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);
    285251        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    286252
    … …  
    297263        params.rect.p0.x = 100;
    298264        params.rect.p0.y = 100;
    299         params.idev_id = 42;
    300265
    301266        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    306271        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    307272        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
    308         PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    309273        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    310274        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    317281
    318282        display_close(disp);
    319         rc = loc_service_unregister(srv, sid);
    320         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    321         loc_server_unregister(srv);
     283        rc = loc_service_unregister(sid);
     284        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    322285}
    323286
    … …  
    331294        display_window_t *wnd;
    332295        test_response_t resp;
    333         loc_srv_t *srv;
    334 
    335         async_set_fallback_port_handler(test_display_conn, &resp);
    336 
    337         // FIXME This causes this test to be non-reentrant!
    338         rc = loc_server_register(test_display_server, &srv);
    339         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    340 
    341         rc = loc_service_register(srv, test_display_svc, &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);
    342304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    343305
    … …  
    372334
    373335        display_close(disp);
    374         rc = loc_service_unregister(srv, sid);
    375         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    376         loc_server_unregister(srv);
     336        rc = loc_service_unregister(sid);
     337        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    377338}
    378339
    … …  
    393354        test_response_t resp;
    394355        gfx_coord2_t pos;
    395         sysarg_t pos_id;
    396         loc_srv_t *srv;
    397 
    398         async_set_fallback_port_handler(test_display_conn, &resp);
    399 
    400         // FIXME This causes this test to be non-reentrant!
    401         rc = loc_server_register(test_display_server, &srv);
    402         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    403 
    404         rc = loc_service_register(srv, test_display_svc, &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);
    405364        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    406365
    … …  
    426385        pos.x = 42;
    427386        pos.y = 43;
    428         pos_id = 44;
    429 
    430         rc = display_window_move_req(wnd, &pos, pos_id);
     387
     388        rc = display_window_move_req(wnd, &pos);
    431389        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    432390        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    434392        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    435393        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    436         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    437394
    438395        display_window_destroy(wnd);
    439396        display_close(disp);
    440         rc = loc_service_unregister(srv, sid);
    441         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    442         loc_server_unregister(srv);
     397        rc = loc_service_unregister(sid);
     398        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    443399}
    444400
    … …  
    453409        test_response_t resp;
    454410        gfx_coord2_t pos;
    455         sysarg_t pos_id;
    456         loc_srv_t *srv;
    457 
    458         async_set_fallback_port_handler(test_display_conn, &resp);
    459 
    460         // FIXME This causes this test to be non-reentrant!
    461         rc = loc_server_register(test_display_server, &srv);
    462         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    463 
    464         rc = loc_service_register(srv, test_display_svc, &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);
    465419        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    466420
    … …  
    486440        pos.x = 42;
    487441        pos.y = 43;
    488         pos_id = 44;
    489 
    490         rc = display_window_move_req(wnd, &pos, pos_id);
     442
     443        rc = display_window_move_req(wnd, &pos);
    491444        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    492445        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    494447        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    495448        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
    496         PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    497449
    498450        display_window_destroy(wnd);
    499451        display_close(disp);
    500         rc = loc_service_unregister(srv, sid);
    501         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    502         loc_server_unregister(srv);
     452        rc = loc_service_unregister(sid);
     453        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    503454}
    504455
    … …  
    513464        gfx_coord2_t dpos;
    514465        test_response_t resp;
    515         loc_srv_t *srv;
    516 
    517         async_set_fallback_port_handler(test_display_conn, &resp);
    518 
    519         // FIXME This causes this test to be non-reentrant!
    520         rc = loc_server_register(test_display_server, &srv);
    521         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    522 
    523         rc = loc_service_register(srv, test_display_svc, &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);
    524474        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    525475
    … …  
    554504        display_window_destroy(wnd);
    555505        display_close(disp);
    556         rc = loc_service_unregister(srv, sid);
    557         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    558         loc_server_unregister(srv);
     506        rc = loc_service_unregister(sid);
     507        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    559508}
    560509
    … …  
    569518        gfx_coord2_t dpos;
    570519        test_response_t resp;
    571         loc_srv_t *srv;
    572 
    573         async_set_fallback_port_handler(test_display_conn, &resp);
    574 
    575         // FIXME This causes this test to be non-reentrant!
    576         rc = loc_server_register(test_display_server, &srv);
    577         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    578 
    579         rc = loc_service_register(srv, test_display_svc, &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);
    580528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    581529
    … …  
    610558        display_window_destroy(wnd);
    611559        display_close(disp);
    612         rc = loc_service_unregister(srv, sid);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    614         loc_server_unregister(srv);
     560        rc = loc_service_unregister(sid);
     561        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    615562}
    616563
    … …  
    625572        gfx_coord2_t dpos;
    626573        test_response_t resp;
    627         loc_srv_t *srv;
    628 
    629         async_set_fallback_port_handler(test_display_conn, &resp);
    630 
    631         // FIXME This causes this test to be non-reentrant!
    632         rc = loc_server_register(test_display_server, &srv);
    633         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    634 
    635         rc = loc_service_register(srv, test_display_svc, &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);
    636582        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    637583
    … …  
    667613        display_window_destroy(wnd);
    668614        display_close(disp);
    669         rc = loc_service_unregister(srv, sid);
    670         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    671         loc_server_unregister(srv);
     615        rc = loc_service_unregister(sid);
     616        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    672617}
    673618
    … …  
    682627        gfx_coord2_t dpos;
    683628        test_response_t resp;
    684         loc_srv_t *srv;
    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, &srv);
    690         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    691 
    692         rc = loc_service_register(srv, test_display_svc, &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);
    693637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    694638
    … …  
    726670        display_window_destroy(wnd);
    727671        display_close(disp);
    728         rc = loc_service_unregister(srv, sid);
    729         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    730         loc_server_unregister(srv);
    731 }
    732 
    733 /** display_window_get_max_rect() with server returning error response works. */
    734 PCUT_TEST(window_get_max_rect_failure)
    735 {
    736         errno_t rc;
    737         service_id_t sid;
    738         display_t *disp = NULL;
    739         display_wnd_params_t params;
    740         display_window_t *wnd;
    741         gfx_rect_t rect;
    742         test_response_t resp;
    743         loc_srv_t *srv;
    744 
    745         async_set_fallback_port_handler(test_display_conn, &resp);
    746 
    747         // FIXME This causes this test to be non-reentrant!
    748         rc = loc_server_register(test_display_server, &srv);
    749         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    750 
    751         rc = loc_service_register(srv, test_display_svc, &sid);
    752         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    753 
    754         rc = display_open(test_display_svc, &disp);
    755         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    756         PCUT_ASSERT_NOT_NULL(disp);
    757 
    758         resp.rc = EOK;
    759         display_wnd_params_init(&params);
    760         params.rect.p0.x = 0;
    761         params.rect.p0.y = 0;
    762         params.rect.p0.x = 100;
    763         params.rect.p0.y = 100;
    764 
    765         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    766             (void *) &resp, &wnd);
    767         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    768         PCUT_ASSERT_NOT_NULL(wnd);
    769 
    770         resp.rc = EIO;
    771         resp.window_get_max_rect_called = false;
    772 
    773         rect.p0.x = 0;
    774         rect.p0.y = 0;
    775         rect.p1.x = 0;
    776         rect.p1.y = 0;
    777 
    778         rc = display_window_get_max_rect(wnd, &rect);
    779         PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
    780         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    781         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
    782         PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
    783         PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
    784         PCUT_ASSERT_INT_EQUALS(0, rect.p1.x);
    785         PCUT_ASSERT_INT_EQUALS(0, rect.p1.y);
    786 
    787         display_window_destroy(wnd);
    788         display_close(disp);
    789         rc = loc_service_unregister(srv, sid);
    790         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    791         loc_server_unregister(srv);
    792 }
    793 
    794 /** display_window_get_max_rect() with server returning success response works. */
    795 PCUT_TEST(window_get_max_rect_success)
    796 {
    797         errno_t rc;
    798         service_id_t sid;
    799         display_t *disp = NULL;
    800         display_wnd_params_t params;
    801         display_window_t *wnd;
    802         gfx_rect_t rect;
    803         test_response_t resp;
    804         loc_srv_t *srv;
    805 
    806         async_set_fallback_port_handler(test_display_conn, &resp);
    807 
    808         // FIXME This causes this test to be non-reentrant!
    809         rc = loc_server_register(test_display_server, &srv);
    810         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    811 
    812         rc = loc_service_register(srv, test_display_svc, &sid);
    813         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    814 
    815         rc = display_open(test_display_svc, &disp);
    816         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    817         PCUT_ASSERT_NOT_NULL(disp);
    818 
    819         resp.rc = EOK;
    820         display_wnd_params_init(&params);
    821         params.rect.p0.x = 0;
    822         params.rect.p0.y = 0;
    823         params.rect.p0.x = 100;
    824         params.rect.p0.y = 100;
    825 
    826         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    827             (void *) &resp, &wnd);
    828         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    829         PCUT_ASSERT_NOT_NULL(wnd);
    830 
    831         resp.rc = EOK;
    832         resp.window_get_max_rect_called = false;
    833         resp.get_max_rect_rrect.p0.x = 11;
    834         resp.get_max_rect_rrect.p0.y = 12;
    835         resp.get_max_rect_rrect.p1.x = 13;
    836         resp.get_max_rect_rrect.p1.y = 14;
    837 
    838         rect.p0.x = 0;
    839         rect.p0.y = 0;
    840         rect.p1.x = 0;
    841         rect.p1.y = 0;
    842 
    843         rc = display_window_get_max_rect(wnd, &rect);
    844         PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
    845         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    846         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
    847         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x);
    848         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y);
    849         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x);
    850         PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y);
    851 
    852         display_window_destroy(wnd);
    853         display_close(disp);
    854         rc = loc_service_unregister(srv, sid);
    855         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    856         loc_server_unregister(srv);
     672        rc = loc_service_unregister(sid);
     673        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    857674}
    858675
    … …  
    868685        display_wnd_rsztype_t rsztype;
    869686        gfx_coord2_t pos;
    870         sysarg_t pos_id;
    871         loc_srv_t *srv;
    872 
    873         async_set_fallback_port_handler(test_display_conn, &resp);
    874 
    875         // FIXME This causes this test to be non-reentrant!
    876         rc = loc_server_register(test_display_server, &srv);
    877         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    878 
    879         rc = loc_service_register(srv, test_display_svc, &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);
    880695        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    881696
    … …  
    902717        pos.x = 42;
    903718        pos.y = 43;
    904         pos_id = 44;
    905 
    906         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     719
     720        rc = display_window_resize_req(wnd, rsztype, &pos);
    907721        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    908722        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    911725        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    912726        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    913         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    914727
    915728        display_window_destroy(wnd);
    916729        display_close(disp);
    917         rc = loc_service_unregister(srv, sid);
    918         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    919         loc_server_unregister(srv);
     730        rc = loc_service_unregister(sid);
     731        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    920732}
    921733
    … …  
    931743        display_wnd_rsztype_t rsztype;
    932744        gfx_coord2_t pos;
    933         sysarg_t pos_id;
    934         loc_srv_t *srv;
    935 
    936         async_set_fallback_port_handler(test_display_conn, &resp);
    937 
    938         // FIXME This causes this test to be non-reentrant!
    939         rc = loc_server_register(test_display_server, &srv);
    940         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    941 
    942         rc = loc_service_register(srv, test_display_svc, &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);
    943753        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    944754
    … …  
    965775        pos.x = 42;
    966776        pos.y = 43;
    967         pos_id = 44;
    968 
    969         rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
     777
     778        rc = display_window_resize_req(wnd, rsztype, &pos);
    970779        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    971780        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    974783        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    975784        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
    976         PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    977785
    978786        display_window_destroy(wnd);
    979787        display_close(disp);
    980         rc = loc_service_unregister(srv, sid);
    981         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    982         loc_server_unregister(srv);
     788        rc = loc_service_unregister(sid);
     789        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    983790}
    984791
    … …  
    994801        gfx_rect_t nrect;
    995802        test_response_t resp;
    996         loc_srv_t *srv;
    997 
    998         async_set_fallback_port_handler(test_display_conn, &resp);
    999 
    1000         // FIXME This causes this test to be non-reentrant!
    1001         rc = loc_server_register(test_display_server, &srv);
    1002         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1003 
    1004         rc = loc_service_register(srv, test_display_svc, &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);
    1005811        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1006812
    … …  
    1043849        display_window_destroy(wnd);
    1044850        display_close(disp);
    1045         rc = loc_service_unregister(srv, sid);
    1046         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1047         loc_server_unregister(srv);
     851        rc = loc_service_unregister(sid);
     852        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1048853}
    1049854
    … …  
    1059864        gfx_rect_t nrect;
    1060865        test_response_t resp;
    1061         loc_srv_t *srv;
    1062 
    1063         async_set_fallback_port_handler(test_display_conn, &resp);
    1064 
    1065         // FIXME This causes this test to be non-reentrant!
    1066         rc = loc_server_register(test_display_server, &srv);
    1067         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1068 
    1069         rc = loc_service_register(srv, test_display_svc, &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);
    1070874        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1071875
    … …  
    1107911        display_window_destroy(wnd);
    1108912        display_close(disp);
    1109         rc = loc_service_unregister(srv, sid);
    1110         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1111         loc_server_unregister(srv);
    1112 }
    1113 
    1114 /** display_window_minimize() with server returning error response works. */
    1115 PCUT_TEST(window_minimize_failure)
    1116 {
    1117         errno_t rc;
    1118         service_id_t sid;
    1119         display_t *disp = NULL;
    1120         display_wnd_params_t params;
    1121         display_window_t *wnd;
    1122         test_response_t resp;
    1123         loc_srv_t *srv;
    1124 
    1125         async_set_fallback_port_handler(test_display_conn, &resp);
    1126 
    1127         // FIXME This causes this test to be non-reentrant!
    1128         rc = loc_server_register(test_display_server, &srv);
    1129         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1130 
    1131         rc = loc_service_register(srv, test_display_svc, &sid);
    1132         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1133 
    1134         rc = display_open(test_display_svc, &disp);
    1135         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1136         PCUT_ASSERT_NOT_NULL(disp);
    1137 
    1138         resp.rc = EOK;
    1139         display_wnd_params_init(&params);
    1140         params.rect.p0.x = 0;
    1141         params.rect.p0.y = 0;
    1142         params.rect.p0.x = 100;
    1143         params.rect.p0.y = 100;
    1144 
    1145         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1146             (void *) &resp, &wnd);
    1147         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1148         PCUT_ASSERT_NOT_NULL(wnd);
    1149 
    1150         resp.rc = EIO;
    1151         resp.window_minimize_called = false;
    1152 
    1153         rc = display_window_minimize(wnd);
    1154         PCUT_ASSERT_TRUE(resp.window_minimize_called);
    1155         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1156 
    1157         display_window_destroy(wnd);
    1158         display_close(disp);
    1159         rc = loc_service_unregister(srv, sid);
    1160         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1161         loc_server_unregister(srv);
    1162 }
    1163 
    1164 /** display_window_minimize() with server returning success response works. */
    1165 PCUT_TEST(window_minimize_success)
    1166 {
    1167         errno_t rc;
    1168         service_id_t sid;
    1169         display_t *disp = NULL;
    1170         display_wnd_params_t params;
    1171         display_window_t *wnd;
    1172         test_response_t resp;
    1173         loc_srv_t *srv;
    1174 
    1175         async_set_fallback_port_handler(test_display_conn, &resp);
    1176 
    1177         // FIXME This causes this test to be non-reentrant!
    1178         rc = loc_server_register(test_display_server, &srv);
    1179         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1180 
    1181         rc = loc_service_register(srv, test_display_svc, &sid);
    1182         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1183 
    1184         rc = display_open(test_display_svc, &disp);
    1185         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1186         PCUT_ASSERT_NOT_NULL(disp);
    1187 
    1188         resp.rc = EOK;
    1189         display_wnd_params_init(&params);
    1190         params.rect.p0.x = 0;
    1191         params.rect.p0.y = 0;
    1192         params.rect.p0.x = 100;
    1193         params.rect.p0.y = 100;
    1194 
    1195         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1196             (void *) &resp, &wnd);
    1197         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1198         PCUT_ASSERT_NOT_NULL(wnd);
    1199 
    1200         resp.rc = EOK;
    1201         resp.window_minimize_called = false;
    1202 
    1203         rc = display_window_minimize(wnd);
    1204         PCUT_ASSERT_TRUE(resp.window_minimize_called);
    1205         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1206 
    1207         display_window_destroy(wnd);
    1208         display_close(disp);
    1209         rc = loc_service_unregister(srv, sid);
    1210         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1211         loc_server_unregister(srv);
    1212 }
    1213 
    1214 /** display_window_maximize() with server returning error response works. */
    1215 PCUT_TEST(window_maximize_failure)
    1216 {
    1217         errno_t rc;
    1218         service_id_t sid;
    1219         display_t *disp = NULL;
    1220         display_wnd_params_t params;
    1221         display_window_t *wnd;
    1222         test_response_t resp;
    1223         loc_srv_t *srv;
    1224 
    1225         async_set_fallback_port_handler(test_display_conn, &resp);
    1226 
    1227         // FIXME This causes this test to be non-reentrant!
    1228         rc = loc_server_register(test_display_server, &srv);
    1229         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1230 
    1231         rc = loc_service_register(srv, test_display_svc, &sid);
    1232         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1233 
    1234         rc = display_open(test_display_svc, &disp);
    1235         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1236         PCUT_ASSERT_NOT_NULL(disp);
    1237 
    1238         resp.rc = EOK;
    1239         display_wnd_params_init(&params);
    1240         params.rect.p0.x = 0;
    1241         params.rect.p0.y = 0;
    1242         params.rect.p0.x = 100;
    1243         params.rect.p0.y = 100;
    1244 
    1245         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1246             (void *) &resp, &wnd);
    1247         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1248         PCUT_ASSERT_NOT_NULL(wnd);
    1249 
    1250         resp.rc = EIO;
    1251         resp.window_maximize_called = false;
    1252 
    1253         rc = display_window_maximize(wnd);
    1254         PCUT_ASSERT_TRUE(resp.window_maximize_called);
    1255         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1256 
    1257         display_window_destroy(wnd);
    1258         display_close(disp);
    1259         rc = loc_service_unregister(srv, sid);
    1260         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1261         loc_server_unregister(srv);
    1262 }
    1263 
    1264 /** display_window_maximize() with server returning success response works. */
    1265 PCUT_TEST(window_maximize_success)
    1266 {
    1267         errno_t rc;
    1268         service_id_t sid;
    1269         display_t *disp = NULL;
    1270         display_wnd_params_t params;
    1271         display_window_t *wnd;
    1272         test_response_t resp;
    1273         loc_srv_t *srv;
    1274 
    1275         async_set_fallback_port_handler(test_display_conn, &resp);
    1276 
    1277         // FIXME This causes this test to be non-reentrant!
    1278         rc = loc_server_register(test_display_server, &srv);
    1279         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1280 
    1281         rc = loc_service_register(srv, test_display_svc, &sid);
    1282         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1283 
    1284         rc = display_open(test_display_svc, &disp);
    1285         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1286         PCUT_ASSERT_NOT_NULL(disp);
    1287 
    1288         resp.rc = EOK;
    1289         display_wnd_params_init(&params);
    1290         params.rect.p0.x = 0;
    1291         params.rect.p0.y = 0;
    1292         params.rect.p0.x = 100;
    1293         params.rect.p0.y = 100;
    1294 
    1295         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1296             (void *) &resp, &wnd);
    1297         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1298         PCUT_ASSERT_NOT_NULL(wnd);
    1299 
    1300         resp.rc = EOK;
    1301         resp.window_maximize_called = false;
    1302 
    1303         rc = display_window_maximize(wnd);
    1304         PCUT_ASSERT_TRUE(resp.window_maximize_called);
    1305         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1306 
    1307         display_window_destroy(wnd);
    1308         display_close(disp);
    1309         rc = loc_service_unregister(srv, sid);
    1310         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1311         loc_server_unregister(srv);
     913        rc = loc_service_unregister(sid);
     914        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1312915}
    1313916
    … …  
    1321924        display_window_t *wnd;
    1322925        test_response_t resp;
    1323         loc_srv_t *srv;
    1324 
    1325         async_set_fallback_port_handler(test_display_conn, &resp);
    1326 
    1327         // FIXME This causes this test to be non-reentrant!
    1328         rc = loc_server_register(test_display_server, &srv);
    1329         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1330 
    1331         rc = loc_service_register(srv, test_display_svc, &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);
    1332934        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1333935
    … …  
    1359961        display_window_destroy(wnd);
    1360962        display_close(disp);
    1361         rc = loc_service_unregister(srv, sid);
    1362         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1363         loc_server_unregister(srv);
     963        rc = loc_service_unregister(sid);
     964        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1364965}
    1365966
    … …  
    1373974        display_window_t *wnd;
    1374975        test_response_t resp;
    1375         loc_srv_t *srv;
    1376 
    1377         async_set_fallback_port_handler(test_display_conn, &resp);
    1378 
    1379         // FIXME This causes this test to be non-reentrant!
    1380         rc = loc_server_register(test_display_server, &srv);
    1381         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1382 
    1383         rc = loc_service_register(srv, test_display_svc, &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);
    1384984        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1385985
    … …  
    14111011        display_window_destroy(wnd);
    14121012        display_close(disp);
    1413         rc = loc_service_unregister(srv, sid);
    1414         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1415         loc_server_unregister(srv);
    1416 }
    1417 
    1418 /** display_window_set_caption() with server returning error response works. */
    1419 PCUT_TEST(window_set_caption_failure)
    1420 {
    1421         errno_t rc;
    1422         service_id_t sid;
    1423         display_t *disp = NULL;
    1424         display_wnd_params_t params;
    1425         display_window_t *wnd;
    1426         const char *caption;
    1427         test_response_t resp;
    1428         loc_srv_t *srv;
    1429 
    1430         async_set_fallback_port_handler(test_display_conn, &resp);
    1431 
    1432         // FIXME This causes this test to be non-reentrant!
    1433         rc = loc_server_register(test_display_server, &srv);
    1434         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1435 
    1436         rc = loc_service_register(srv, test_display_svc, &sid);
    1437         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1438 
    1439         rc = display_open(test_display_svc, &disp);
    1440         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1441         PCUT_ASSERT_NOT_NULL(disp);
    1442 
    1443         resp.rc = EOK;
    1444         display_wnd_params_init(&params);
    1445         params.rect.p0.x = 0;
    1446         params.rect.p0.y = 0;
    1447         params.rect.p0.x = 100;
    1448         params.rect.p0.y = 100;
    1449 
    1450         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1451             (void *) &resp, &wnd);
    1452         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1453         PCUT_ASSERT_NOT_NULL(wnd);
    1454 
    1455         caption = "Hello";
    1456 
    1457         resp.rc = EIO;
    1458         resp.window_set_caption_called = false;
    1459 
    1460         rc = display_window_set_caption(wnd, caption);
    1461         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
    1462         PCUT_ASSERT_TRUE(resp.window_set_caption_called);
    1463         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1464         PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
    1465 
    1466         //free(resp.set_caption_caption);
    1467         display_window_destroy(wnd);
    1468         display_close(disp);
    1469         rc = loc_service_unregister(srv, sid);
    1470         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1471         loc_server_unregister(srv);
    1472 }
    1473 
    1474 /** display_window_set_caption() with server returning success response works. */
    1475 PCUT_TEST(window_set_caption_success)
    1476 {
    1477         errno_t rc;
    1478         service_id_t sid;
    1479         display_t *disp = NULL;
    1480         display_wnd_params_t params;
    1481         display_window_t *wnd;
    1482         const char *caption;
    1483         test_response_t resp;
    1484         loc_srv_t *srv;
    1485 
    1486         async_set_fallback_port_handler(test_display_conn, &resp);
    1487 
    1488         // FIXME This causes this test to be non-reentrant!
    1489         rc = loc_server_register(test_display_server, &srv);
    1490         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1491 
    1492         rc = loc_service_register(srv, test_display_svc, &sid);
    1493         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1494 
    1495         rc = display_open(test_display_svc, &disp);
    1496         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1497         PCUT_ASSERT_NOT_NULL(disp);
    1498 
    1499         resp.rc = EOK;
    1500         display_wnd_params_init(&params);
    1501         params.rect.p0.x = 0;
    1502         params.rect.p0.y = 0;
    1503         params.rect.p0.x = 100;
    1504         params.rect.p0.y = 100;
    1505 
    1506         rc = display_window_create(disp, &params, &test_display_wnd_cb,
    1507             (void *) &resp, &wnd);
    1508         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1509         PCUT_ASSERT_NOT_NULL(wnd);
    1510 
    1511         caption = "Hello";
    1512 
    1513         resp.rc = EOK;
    1514         resp.window_set_caption_called = false;
    1515 
    1516         rc = display_window_set_caption(wnd, caption);
    1517         PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
    1518         PCUT_ASSERT_TRUE(resp.window_set_caption_called);
    1519         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    1520         PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
    1521 
    1522         //free(resp.set_caption_caption);
    1523         display_window_destroy(wnd);
    1524         display_close(disp);
    1525         rc = loc_service_unregister(srv, sid);
    1526         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1527         loc_server_unregister(srv);
     1013        rc = loc_service_unregister(sid);
     1014        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15281015}
    15291016
    … …  
    15381025        test_response_t resp;
    15391026        gfx_context_t *gc;
    1540         loc_srv_t *srv;
    1541 
    1542         async_set_fallback_port_handler(test_display_conn, &resp);
    1543 
    1544         // FIXME This causes this test to be non-reentrant!
    1545         rc = loc_server_register(test_display_server, &srv);
    1546         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1547 
    1548         rc = loc_service_register(srv, test_display_svc, &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);
    15491035        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15501036
    … …  
    15771063
    15781064        display_close(disp);
    1579         rc = loc_service_unregister(srv, sid);
    1580         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1581         loc_server_unregister(srv);
     1065        rc = loc_service_unregister(sid);
     1066        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15821067}
    15831068
    … …  
    15931078        gfx_context_t *gc;
    15941079        gfx_color_t *color;
    1595         loc_srv_t *srv;
    1596 
    1597         async_set_fallback_port_handler(test_display_conn, &resp);
    1598 
    1599         // FIXME This causes this test to be non-reentrant!
    1600         rc = loc_server_register(test_display_server, &srv);
    1601         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1602 
    1603         rc = loc_service_register(srv, test_display_svc, &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);
    16041088        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16051089
    … …  
    16401124
    16411125        display_close(disp);
    1642         rc = loc_service_unregister(srv, sid);
    1643         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1644         loc_server_unregister(srv);
     1126        rc = loc_service_unregister(sid);
     1127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16451128}
    16461129
    … …  
    16541137        display_window_t *wnd;
    16551138        test_response_t resp;
    1656         loc_srv_t *srv;
    1657 
    1658         async_set_fallback_port_handler(test_display_conn, &resp);
    1659 
    1660         // FIXME This causes this test to be non-reentrant!
    1661         rc = loc_server_register(test_display_server, &srv);
    1662         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1663 
    1664         rc = loc_service_register(srv, test_display_svc, &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);
    16651147        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16661148
    … …  
    17071189        display_close(disp);
    17081190
    1709         rc = loc_service_unregister(srv, sid);
    1710         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1711         loc_server_unregister(srv);
     1191        rc = loc_service_unregister(sid);
     1192        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17121193}
    17131194
    … …  
    17211202        display_window_t *wnd;
    17221203        test_response_t resp;
    1723         loc_srv_t *srv;
    1724 
    1725         async_set_fallback_port_handler(test_display_conn, &resp);
    1726 
    1727         // FIXME This causes this test to be non-reentrant!
    1728         rc = loc_server_register(test_display_server, &srv);
    1729         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1730 
    1731         rc = loc_service_register(srv, test_display_svc, &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);
    17321212        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17331213
    … …  
    17521232        resp.event_cnt = 1;
    17531233        resp.event.etype = wev_focus;
    1754         resp.event.ev.focus.nfocus = 42;
    17551234        resp.wnd_id = wnd->id;
    17561235        resp.focus_event_called = false;
    … …  
    17691248        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    17701249            resp.revent.etype);
    1771         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    1772             resp.revent.ev.focus.nfocus);
    17731250
    17741251        rc = display_window_destroy(wnd);
    … …  
    17771254        display_close(disp);
    17781255
    1779         rc = loc_service_unregister(srv, sid);
    1780         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1781         loc_server_unregister(srv);
     1256        rc = loc_service_unregister(sid);
     1257        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17821258}
    17831259
    … …  
    17911267        display_window_t *wnd;
    17921268        test_response_t resp;
    1793         loc_srv_t *srv;
    1794 
    1795         async_set_fallback_port_handler(test_display_conn, &resp);
    1796 
    1797         // FIXME This causes this test to be non-reentrant!
    1798         rc = loc_server_register(test_display_server, &srv);
    1799         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1800 
    1801         rc = loc_service_register(srv, test_display_svc, &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);
    18021277        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18031278
    … …  
    18561331        display_close(disp);
    18571332
    1858         rc = loc_service_unregister(srv, sid);
    1859         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1860         loc_server_unregister(srv);
     1333        rc = loc_service_unregister(sid);
     1334        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18611335}
    18621336
    … …  
    18701344        display_window_t *wnd;
    18711345        test_response_t resp;
    1872         loc_srv_t *srv;
    1873 
    1874         async_set_fallback_port_handler(test_display_conn, &resp);
    1875 
    1876         // FIXME This causes this test to be non-reentrant!
    1877         rc = loc_server_register(test_display_server, &srv);
    1878         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1879 
    1880         rc = loc_service_register(srv, test_display_svc, &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);
    18811354        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18821355
    … …  
    19351408        display_close(disp);
    19361409
    1937         rc = loc_service_unregister(srv, sid);
    1938         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1939         loc_server_unregister(srv);
     1410        rc = loc_service_unregister(sid);
     1411        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19401412}
    19411413
    … …  
    19491421        display_window_t *wnd;
    19501422        test_response_t resp;
    1951         loc_srv_t *srv;
    1952 
    1953         async_set_fallback_port_handler(test_display_conn, &resp);
    1954 
    1955         // FIXME This causes this test to be non-reentrant!
    1956         rc = loc_server_register(test_display_server, &srv);
    1957         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1958 
    1959         rc = loc_service_register(srv, test_display_svc, &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);
    19601431        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19611432
    … …  
    19801451        resp.event_cnt = 1;
    19811452        resp.event.etype = wev_unfocus;
    1982         resp.event.ev.unfocus.nfocus = 42;
    19831453        resp.wnd_id = wnd->id;
    19841454        resp.unfocus_event_called = false;
    … …  
    19971467        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    19981468            resp.revent.etype);
    1999         PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
    2000             resp.revent.ev.focus.nfocus);
    20011469
    20021470        rc = display_window_destroy(wnd);
    … …  
    20051473        display_close(disp);
    20061474
    2007         rc = loc_service_unregister(srv, sid);
    2008         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2009         loc_server_unregister(srv);
     1475        rc = loc_service_unregister(sid);
     1476        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20101477}
    20111478
    … …  
    20181485        display_info_t info;
    20191486        test_response_t resp;
    2020         loc_srv_t *srv;
    2021 
    2022         async_set_fallback_port_handler(test_display_conn, &resp);
    2023 
    2024         // FIXME This causes this test to be non-reentrant!
    2025         rc = loc_server_register(test_display_server, &srv);
    2026         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2027 
    2028         rc = loc_service_register(srv, test_display_svc, &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);
    20291495        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20301496
    … …  
    20411507
    20421508        display_close(disp);
    2043         rc = loc_service_unregister(srv, sid);
    2044         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2045         loc_server_unregister(srv);
     1509        rc = loc_service_unregister(sid);
     1510        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20461511}
    20471512
    … …  
    20541519        display_info_t info;
    20551520        test_response_t resp;
    2056         loc_srv_t *srv;
    2057 
    2058         async_set_fallback_port_handler(test_display_conn, &resp);
    2059 
    2060         // FIXME This causes this test to be non-reentrant!
    2061         rc = loc_server_register(test_display_server, &srv);
    2062         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2063 
    2064         rc = loc_service_register(srv, test_display_svc, &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);
    20651529        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20661530
    … …  
    20851549
    20861550        display_close(disp);
    2087         rc = loc_service_unregister(srv, sid);
    2088         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    2089         loc_server_unregister(srv);
     1551        rc = loc_service_unregister(sid);
     1552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20901553}
    20911554
    … …  
    21491612}
    21501613
    2151 static void test_focus_event(void *arg, unsigned nfocus)
     1614static void test_focus_event(void *arg)
    21521615{
    21531616        test_response_t *resp = (test_response_t *) arg;
    21541617
    21551618        resp->revent.etype = wev_focus;
    2156         resp->revent.ev.focus.nfocus = nfocus;
    21571619
    21581620        fibril_mutex_lock(&resp->event_lock);
    … …  
    21881650}
    21891651
    2190 static void test_unfocus_event(void *arg, unsigned nfocus)
     1652static void test_unfocus_event(void *arg)
    21911653{
    21921654        test_response_t *resp = (test_response_t *) arg;
    21931655
    21941656        resp->revent.etype = wev_unfocus;
    2195         resp->revent.ev.unfocus.nfocus = nfocus;
    21961657
    21971658        fibril_mutex_lock(&resp->event_lock);
    … …  
    22091670        resp->create_rect = params->rect;
    22101671        resp->create_min_size = params->min_size;
    2211         resp->create_idev_id = params->idev_id;
    22121672        if (resp->rc == EOK)
    22131673                *rwnd_id = resp->wnd_id;
    … …  
    22261686
    22271687static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    2228     gfx_coord2_t *pos, sysarg_t pos_id)
     1688    gfx_coord2_t *pos)
    22291689{
    22301690        test_response_t *resp = (test_response_t *) arg;
    … …  
    22331693        resp->move_req_wnd_id = wnd_id;
    22341694        resp->move_req_pos = *pos;
    2235         resp->move_req_pos_id = pos_id;
    22361695        return resp->rc;
    22371696}
    … …  
    22601719}
    22611720
    2262 static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id,
    2263     gfx_rect_t *rect)
    2264 {
    2265         test_response_t *resp = (test_response_t *) arg;
    2266 
    2267         resp->window_get_max_rect_called = true;
    2268         resp->get_max_rect_wnd_id = wnd_id;
    2269 
    2270         if (resp->rc == EOK)
    2271                 *rect = resp->get_max_rect_rrect;
    2272 
    2273         return resp->rc;
    2274 }
    2275 
    22761721static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    2277     display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
     1722    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
    22781723{
    22791724        test_response_t *resp = (test_response_t *) arg;
    … …  
    22831728        resp->resize_req_wnd_id = wnd_id;
    22841729        resp->resize_req_pos = *pos;
    2285         resp->resize_req_pos_id = pos_id;
    22861730        return resp->rc;
    22871731}
    … …  
    22991743}
    23001744
    2301 static errno_t test_window_minimize(void *arg, sysarg_t wnd_id)
    2302 {
    2303         test_response_t *resp = (test_response_t *) arg;
    2304 
    2305         resp->window_minimize_called = true;
    2306         resp->resize_wnd_id = wnd_id;
    2307         return resp->rc;
    2308 }
    2309 
    2310 static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
    2311 {
    2312         test_response_t *resp = (test_response_t *) arg;
    2313 
    2314         resp->window_maximize_called = true;
    2315         resp->resize_wnd_id = wnd_id;
    2316         return resp->rc;
    2317 }
    2318 
    2319 static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id)
    2320 {
    2321         test_response_t *resp = (test_response_t *) arg;
    2322 
    2323         resp->window_unmaximize_called = true;
    2324         resp->resize_wnd_id = wnd_id;
    2325         return resp->rc;
    2326 }
    2327 
    23281745static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    23291746    display_stock_cursor_t cursor)
    … …  
    23341751        resp->set_cursor_wnd_id = wnd_id;
    23351752        resp->set_cursor_cursor = cursor;
    2336 
    2337         return resp->rc;
    2338 }
    2339 
    2340 static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id,
    2341     const char *caption)
    2342 {
    2343         test_response_t *resp = (test_response_t *) arg;
    2344 
    2345         resp->window_set_caption_called = true;
    2346         resp->set_caption_wnd_id = wnd_id;
    2347         resp->set_caption_caption = str_dup(caption);
    23481753
    23491754        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.