Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rc9927c66 r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#include <loc.h>
    3939#include <pcut/pcut.h>
     40#include <str.h>
    4041#include "../private/display.h"
    4142
    … …  
    5051
    5152static void test_close_event(void *);
    52 static void test_focus_event(void *);
     53static void test_focus_event(void *, unsigned);
    5354static void test_kbd_event(void *, kbd_event_t *);
    5455static void test_pos_event(void *, pos_event_t *);
    55 static void test_unfocus_event(void *);
     56static void test_unfocus_event(void *, unsigned);
    5657
    5758static errno_t test_window_create(void *, display_wnd_params_t *, sysarg_t *);
    5859static errno_t test_window_destroy(void *, sysarg_t);
    59 static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *);
     60static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *, sysarg_t);
    6061static errno_t test_window_move(void *, sysarg_t, gfx_coord2_t *);
    6162static errno_t test_window_get_pos(void *, sysarg_t, gfx_coord2_t *);
     63static errno_t test_window_get_max_rect(void *, sysarg_t, gfx_rect_t *);
    6264static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
    63     gfx_coord2_t *);
     65    gfx_coord2_t *, sysarg_t);
    6466static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6567    gfx_rect_t *);
     68static errno_t test_window_minimize(void *, sysarg_t);
     69static errno_t test_window_maximize(void *, sysarg_t);
     70static errno_t test_window_unmaximize(void *, sysarg_t);
    6671static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t);
     72static errno_t test_window_set_caption(void *, sysarg_t, const char *);
    6773static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    6874static errno_t test_get_info(void *, display_info_t *);
    … …  
    7682        .window_move = test_window_move,
    7783        .window_get_pos = test_window_get_pos,
     84        .window_get_max_rect = test_window_get_max_rect,
    7885        .window_resize_req = test_window_resize_req,
    7986        .window_resize = test_window_resize,
     87        .window_minimize = test_window_minimize,
     88        .window_maximize = test_window_maximize,
     89        .window_unmaximize = test_window_unmaximize,
    8090        .window_set_cursor = test_window_set_cursor,
     91        .window_set_caption = test_window_set_caption,
    8192        .get_event = test_get_event,
    8293        .get_info = test_get_info
    … …  
    107118        gfx_rect_t create_rect;
    108119        gfx_coord2_t create_min_size;
     120        sysarg_t create_idev_id;
    109121        bool window_destroy_called;
    110122        sysarg_t destroy_wnd_id;
    … …  
    113125        sysarg_t move_req_wnd_id;
    114126        gfx_coord2_t move_req_pos;
     127        sysarg_t move_req_pos_id;
    115128
    116129        bool window_move_called;
    … …  
    121134        sysarg_t get_pos_wnd_id;
    122135        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;
    123140
    124141        bool window_resize_req_called;
    … …  
    126143        display_wnd_rsztype_t resize_req_rsztype;
    127144        gfx_coord2_t resize_req_pos;
     145        sysarg_t resize_req_pos_id;
    128146
    129147        bool window_resize_called;
    … …  
    132150        sysarg_t resize_wnd_id;
    133151
     152        bool window_minimize_called;
     153        bool window_maximize_called;
     154        bool window_unmaximize_called;
     155
    134156        bool window_set_cursor_called;
    135157        sysarg_t set_cursor_wnd_id;
    136158        display_stock_cursor_t set_cursor_cursor;
    137159
     160        bool window_set_caption_called;
     161        sysarg_t set_caption_wnd_id;
     162        char *set_caption_caption;
     163
    138164        bool get_event_called;
    139165
    … …  
    143169        bool set_color_called;
    144170        bool close_event_called;
     171
    145172        bool focus_event_called;
    146173        bool kbd_event_called;
    … …  
    159186        display_t *disp = NULL;
    160187        test_response_t resp;
    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);
     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);
    178207}
    179208
    … …  
    187216        display_window_t *wnd;
    188217        test_response_t resp;
    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);
     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);
    197227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    198228
    … …  
    211241        params.min_size.x = 11;
    212242        params.min_size.y = 12;
     243        params.idev_id = 42;
    213244
    214245        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    221252        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    222253        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
     254        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    223255        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    224256        PCUT_ASSERT_NULL(wnd);
    225257
    226258        display_close(disp);
    227         rc = loc_service_unregister(sid);
    228         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        rc = loc_service_unregister(srv, sid);
     260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     261        loc_server_unregister(srv);
    229262}
    230263
    … …  
    241274        display_window_t *wnd;
    242275        test_response_t resp;
    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);
     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);
    251285        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    252286
    … …  
    263297        params.rect.p0.x = 100;
    264298        params.rect.p0.y = 100;
     299        params.idev_id = 42;
    265300
    266301        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    271306        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    272307        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
     308        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    273309        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    274310        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    281317
    282318        display_close(disp);
    283         rc = loc_service_unregister(sid);
    284         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319        rc = loc_service_unregister(srv, sid);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321        loc_server_unregister(srv);
    285322}
    286323
    … …  
    294331        display_window_t *wnd;
    295332        test_response_t resp;
    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);
     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);
    304342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    305343
    … …  
    334372
    335373        display_close(disp);
    336         rc = loc_service_unregister(sid);
    337         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     374        rc = loc_service_unregister(srv, sid);
     375        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     376        loc_server_unregister(srv);
    338377}
    339378
    … …  
    354393        test_response_t resp;
    355394        gfx_coord2_t pos;
    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);
     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);
    364405        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    365406
    … …  
    385426        pos.x = 42;
    386427        pos.y = 43;
    387 
    388         rc = display_window_move_req(wnd, &pos);
     428        pos_id = 44;
     429
     430        rc = display_window_move_req(wnd, &pos, pos_id);
    389431        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    390432        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    392434        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    393435        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     436        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    394437
    395438        display_window_destroy(wnd);
    396439        display_close(disp);
    397         rc = loc_service_unregister(sid);
    398         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     440        rc = loc_service_unregister(srv, sid);
     441        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     442        loc_server_unregister(srv);
    399443}
    400444
    … …  
    409453        test_response_t resp;
    410454        gfx_coord2_t pos;
    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);
     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);
    419465        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    420466
    … …  
    440486        pos.x = 42;
    441487        pos.y = 43;
    442 
    443         rc = display_window_move_req(wnd, &pos);
     488        pos_id = 44;
     489
     490        rc = display_window_move_req(wnd, &pos, pos_id);
    444491        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    445492        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    447494        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    448495        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     496        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    449497
    450498        display_window_destroy(wnd);
    451499        display_close(disp);
    452         rc = loc_service_unregister(sid);
    453         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     500        rc = loc_service_unregister(srv, sid);
     501        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     502        loc_server_unregister(srv);
    454503}
    455504
    … …  
    464513        gfx_coord2_t dpos;
    465514        test_response_t resp;
    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);
     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);
    474524        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    475525
    … …  
    504554        display_window_destroy(wnd);
    505555        display_close(disp);
    506         rc = loc_service_unregister(sid);
    507         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     556        rc = loc_service_unregister(srv, sid);
     557        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     558        loc_server_unregister(srv);
    508559}
    509560
    … …  
    518569        gfx_coord2_t dpos;
    519570        test_response_t resp;
    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);
     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);
    528580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    529581
    … …  
    558610        display_window_destroy(wnd);
    559611        display_close(disp);
    560         rc = loc_service_unregister(sid);
    561         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     612        rc = loc_service_unregister(srv, sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614        loc_server_unregister(srv);
    562615}
    563616
    … …  
    572625        gfx_coord2_t dpos;
    573626        test_response_t resp;
    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);
     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);
    582636        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    583637
    … …  
    613667        display_window_destroy(wnd);
    614668        display_close(disp);
    615         rc = loc_service_unregister(sid);
    616         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     669        rc = loc_service_unregister(srv, sid);
     670        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     671        loc_server_unregister(srv);
    617672}
    618673
    … …  
    627682        gfx_coord2_t dpos;
    628683        test_response_t resp;
    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);
     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);
    637693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    638694
    … …  
    670726        display_window_destroy(wnd);
    671727        display_close(disp);
    672         rc = loc_service_unregister(sid);
    673         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     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. */
     734PCUT_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. */
     795PCUT_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);
    674857}
    675858
    … …  
    685868        display_wnd_rsztype_t rsztype;
    686869        gfx_coord2_t pos;
    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);
     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);
    695880        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    696881
    … …  
    717902        pos.x = 42;
    718903        pos.y = 43;
    719 
    720         rc = display_window_resize_req(wnd, rsztype, &pos);
     904        pos_id = 44;
     905
     906        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    721907        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    722908        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    725911        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    726912        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     913        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    727914
    728915        display_window_destroy(wnd);
    729916        display_close(disp);
    730         rc = loc_service_unregister(sid);
    731         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     917        rc = loc_service_unregister(srv, sid);
     918        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     919        loc_server_unregister(srv);
    732920}
    733921
    … …  
    743931        display_wnd_rsztype_t rsztype;
    744932        gfx_coord2_t pos;
    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);
     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);
    753943        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    754944
    … …  
    775965        pos.x = 42;
    776966        pos.y = 43;
    777 
    778         rc = display_window_resize_req(wnd, rsztype, &pos);
     967        pos_id = 44;
     968
     969        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    779970        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    780971        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    783974        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    784975        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     976        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    785977
    786978        display_window_destroy(wnd);
    787979        display_close(disp);
    788         rc = loc_service_unregister(sid);
    789         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     980        rc = loc_service_unregister(srv, sid);
     981        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     982        loc_server_unregister(srv);
    790983}
    791984
    … …  
    801994        gfx_rect_t nrect;
    802995        test_response_t resp;
    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);
     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);
    8111005        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8121006
    … …  
    8491043        display_window_destroy(wnd);
    8501044        display_close(disp);
    851         rc = loc_service_unregister(sid);
    852         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1045        rc = loc_service_unregister(srv, sid);
     1046        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1047        loc_server_unregister(srv);
    8531048}
    8541049
    … …  
    8641059        gfx_rect_t nrect;
    8651060        test_response_t resp;
    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);
     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);
    8741070        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8751071
    … …  
    9111107        display_window_destroy(wnd);
    9121108        display_close(disp);
    913         rc = loc_service_unregister(sid);
    914         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     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. */
     1115PCUT_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. */
     1165PCUT_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. */
     1215PCUT_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. */
     1265PCUT_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);
    9151312}
    9161313
    … …  
    9241321        display_window_t *wnd;
    9251322        test_response_t resp;
    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);
     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);
    9341332        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9351333
    … …  
    9611359        display_window_destroy(wnd);
    9621360        display_close(disp);
    963         rc = loc_service_unregister(sid);
    964         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1361        rc = loc_service_unregister(srv, sid);
     1362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1363        loc_server_unregister(srv);
    9651364}
    9661365
    … …  
    9741373        display_window_t *wnd;
    9751374        test_response_t resp;
    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);
     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);
    9841384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9851385
    … …  
    10111411        display_window_destroy(wnd);
    10121412        display_close(disp);
    1013         rc = loc_service_unregister(sid);
    1014         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     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. */
     1419PCUT_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. */
     1475PCUT_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);
    10151528}
    10161529
    … …  
    10251538        test_response_t resp;
    10261539        gfx_context_t *gc;
    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);
     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);
    10351549        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10361550
    … …  
    10631577
    10641578        display_close(disp);
    1065         rc = loc_service_unregister(sid);
    1066         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1579        rc = loc_service_unregister(srv, sid);
     1580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1581        loc_server_unregister(srv);
    10671582}
    10681583
    … …  
    10781593        gfx_context_t *gc;
    10791594        gfx_color_t *color;
    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);
     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);
    10881604        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10891605
    … …  
    11241640
    11251641        display_close(disp);
    1126         rc = loc_service_unregister(sid);
    1127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1642        rc = loc_service_unregister(srv, sid);
     1643        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1644        loc_server_unregister(srv);
    11281645}
    11291646
    … …  
    11371654        display_window_t *wnd;
    11381655        test_response_t resp;
    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);
     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);
    11471665        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11481666
    … …  
    11891707        display_close(disp);
    11901708
    1191         rc = loc_service_unregister(sid);
    1192         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1709        rc = loc_service_unregister(srv, sid);
     1710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1711        loc_server_unregister(srv);
    11931712}
    11941713
    … …  
    12021721        display_window_t *wnd;
    12031722        test_response_t resp;
    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);
     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);
    12121732        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12131733
    … …  
    12321752        resp.event_cnt = 1;
    12331753        resp.event.etype = wev_focus;
     1754        resp.event.ev.focus.nfocus = 42;
    12341755        resp.wnd_id = wnd->id;
    12351756        resp.focus_event_called = false;
    … …  
    12481769        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    12491770            resp.revent.etype);
     1771        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     1772            resp.revent.ev.focus.nfocus);
    12501773
    12511774        rc = display_window_destroy(wnd);
    … …  
    12541777        display_close(disp);
    12551778
    1256         rc = loc_service_unregister(sid);
    1257         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1779        rc = loc_service_unregister(srv, sid);
     1780        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1781        loc_server_unregister(srv);
    12581782}
    12591783
    … …  
    12671791        display_window_t *wnd;
    12681792        test_response_t resp;
    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);
     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);
    12771802        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12781803
    … …  
    13311856        display_close(disp);
    13321857
    1333         rc = loc_service_unregister(sid);
    1334         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1858        rc = loc_service_unregister(srv, sid);
     1859        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1860        loc_server_unregister(srv);
    13351861}
    13361862
    … …  
    13441870        display_window_t *wnd;
    13451871        test_response_t resp;
    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);
     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);
    13541881        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13551882
    … …  
    14081935        display_close(disp);
    14091936
    1410         rc = loc_service_unregister(sid);
    1411         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1937        rc = loc_service_unregister(srv, sid);
     1938        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1939        loc_server_unregister(srv);
    14121940}
    14131941
    … …  
    14211949        display_window_t *wnd;
    14221950        test_response_t resp;
    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);
     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);
    14311960        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14321961
    … …  
    14511980        resp.event_cnt = 1;
    14521981        resp.event.etype = wev_unfocus;
     1982        resp.event.ev.unfocus.nfocus = 42;
    14531983        resp.wnd_id = wnd->id;
    14541984        resp.unfocus_event_called = false;
    … …  
    14671997        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    14681998            resp.revent.etype);
     1999        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     2000            resp.revent.ev.focus.nfocus);
    14692001
    14702002        rc = display_window_destroy(wnd);
    … …  
    14732005        display_close(disp);
    14742006
    1475         rc = loc_service_unregister(sid);
    1476         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2007        rc = loc_service_unregister(srv, sid);
     2008        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2009        loc_server_unregister(srv);
    14772010}
    14782011
    … …  
    14852018        display_info_t info;
    14862019        test_response_t resp;
    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);
     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);
    14952029        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14962030
    … …  
    15072041
    15082042        display_close(disp);
    1509         rc = loc_service_unregister(sid);
    1510         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2043        rc = loc_service_unregister(srv, sid);
     2044        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2045        loc_server_unregister(srv);
    15112046}
    15122047
    … …  
    15192054        display_info_t info;
    15202055        test_response_t resp;
    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);
     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);
    15292065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15302066
    … …  
    15492085
    15502086        display_close(disp);
    1551         rc = loc_service_unregister(sid);
    1552         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2087        rc = loc_service_unregister(srv, sid);
     2088        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2089        loc_server_unregister(srv);
    15532090}
    15542091
    … …  
    16122149}
    16132150
    1614 static void test_focus_event(void *arg)
     2151static void test_focus_event(void *arg, unsigned nfocus)
    16152152{
    16162153        test_response_t *resp = (test_response_t *) arg;
    16172154
    16182155        resp->revent.etype = wev_focus;
     2156        resp->revent.ev.focus.nfocus = nfocus;
    16192157
    16202158        fibril_mutex_lock(&resp->event_lock);
    … …  
    16502188}
    16512189
    1652 static void test_unfocus_event(void *arg)
     2190static void test_unfocus_event(void *arg, unsigned nfocus)
    16532191{
    16542192        test_response_t *resp = (test_response_t *) arg;
    16552193
    16562194        resp->revent.etype = wev_unfocus;
     2195        resp->revent.ev.unfocus.nfocus = nfocus;
    16572196
    16582197        fibril_mutex_lock(&resp->event_lock);
    … …  
    16702209        resp->create_rect = params->rect;
    16712210        resp->create_min_size = params->min_size;
     2211        resp->create_idev_id = params->idev_id;
    16722212        if (resp->rc == EOK)
    16732213                *rwnd_id = resp->wnd_id;
    … …  
    16862226
    16872227static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    1688     gfx_coord2_t *pos)
     2228    gfx_coord2_t *pos, sysarg_t pos_id)
    16892229{
    16902230        test_response_t *resp = (test_response_t *) arg;
    … …  
    16932233        resp->move_req_wnd_id = wnd_id;
    16942234        resp->move_req_pos = *pos;
     2235        resp->move_req_pos_id = pos_id;
    16952236        return resp->rc;
    16962237}
    … …  
    17192260}
    17202261
     2262static 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
    17212276static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    1722     display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
     2277    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    17232278{
    17242279        test_response_t *resp = (test_response_t *) arg;
    … …  
    17282283        resp->resize_req_wnd_id = wnd_id;
    17292284        resp->resize_req_pos = *pos;
     2285        resp->resize_req_pos_id = pos_id;
    17302286        return resp->rc;
    17312287}
    … …  
    17432299}
    17442300
     2301static 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
     2310static 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
     2319static 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
    17452328static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    17462329    display_stock_cursor_t cursor)
    … …  
    17512334        resp->set_cursor_wnd_id = wnd_id;
    17522335        resp->set_cursor_cursor = cursor;
     2336
     2337        return resp->rc;
     2338}
     2339
     2340static 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);
    17532348
    17542349        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.