Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4ac11ff rca48672  
    11/*
    2  * Copyright (c) 2019 Jiri Svoboda
     2 * Copyright (c) 2025 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 *);
     62static 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 *);
    6164static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
    62     gfx_coord2_t *);
     65    gfx_coord2_t *, sysarg_t);
    6366static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6467    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);
    6571static 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 *);
    6673static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    6774static errno_t test_get_info(void *, display_info_t *);
    … …  
    7481        .window_move_req = test_window_move_req,
    7582        .window_move = test_window_move,
     83        .window_get_pos = test_window_get_pos,
     84        .window_get_max_rect = test_window_get_max_rect,
    7685        .window_resize_req = test_window_resize_req,
    7786        .window_resize = test_window_resize,
     87        .window_minimize = test_window_minimize,
     88        .window_maximize = test_window_maximize,
     89        .window_unmaximize = test_window_unmaximize,
    7890        .window_set_cursor = test_window_set_cursor,
     91        .window_set_caption = test_window_set_caption,
    7992        .get_event = test_get_event,
    8093        .get_info = test_get_info
    … …  
    105118        gfx_rect_t create_rect;
    106119        gfx_coord2_t create_min_size;
     120        sysarg_t create_idev_id;
    107121        bool window_destroy_called;
    108122        sysarg_t destroy_wnd_id;
    … …  
    111125        sysarg_t move_req_wnd_id;
    112126        gfx_coord2_t move_req_pos;
     127        sysarg_t move_req_pos_id;
    113128
    114129        bool window_move_called;
    115130        sysarg_t move_wnd_id;
    116131        gfx_coord2_t move_dpos;
     132
     133        bool window_get_pos_called;
     134        sysarg_t get_pos_wnd_id;
     135        gfx_coord2_t get_pos_rpos;
     136
     137        bool window_get_max_rect_called;
     138        sysarg_t get_max_rect_wnd_id;
     139        gfx_rect_t get_max_rect_rrect;
    117140
    118141        bool window_resize_req_called;
    … …  
    120143        display_wnd_rsztype_t resize_req_rsztype;
    121144        gfx_coord2_t resize_req_pos;
     145        sysarg_t resize_req_pos_id;
    122146
    123147        bool window_resize_called;
    … …  
    126150        sysarg_t resize_wnd_id;
    127151
     152        bool window_minimize_called;
     153        bool window_maximize_called;
     154        bool window_unmaximize_called;
     155
    128156        bool window_set_cursor_called;
    129157        sysarg_t set_cursor_wnd_id;
    130158        display_stock_cursor_t set_cursor_cursor;
    131159
     160        bool window_set_caption_called;
     161        sysarg_t set_caption_wnd_id;
     162        char *set_caption_caption;
     163
    132164        bool get_event_called;
    133165
    … …  
    137169        bool set_color_called;
    138170        bool close_event_called;
     171
    139172        bool focus_event_called;
    140173        bool kbd_event_called;
    … …  
    153186        display_t *disp = NULL;
    154187        test_response_t resp;
    155 
    156         async_set_fallback_port_handler(test_display_conn, &resp);
    157 
    158         // FIXME This causes this test to be non-reentrant!
    159         rc = loc_server_register(test_display_server);
    160         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    161 
    162         rc = loc_service_register(test_display_svc, &sid);
    163         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    164 
    165         rc = display_open(test_display_svc, &disp);
    166         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    167         PCUT_ASSERT_NOT_NULL(disp);
    168 
    169         display_close(disp);
    170         rc = loc_service_unregister(sid);
    171         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     188        loc_srv_t *srv;
     189
     190        async_set_fallback_port_handler(test_display_conn, &resp);
     191
     192        // FIXME This causes this test to be non-reentrant!
     193        rc = loc_server_register(test_display_server, &srv);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195
     196        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     197            &sid);
     198        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     199
     200        rc = display_open(test_display_svc, &disp);
     201        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     202        PCUT_ASSERT_NOT_NULL(disp);
     203
     204        display_close(disp);
     205        rc = loc_service_unregister(srv, sid);
     206        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     207        loc_server_unregister(srv);
    172208}
    173209
    … …  
    181217        display_window_t *wnd;
    182218        test_response_t resp;
    183 
    184         async_set_fallback_port_handler(test_display_conn, &resp);
    185 
    186         // FIXME This causes this test to be non-reentrant!
    187         rc = loc_server_register(test_display_server);
    188         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    189 
    190         rc = loc_service_register(test_display_svc, &sid);
     219        loc_srv_t *srv;
     220
     221        async_set_fallback_port_handler(test_display_conn, &resp);
     222
     223        // FIXME This causes this test to be non-reentrant!
     224        rc = loc_server_register(test_display_server, &srv);
     225        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     226
     227        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     228            &sid);
    191229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    192230
    … …  
    205243        params.min_size.x = 11;
    206244        params.min_size.y = 12;
     245        params.idev_id = 42;
    207246
    208247        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    215254        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    216255        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
     256        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    217257        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    218258        PCUT_ASSERT_NULL(wnd);
    219259
    220260        display_close(disp);
    221         rc = loc_service_unregister(sid);
    222         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     261        rc = loc_service_unregister(srv, sid);
     262        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     263        loc_server_unregister(srv);
    223264}
    224265
    … …  
    235276        display_window_t *wnd;
    236277        test_response_t resp;
    237 
    238         async_set_fallback_port_handler(test_display_conn, &resp);
    239 
    240         // FIXME This causes this test to be non-reentrant!
    241         rc = loc_server_register(test_display_server);
    242         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    243 
    244         rc = loc_service_register(test_display_svc, &sid);
     278        loc_srv_t *srv;
     279
     280        async_set_fallback_port_handler(test_display_conn, &resp);
     281
     282        // FIXME This causes this test to be non-reentrant!
     283        rc = loc_server_register(test_display_server, &srv);
     284        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     285
     286        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     287            &sid);
    245288        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    246289
    … …  
    257300        params.rect.p0.x = 100;
    258301        params.rect.p0.y = 100;
     302        params.idev_id = 42;
    259303
    260304        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    265309        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    266310        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
     311        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    267312        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    268313        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    275320
    276321        display_close(disp);
    277         rc = loc_service_unregister(sid);
    278         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     322        rc = loc_service_unregister(srv, sid);
     323        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     324        loc_server_unregister(srv);
    279325}
    280326
    … …  
    288334        display_window_t *wnd;
    289335        test_response_t resp;
    290 
    291         async_set_fallback_port_handler(test_display_conn, &resp);
    292 
    293         // FIXME This causes this test to be non-reentrant!
    294         rc = loc_server_register(test_display_server);
    295         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    296 
    297         rc = loc_service_register(test_display_svc, &sid);
     336        loc_srv_t *srv;
     337
     338        async_set_fallback_port_handler(test_display_conn, &resp);
     339
     340        // FIXME This causes this test to be non-reentrant!
     341        rc = loc_server_register(test_display_server, &srv);
     342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     343
     344        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     345            &sid);
    298346        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    299347
    … …  
    328376
    329377        display_close(disp);
    330         rc = loc_service_unregister(sid);
    331         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     378        rc = loc_service_unregister(srv, sid);
     379        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     380        loc_server_unregister(srv);
    332381}
    333382
    … …  
    348397        test_response_t resp;
    349398        gfx_coord2_t pos;
    350 
    351         async_set_fallback_port_handler(test_display_conn, &resp);
    352 
    353         // FIXME This causes this test to be non-reentrant!
    354         rc = loc_server_register(test_display_server);
    355         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    356 
    357         rc = loc_service_register(test_display_svc, &sid);
     399        sysarg_t pos_id;
     400        loc_srv_t *srv;
     401
     402        async_set_fallback_port_handler(test_display_conn, &resp);
     403
     404        // FIXME This causes this test to be non-reentrant!
     405        rc = loc_server_register(test_display_server, &srv);
     406        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     407
     408        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     409            &sid);
    358410        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    359411
    … …  
    379431        pos.x = 42;
    380432        pos.y = 43;
    381 
    382         rc = display_window_move_req(wnd, &pos);
     433        pos_id = 44;
     434
     435        rc = display_window_move_req(wnd, &pos, pos_id);
    383436        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    384437        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    386439        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    387440        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     441        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    388442
    389443        display_window_destroy(wnd);
    390444        display_close(disp);
    391         rc = loc_service_unregister(sid);
    392         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     445        rc = loc_service_unregister(srv, sid);
     446        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     447        loc_server_unregister(srv);
    393448}
    394449
    … …  
    403458        test_response_t resp;
    404459        gfx_coord2_t pos;
    405 
    406         async_set_fallback_port_handler(test_display_conn, &resp);
    407 
    408         // FIXME This causes this test to be non-reentrant!
    409         rc = loc_server_register(test_display_server);
    410         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    411 
    412         rc = loc_service_register(test_display_svc, &sid);
     460        sysarg_t pos_id;
     461        loc_srv_t *srv;
     462
     463        async_set_fallback_port_handler(test_display_conn, &resp);
     464
     465        // FIXME This causes this test to be non-reentrant!
     466        rc = loc_server_register(test_display_server, &srv);
     467        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     468
     469        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     470            &sid);
    413471        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    414472
    … …  
    434492        pos.x = 42;
    435493        pos.y = 43;
    436 
    437         rc = display_window_move_req(wnd, &pos);
     494        pos_id = 44;
     495
     496        rc = display_window_move_req(wnd, &pos, pos_id);
    438497        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    439498        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    441500        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    442501        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     502        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    443503
    444504        display_window_destroy(wnd);
    445505        display_close(disp);
    446         rc = loc_service_unregister(sid);
    447         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     506        rc = loc_service_unregister(srv, sid);
     507        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     508        loc_server_unregister(srv);
    448509}
    449510
    … …  
    458519        gfx_coord2_t dpos;
    459520        test_response_t resp;
    460 
    461         async_set_fallback_port_handler(test_display_conn, &resp);
    462 
    463         // FIXME This causes this test to be non-reentrant!
    464         rc = loc_server_register(test_display_server);
    465         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    466 
    467         rc = loc_service_register(test_display_svc, &sid);
     521        loc_srv_t *srv;
     522
     523        async_set_fallback_port_handler(test_display_conn, &resp);
     524
     525        // FIXME This causes this test to be non-reentrant!
     526        rc = loc_server_register(test_display_server, &srv);
     527        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     528
     529        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     530            &sid);
    468531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    469532
    … …  
    498561        display_window_destroy(wnd);
    499562        display_close(disp);
    500         rc = loc_service_unregister(sid);
    501         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     563        rc = loc_service_unregister(srv, sid);
     564        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     565        loc_server_unregister(srv);
    502566}
    503567
    … …  
    512576        gfx_coord2_t dpos;
    513577        test_response_t resp;
    514 
    515         async_set_fallback_port_handler(test_display_conn, &resp);
    516 
    517         // FIXME This causes this test to be non-reentrant!
    518         rc = loc_server_register(test_display_server);
    519         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    520 
    521         rc = loc_service_register(test_display_svc, &sid);
     578        loc_srv_t *srv;
     579
     580        async_set_fallback_port_handler(test_display_conn, &resp);
     581
     582        // FIXME This causes this test to be non-reentrant!
     583        rc = loc_server_register(test_display_server, &srv);
     584        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     585
     586        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     587            &sid);
    522588        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    523589
    … …  
    552618        display_window_destroy(wnd);
    553619        display_close(disp);
    554         rc = loc_service_unregister(sid);
    555         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     620        rc = loc_service_unregister(srv, sid);
     621        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     622        loc_server_unregister(srv);
     623}
     624
     625/** display_window_get_pos() with server returning error response works. */
     626PCUT_TEST(window_get_pos_failure)
     627{
     628        errno_t rc;
     629        service_id_t sid;
     630        display_t *disp = NULL;
     631        display_wnd_params_t params;
     632        display_window_t *wnd;
     633        gfx_coord2_t dpos;
     634        test_response_t resp;
     635        loc_srv_t *srv;
     636
     637        async_set_fallback_port_handler(test_display_conn, &resp);
     638
     639        // FIXME This causes this test to be non-reentrant!
     640        rc = loc_server_register(test_display_server, &srv);
     641        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     642
     643        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     644            &sid);
     645        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     646
     647        rc = display_open(test_display_svc, &disp);
     648        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     649        PCUT_ASSERT_NOT_NULL(disp);
     650
     651        resp.rc = EOK;
     652        display_wnd_params_init(&params);
     653        params.rect.p0.x = 0;
     654        params.rect.p0.y = 0;
     655        params.rect.p0.x = 100;
     656        params.rect.p0.y = 100;
     657
     658        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     659            (void *) &resp, &wnd);
     660        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     661        PCUT_ASSERT_NOT_NULL(wnd);
     662
     663        resp.rc = EIO;
     664        resp.window_get_pos_called = false;
     665
     666        dpos.x = 0;
     667        dpos.y = 0;
     668
     669        rc = display_window_get_pos(wnd, &dpos);
     670        PCUT_ASSERT_TRUE(resp.window_get_pos_called);
     671        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     672        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
     673        PCUT_ASSERT_INT_EQUALS(0, dpos.x);
     674        PCUT_ASSERT_INT_EQUALS(0, dpos.y);
     675
     676        display_window_destroy(wnd);
     677        display_close(disp);
     678        rc = loc_service_unregister(srv, sid);
     679        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     680        loc_server_unregister(srv);
     681}
     682
     683/** display_window_get_pos() with server returning success response works. */
     684PCUT_TEST(window_get_pos_success)
     685{
     686        errno_t rc;
     687        service_id_t sid;
     688        display_t *disp = NULL;
     689        display_wnd_params_t params;
     690        display_window_t *wnd;
     691        gfx_coord2_t dpos;
     692        test_response_t resp;
     693        loc_srv_t *srv;
     694
     695        async_set_fallback_port_handler(test_display_conn, &resp);
     696
     697        // FIXME This causes this test to be non-reentrant!
     698        rc = loc_server_register(test_display_server, &srv);
     699        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     700
     701        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     702            &sid);
     703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     704
     705        rc = display_open(test_display_svc, &disp);
     706        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     707        PCUT_ASSERT_NOT_NULL(disp);
     708
     709        resp.rc = EOK;
     710        display_wnd_params_init(&params);
     711        params.rect.p0.x = 0;
     712        params.rect.p0.y = 0;
     713        params.rect.p0.x = 100;
     714        params.rect.p0.y = 100;
     715
     716        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     717            (void *) &resp, &wnd);
     718        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     719        PCUT_ASSERT_NOT_NULL(wnd);
     720
     721        resp.rc = EOK;
     722        resp.window_get_pos_called = false;
     723        resp.get_pos_rpos.x = 11;
     724        resp.get_pos_rpos.y = 12;
     725
     726        dpos.x = 0;
     727        dpos.y = 0;
     728
     729        rc = display_window_get_pos(wnd, &dpos);
     730        PCUT_ASSERT_TRUE(resp.window_get_pos_called);
     731        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     732        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
     733        PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.x, dpos.x);
     734        PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.y, dpos.y);
     735
     736        display_window_destroy(wnd);
     737        display_close(disp);
     738        rc = loc_service_unregister(srv, sid);
     739        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     740        loc_server_unregister(srv);
     741}
     742
     743/** display_window_get_max_rect() with server returning error response works. */
     744PCUT_TEST(window_get_max_rect_failure)
     745{
     746        errno_t rc;
     747        service_id_t sid;
     748        display_t *disp = NULL;
     749        display_wnd_params_t params;
     750        display_window_t *wnd;
     751        gfx_rect_t rect;
     752        test_response_t resp;
     753        loc_srv_t *srv;
     754
     755        async_set_fallback_port_handler(test_display_conn, &resp);
     756
     757        // FIXME This causes this test to be non-reentrant!
     758        rc = loc_server_register(test_display_server, &srv);
     759        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     760
     761        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     762            &sid);
     763        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     764
     765        rc = display_open(test_display_svc, &disp);
     766        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     767        PCUT_ASSERT_NOT_NULL(disp);
     768
     769        resp.rc = EOK;
     770        display_wnd_params_init(&params);
     771        params.rect.p0.x = 0;
     772        params.rect.p0.y = 0;
     773        params.rect.p0.x = 100;
     774        params.rect.p0.y = 100;
     775
     776        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     777            (void *) &resp, &wnd);
     778        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     779        PCUT_ASSERT_NOT_NULL(wnd);
     780
     781        resp.rc = EIO;
     782        resp.window_get_max_rect_called = false;
     783
     784        rect.p0.x = 0;
     785        rect.p0.y = 0;
     786        rect.p1.x = 0;
     787        rect.p1.y = 0;
     788
     789        rc = display_window_get_max_rect(wnd, &rect);
     790        PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
     791        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     792        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
     793        PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
     794        PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
     795        PCUT_ASSERT_INT_EQUALS(0, rect.p1.x);
     796        PCUT_ASSERT_INT_EQUALS(0, rect.p1.y);
     797
     798        display_window_destroy(wnd);
     799        display_close(disp);
     800        rc = loc_service_unregister(srv, sid);
     801        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     802        loc_server_unregister(srv);
     803}
     804
     805/** display_window_get_max_rect() with server returning success response works. */
     806PCUT_TEST(window_get_max_rect_success)
     807{
     808        errno_t rc;
     809        service_id_t sid;
     810        display_t *disp = NULL;
     811        display_wnd_params_t params;
     812        display_window_t *wnd;
     813        gfx_rect_t rect;
     814        test_response_t resp;
     815        loc_srv_t *srv;
     816
     817        async_set_fallback_port_handler(test_display_conn, &resp);
     818
     819        // FIXME This causes this test to be non-reentrant!
     820        rc = loc_server_register(test_display_server, &srv);
     821        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     822
     823        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     824            &sid);
     825        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     826
     827        rc = display_open(test_display_svc, &disp);
     828        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     829        PCUT_ASSERT_NOT_NULL(disp);
     830
     831        resp.rc = EOK;
     832        display_wnd_params_init(&params);
     833        params.rect.p0.x = 0;
     834        params.rect.p0.y = 0;
     835        params.rect.p0.x = 100;
     836        params.rect.p0.y = 100;
     837
     838        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     839            (void *) &resp, &wnd);
     840        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     841        PCUT_ASSERT_NOT_NULL(wnd);
     842
     843        resp.rc = EOK;
     844        resp.window_get_max_rect_called = false;
     845        resp.get_max_rect_rrect.p0.x = 11;
     846        resp.get_max_rect_rrect.p0.y = 12;
     847        resp.get_max_rect_rrect.p1.x = 13;
     848        resp.get_max_rect_rrect.p1.y = 14;
     849
     850        rect.p0.x = 0;
     851        rect.p0.y = 0;
     852        rect.p1.x = 0;
     853        rect.p1.y = 0;
     854
     855        rc = display_window_get_max_rect(wnd, &rect);
     856        PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
     857        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     858        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
     859        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x);
     860        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y);
     861        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x);
     862        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y);
     863
     864        display_window_destroy(wnd);
     865        display_close(disp);
     866        rc = loc_service_unregister(srv, sid);
     867        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     868        loc_server_unregister(srv);
    556869}
    557870
    … …  
    567880        display_wnd_rsztype_t rsztype;
    568881        gfx_coord2_t pos;
    569 
    570         async_set_fallback_port_handler(test_display_conn, &resp);
    571 
    572         // FIXME This causes this test to be non-reentrant!
    573         rc = loc_server_register(test_display_server);
    574         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    575 
    576         rc = loc_service_register(test_display_svc, &sid);
     882        sysarg_t pos_id;
     883        loc_srv_t *srv;
     884
     885        async_set_fallback_port_handler(test_display_conn, &resp);
     886
     887        // FIXME This causes this test to be non-reentrant!
     888        rc = loc_server_register(test_display_server, &srv);
     889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     890
     891        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     892            &sid);
    577893        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    578894
    … …  
    599915        pos.x = 42;
    600916        pos.y = 43;
    601 
    602         rc = display_window_resize_req(wnd, rsztype, &pos);
     917        pos_id = 44;
     918
     919        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    603920        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    604921        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    607924        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    608925        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     926        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    609927
    610928        display_window_destroy(wnd);
    611929        display_close(disp);
    612         rc = loc_service_unregister(sid);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     930        rc = loc_service_unregister(srv, sid);
     931        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     932        loc_server_unregister(srv);
    614933}
    615934
    … …  
    625944        display_wnd_rsztype_t rsztype;
    626945        gfx_coord2_t pos;
    627 
    628         async_set_fallback_port_handler(test_display_conn, &resp);
    629 
    630         // FIXME This causes this test to be non-reentrant!
    631         rc = loc_server_register(test_display_server);
    632         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    633 
    634         rc = loc_service_register(test_display_svc, &sid);
     946        sysarg_t pos_id;
     947        loc_srv_t *srv;
     948
     949        async_set_fallback_port_handler(test_display_conn, &resp);
     950
     951        // FIXME This causes this test to be non-reentrant!
     952        rc = loc_server_register(test_display_server, &srv);
     953        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     954
     955        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     956            &sid);
    635957        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    636958
    … …  
    657979        pos.x = 42;
    658980        pos.y = 43;
    659 
    660         rc = display_window_resize_req(wnd, rsztype, &pos);
     981        pos_id = 44;
     982
     983        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    661984        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    662985        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    665988        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    666989        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     990        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    667991
    668992        display_window_destroy(wnd);
    669993        display_close(disp);
    670         rc = loc_service_unregister(sid);
    671         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     994        rc = loc_service_unregister(srv, sid);
     995        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     996        loc_server_unregister(srv);
    672997}
    673998
    … …  
    6831008        gfx_rect_t nrect;
    6841009        test_response_t resp;
    685 
    686         async_set_fallback_port_handler(test_display_conn, &resp);
    687 
    688         // FIXME This causes this test to be non-reentrant!
    689         rc = loc_server_register(test_display_server);
    690         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    691 
    692         rc = loc_service_register(test_display_svc, &sid);
     1010        loc_srv_t *srv;
     1011
     1012        async_set_fallback_port_handler(test_display_conn, &resp);
     1013
     1014        // FIXME This causes this test to be non-reentrant!
     1015        rc = loc_server_register(test_display_server, &srv);
     1016        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1017
     1018        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1019            &sid);
    6931020        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    6941021
    … …  
    7311058        display_window_destroy(wnd);
    7321059        display_close(disp);
    733         rc = loc_service_unregister(sid);
    734         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1060        rc = loc_service_unregister(srv, sid);
     1061        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1062        loc_server_unregister(srv);
    7351063}
    7361064
    … …  
    7461074        gfx_rect_t nrect;
    7471075        test_response_t resp;
    748 
    749         async_set_fallback_port_handler(test_display_conn, &resp);
    750 
    751         // FIXME This causes this test to be non-reentrant!
    752         rc = loc_server_register(test_display_server);
    753         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    754 
    755         rc = loc_service_register(test_display_svc, &sid);
     1076        loc_srv_t *srv;
     1077
     1078        async_set_fallback_port_handler(test_display_conn, &resp);
     1079
     1080        // FIXME This causes this test to be non-reentrant!
     1081        rc = loc_server_register(test_display_server, &srv);
     1082        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1083
     1084        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1085            &sid);
    7561086        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    7571087
    … …  
    7931123        display_window_destroy(wnd);
    7941124        display_close(disp);
    795         rc = loc_service_unregister(sid);
    796         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1125        rc = loc_service_unregister(srv, sid);
     1126        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1127        loc_server_unregister(srv);
     1128}
     1129
     1130/** display_window_minimize() with server returning error response works. */
     1131PCUT_TEST(window_minimize_failure)
     1132{
     1133        errno_t rc;
     1134        service_id_t sid;
     1135        display_t *disp = NULL;
     1136        display_wnd_params_t params;
     1137        display_window_t *wnd;
     1138        test_response_t resp;
     1139        loc_srv_t *srv;
     1140
     1141        async_set_fallback_port_handler(test_display_conn, &resp);
     1142
     1143        // FIXME This causes this test to be non-reentrant!
     1144        rc = loc_server_register(test_display_server, &srv);
     1145        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1146
     1147        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1148            &sid);
     1149        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1150
     1151        rc = display_open(test_display_svc, &disp);
     1152        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1153        PCUT_ASSERT_NOT_NULL(disp);
     1154
     1155        resp.rc = EOK;
     1156        display_wnd_params_init(&params);
     1157        params.rect.p0.x = 0;
     1158        params.rect.p0.y = 0;
     1159        params.rect.p0.x = 100;
     1160        params.rect.p0.y = 100;
     1161
     1162        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1163            (void *) &resp, &wnd);
     1164        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1165        PCUT_ASSERT_NOT_NULL(wnd);
     1166
     1167        resp.rc = EIO;
     1168        resp.window_minimize_called = false;
     1169
     1170        rc = display_window_minimize(wnd);
     1171        PCUT_ASSERT_TRUE(resp.window_minimize_called);
     1172        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1173
     1174        display_window_destroy(wnd);
     1175        display_close(disp);
     1176        rc = loc_service_unregister(srv, sid);
     1177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1178        loc_server_unregister(srv);
     1179}
     1180
     1181/** display_window_minimize() with server returning success response works. */
     1182PCUT_TEST(window_minimize_success)
     1183{
     1184        errno_t rc;
     1185        service_id_t sid;
     1186        display_t *disp = NULL;
     1187        display_wnd_params_t params;
     1188        display_window_t *wnd;
     1189        test_response_t resp;
     1190        loc_srv_t *srv;
     1191
     1192        async_set_fallback_port_handler(test_display_conn, &resp);
     1193
     1194        // FIXME This causes this test to be non-reentrant!
     1195        rc = loc_server_register(test_display_server, &srv);
     1196        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1197
     1198        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1199            &sid);
     1200        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1201
     1202        rc = display_open(test_display_svc, &disp);
     1203        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1204        PCUT_ASSERT_NOT_NULL(disp);
     1205
     1206        resp.rc = EOK;
     1207        display_wnd_params_init(&params);
     1208        params.rect.p0.x = 0;
     1209        params.rect.p0.y = 0;
     1210        params.rect.p0.x = 100;
     1211        params.rect.p0.y = 100;
     1212
     1213        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1214            (void *) &resp, &wnd);
     1215        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1216        PCUT_ASSERT_NOT_NULL(wnd);
     1217
     1218        resp.rc = EOK;
     1219        resp.window_minimize_called = false;
     1220
     1221        rc = display_window_minimize(wnd);
     1222        PCUT_ASSERT_TRUE(resp.window_minimize_called);
     1223        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1224
     1225        display_window_destroy(wnd);
     1226        display_close(disp);
     1227        rc = loc_service_unregister(srv, sid);
     1228        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1229        loc_server_unregister(srv);
     1230}
     1231
     1232/** display_window_maximize() with server returning error response works. */
     1233PCUT_TEST(window_maximize_failure)
     1234{
     1235        errno_t rc;
     1236        service_id_t sid;
     1237        display_t *disp = NULL;
     1238        display_wnd_params_t params;
     1239        display_window_t *wnd;
     1240        test_response_t resp;
     1241        loc_srv_t *srv;
     1242
     1243        async_set_fallback_port_handler(test_display_conn, &resp);
     1244
     1245        // FIXME This causes this test to be non-reentrant!
     1246        rc = loc_server_register(test_display_server, &srv);
     1247        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1248
     1249        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1250            &sid);
     1251        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1252
     1253        rc = display_open(test_display_svc, &disp);
     1254        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1255        PCUT_ASSERT_NOT_NULL(disp);
     1256
     1257        resp.rc = EOK;
     1258        display_wnd_params_init(&params);
     1259        params.rect.p0.x = 0;
     1260        params.rect.p0.y = 0;
     1261        params.rect.p0.x = 100;
     1262        params.rect.p0.y = 100;
     1263
     1264        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1265            (void *) &resp, &wnd);
     1266        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1267        PCUT_ASSERT_NOT_NULL(wnd);
     1268
     1269        resp.rc = EIO;
     1270        resp.window_maximize_called = false;
     1271
     1272        rc = display_window_maximize(wnd);
     1273        PCUT_ASSERT_TRUE(resp.window_maximize_called);
     1274        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1275
     1276        display_window_destroy(wnd);
     1277        display_close(disp);
     1278        rc = loc_service_unregister(srv, sid);
     1279        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1280        loc_server_unregister(srv);
     1281}
     1282
     1283/** display_window_maximize() with server returning success response works. */
     1284PCUT_TEST(window_maximize_success)
     1285{
     1286        errno_t rc;
     1287        service_id_t sid;
     1288        display_t *disp = NULL;
     1289        display_wnd_params_t params;
     1290        display_window_t *wnd;
     1291        test_response_t resp;
     1292        loc_srv_t *srv;
     1293
     1294        async_set_fallback_port_handler(test_display_conn, &resp);
     1295
     1296        // FIXME This causes this test to be non-reentrant!
     1297        rc = loc_server_register(test_display_server, &srv);
     1298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1299
     1300        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1301            &sid);
     1302        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1303
     1304        rc = display_open(test_display_svc, &disp);
     1305        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1306        PCUT_ASSERT_NOT_NULL(disp);
     1307
     1308        resp.rc = EOK;
     1309        display_wnd_params_init(&params);
     1310        params.rect.p0.x = 0;
     1311        params.rect.p0.y = 0;
     1312        params.rect.p0.x = 100;
     1313        params.rect.p0.y = 100;
     1314
     1315        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1316            (void *) &resp, &wnd);
     1317        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1318        PCUT_ASSERT_NOT_NULL(wnd);
     1319
     1320        resp.rc = EOK;
     1321        resp.window_maximize_called = false;
     1322
     1323        rc = display_window_maximize(wnd);
     1324        PCUT_ASSERT_TRUE(resp.window_maximize_called);
     1325        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1326
     1327        display_window_destroy(wnd);
     1328        display_close(disp);
     1329        rc = loc_service_unregister(srv, sid);
     1330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1331        loc_server_unregister(srv);
    7971332}
    7981333
    … …  
    8061341        display_window_t *wnd;
    8071342        test_response_t resp;
    808 
    809         async_set_fallback_port_handler(test_display_conn, &resp);
    810 
    811         // FIXME This causes this test to be non-reentrant!
    812         rc = loc_server_register(test_display_server);
    813         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    814 
    815         rc = loc_service_register(test_display_svc, &sid);
     1343        loc_srv_t *srv;
     1344
     1345        async_set_fallback_port_handler(test_display_conn, &resp);
     1346
     1347        // FIXME This causes this test to be non-reentrant!
     1348        rc = loc_server_register(test_display_server, &srv);
     1349        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1350
     1351        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1352            &sid);
    8161353        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8171354
    … …  
    8431380        display_window_destroy(wnd);
    8441381        display_close(disp);
    845         rc = loc_service_unregister(sid);
    846         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1382        rc = loc_service_unregister(srv, sid);
     1383        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1384        loc_server_unregister(srv);
    8471385}
    8481386
    … …  
    8561394        display_window_t *wnd;
    8571395        test_response_t resp;
    858 
    859         async_set_fallback_port_handler(test_display_conn, &resp);
    860 
    861         // FIXME This causes this test to be non-reentrant!
    862         rc = loc_server_register(test_display_server);
    863         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    864 
    865         rc = loc_service_register(test_display_svc, &sid);
     1396        loc_srv_t *srv;
     1397
     1398        async_set_fallback_port_handler(test_display_conn, &resp);
     1399
     1400        // FIXME This causes this test to be non-reentrant!
     1401        rc = loc_server_register(test_display_server, &srv);
     1402        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1403
     1404        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1405            &sid);
    8661406        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8671407
    … …  
    8931433        display_window_destroy(wnd);
    8941434        display_close(disp);
    895         rc = loc_service_unregister(sid);
    896         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1435        rc = loc_service_unregister(srv, sid);
     1436        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1437        loc_server_unregister(srv);
     1438}
     1439
     1440/** display_window_set_caption() with server returning error response works. */
     1441PCUT_TEST(window_set_caption_failure)
     1442{
     1443        errno_t rc;
     1444        service_id_t sid;
     1445        display_t *disp = NULL;
     1446        display_wnd_params_t params;
     1447        display_window_t *wnd;
     1448        const char *caption;
     1449        test_response_t resp;
     1450        loc_srv_t *srv;
     1451
     1452        async_set_fallback_port_handler(test_display_conn, &resp);
     1453
     1454        // FIXME This causes this test to be non-reentrant!
     1455        rc = loc_server_register(test_display_server, &srv);
     1456        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1457
     1458        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1459            &sid);
     1460        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1461
     1462        rc = display_open(test_display_svc, &disp);
     1463        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1464        PCUT_ASSERT_NOT_NULL(disp);
     1465
     1466        resp.rc = EOK;
     1467        display_wnd_params_init(&params);
     1468        params.rect.p0.x = 0;
     1469        params.rect.p0.y = 0;
     1470        params.rect.p0.x = 100;
     1471        params.rect.p0.y = 100;
     1472
     1473        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1474            (void *) &resp, &wnd);
     1475        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1476        PCUT_ASSERT_NOT_NULL(wnd);
     1477
     1478        caption = "Hello";
     1479
     1480        resp.rc = EIO;
     1481        resp.window_set_caption_called = false;
     1482
     1483        rc = display_window_set_caption(wnd, caption);
     1484        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
     1485        PCUT_ASSERT_TRUE(resp.window_set_caption_called);
     1486        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1487        PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
     1488
     1489        //free(resp.set_caption_caption);
     1490        display_window_destroy(wnd);
     1491        display_close(disp);
     1492        rc = loc_service_unregister(srv, sid);
     1493        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1494        loc_server_unregister(srv);
     1495}
     1496
     1497/** display_window_set_caption() with server returning success response works. */
     1498PCUT_TEST(window_set_caption_success)
     1499{
     1500        errno_t rc;
     1501        service_id_t sid;
     1502        display_t *disp = NULL;
     1503        display_wnd_params_t params;
     1504        display_window_t *wnd;
     1505        const char *caption;
     1506        test_response_t resp;
     1507        loc_srv_t *srv;
     1508
     1509        async_set_fallback_port_handler(test_display_conn, &resp);
     1510
     1511        // FIXME This causes this test to be non-reentrant!
     1512        rc = loc_server_register(test_display_server, &srv);
     1513        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1514
     1515        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1516            &sid);
     1517        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1518
     1519        rc = display_open(test_display_svc, &disp);
     1520        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1521        PCUT_ASSERT_NOT_NULL(disp);
     1522
     1523        resp.rc = EOK;
     1524        display_wnd_params_init(&params);
     1525        params.rect.p0.x = 0;
     1526        params.rect.p0.y = 0;
     1527        params.rect.p0.x = 100;
     1528        params.rect.p0.y = 100;
     1529
     1530        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1531            (void *) &resp, &wnd);
     1532        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1533        PCUT_ASSERT_NOT_NULL(wnd);
     1534
     1535        caption = "Hello";
     1536
     1537        resp.rc = EOK;
     1538        resp.window_set_caption_called = false;
     1539
     1540        rc = display_window_set_caption(wnd, caption);
     1541        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
     1542        PCUT_ASSERT_TRUE(resp.window_set_caption_called);
     1543        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1544        PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
     1545
     1546        //free(resp.set_caption_caption);
     1547        display_window_destroy(wnd);
     1548        display_close(disp);
     1549        rc = loc_service_unregister(srv, sid);
     1550        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1551        loc_server_unregister(srv);
    8971552}
    8981553
    … …  
    9071562        test_response_t resp;
    9081563        gfx_context_t *gc;
    909 
    910         async_set_fallback_port_handler(test_display_conn, &resp);
    911 
    912         // FIXME This causes this test to be non-reentrant!
    913         rc = loc_server_register(test_display_server);
    914         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    915 
    916         rc = loc_service_register(test_display_svc, &sid);
     1564        loc_srv_t *srv;
     1565
     1566        async_set_fallback_port_handler(test_display_conn, &resp);
     1567
     1568        // FIXME This causes this test to be non-reentrant!
     1569        rc = loc_server_register(test_display_server, &srv);
     1570        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1571
     1572        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1573            &sid);
    9171574        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9181575
    … …  
    9371594        resp.rc = ENOMEM;
    9381595        rc = display_window_get_gc(wnd, &gc);
    939         /* async_connect_me_to() does not return specific error */
    940         PCUT_ASSERT_ERRNO_VAL(EIO, rc);
     1596        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    9411597        PCUT_ASSERT_NULL(gc);
    9421598
    … …  
    9461602
    9471603        display_close(disp);
    948         rc = loc_service_unregister(sid);
    949         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1604        rc = loc_service_unregister(srv, sid);
     1605        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1606        loc_server_unregister(srv);
    9501607}
    9511608
    … …  
    9611618        gfx_context_t *gc;
    9621619        gfx_color_t *color;
    963 
    964         async_set_fallback_port_handler(test_display_conn, &resp);
    965 
    966         // FIXME This causes this test to be non-reentrant!
    967         rc = loc_server_register(test_display_server);
    968         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    969 
    970         rc = loc_service_register(test_display_svc, &sid);
     1620        loc_srv_t *srv;
     1621
     1622        async_set_fallback_port_handler(test_display_conn, &resp);
     1623
     1624        // FIXME This causes this test to be non-reentrant!
     1625        rc = loc_server_register(test_display_server, &srv);
     1626        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1627
     1628        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1629            &sid);
    9711630        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9721631
    … …  
    10071666
    10081667        display_close(disp);
    1009         rc = loc_service_unregister(sid);
    1010         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1668        rc = loc_service_unregister(srv, sid);
     1669        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1670        loc_server_unregister(srv);
    10111671}
    10121672
    … …  
    10201680        display_window_t *wnd;
    10211681        test_response_t resp;
    1022 
    1023         async_set_fallback_port_handler(test_display_conn, &resp);
    1024 
    1025         // FIXME This causes this test to be non-reentrant!
    1026         rc = loc_server_register(test_display_server);
    1027         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1028 
    1029         rc = loc_service_register(test_display_svc, &sid);
     1682        loc_srv_t *srv;
     1683
     1684        async_set_fallback_port_handler(test_display_conn, &resp);
     1685
     1686        // FIXME This causes this test to be non-reentrant!
     1687        rc = loc_server_register(test_display_server, &srv);
     1688        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1689
     1690        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1691            &sid);
    10301692        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10311693
    … …  
    10721734        display_close(disp);
    10731735
    1074         rc = loc_service_unregister(sid);
    1075         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1736        rc = loc_service_unregister(srv, sid);
     1737        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1738        loc_server_unregister(srv);
    10761739}
    10771740
    … …  
    10851748        display_window_t *wnd;
    10861749        test_response_t resp;
    1087 
    1088         async_set_fallback_port_handler(test_display_conn, &resp);
    1089 
    1090         // FIXME This causes this test to be non-reentrant!
    1091         rc = loc_server_register(test_display_server);
    1092         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1093 
    1094         rc = loc_service_register(test_display_svc, &sid);
     1750        loc_srv_t *srv;
     1751
     1752        async_set_fallback_port_handler(test_display_conn, &resp);
     1753
     1754        // FIXME This causes this test to be non-reentrant!
     1755        rc = loc_server_register(test_display_server, &srv);
     1756        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1757
     1758        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1759            &sid);
    10951760        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10961761
    … …  
    11151780        resp.event_cnt = 1;
    11161781        resp.event.etype = wev_focus;
     1782        resp.event.ev.focus.nfocus = 42;
    11171783        resp.wnd_id = wnd->id;
    11181784        resp.focus_event_called = false;
    … …  
    11311797        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    11321798            resp.revent.etype);
     1799        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     1800            resp.revent.ev.focus.nfocus);
    11331801
    11341802        rc = display_window_destroy(wnd);
    … …  
    11371805        display_close(disp);
    11381806
    1139         rc = loc_service_unregister(sid);
    1140         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1807        rc = loc_service_unregister(srv, sid);
     1808        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1809        loc_server_unregister(srv);
    11411810}
    11421811
    … …  
    11501819        display_window_t *wnd;
    11511820        test_response_t resp;
    1152 
    1153         async_set_fallback_port_handler(test_display_conn, &resp);
    1154 
    1155         // FIXME This causes this test to be non-reentrant!
    1156         rc = loc_server_register(test_display_server);
    1157         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1158 
    1159         rc = loc_service_register(test_display_svc, &sid);
     1821        loc_srv_t *srv;
     1822
     1823        async_set_fallback_port_handler(test_display_conn, &resp);
     1824
     1825        // FIXME This causes this test to be non-reentrant!
     1826        rc = loc_server_register(test_display_server, &srv);
     1827        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1828
     1829        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1830            &sid);
    11601831        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11611832
    … …  
    12141885        display_close(disp);
    12151886
    1216         rc = loc_service_unregister(sid);
    1217         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1887        rc = loc_service_unregister(srv, sid);
     1888        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1889        loc_server_unregister(srv);
    12181890}
    12191891
    … …  
    12271899        display_window_t *wnd;
    12281900        test_response_t resp;
    1229 
    1230         async_set_fallback_port_handler(test_display_conn, &resp);
    1231 
    1232         // FIXME This causes this test to be non-reentrant!
    1233         rc = loc_server_register(test_display_server);
    1234         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1235 
    1236         rc = loc_service_register(test_display_svc, &sid);
     1901        loc_srv_t *srv;
     1902
     1903        async_set_fallback_port_handler(test_display_conn, &resp);
     1904
     1905        // FIXME This causes this test to be non-reentrant!
     1906        rc = loc_server_register(test_display_server, &srv);
     1907        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1908
     1909        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1910            &sid);
    12371911        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12381912
    … …  
    12911965        display_close(disp);
    12921966
    1293         rc = loc_service_unregister(sid);
    1294         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1967        rc = loc_service_unregister(srv, sid);
     1968        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1969        loc_server_unregister(srv);
    12951970}
    12961971
    … …  
    13041979        display_window_t *wnd;
    13051980        test_response_t resp;
    1306 
    1307         async_set_fallback_port_handler(test_display_conn, &resp);
    1308 
    1309         // FIXME This causes this test to be non-reentrant!
    1310         rc = loc_server_register(test_display_server);
    1311         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1312 
    1313         rc = loc_service_register(test_display_svc, &sid);
     1981        loc_srv_t *srv;
     1982
     1983        async_set_fallback_port_handler(test_display_conn, &resp);
     1984
     1985        // FIXME This causes this test to be non-reentrant!
     1986        rc = loc_server_register(test_display_server, &srv);
     1987        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1988
     1989        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     1990            &sid);
    13141991        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13151992
    … …  
    13342011        resp.event_cnt = 1;
    13352012        resp.event.etype = wev_unfocus;
     2013        resp.event.ev.unfocus.nfocus = 42;
    13362014        resp.wnd_id = wnd->id;
    13372015        resp.unfocus_event_called = false;
    … …  
    13502028        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    13512029            resp.revent.etype);
     2030        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     2031            resp.revent.ev.focus.nfocus);
    13522032
    13532033        rc = display_window_destroy(wnd);
    … …  
    13562036        display_close(disp);
    13572037
    1358         rc = loc_service_unregister(sid);
    1359         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2038        rc = loc_service_unregister(srv, sid);
     2039        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2040        loc_server_unregister(srv);
    13602041}
    13612042
    … …  
    13682049        display_info_t info;
    13692050        test_response_t resp;
    1370 
    1371         async_set_fallback_port_handler(test_display_conn, &resp);
    1372 
    1373         // FIXME This causes this test to be non-reentrant!
    1374         rc = loc_server_register(test_display_server);
    1375         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1376 
    1377         rc = loc_service_register(test_display_svc, &sid);
     2051        loc_srv_t *srv;
     2052
     2053        async_set_fallback_port_handler(test_display_conn, &resp);
     2054
     2055        // FIXME This causes this test to be non-reentrant!
     2056        rc = loc_server_register(test_display_server, &srv);
     2057        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2058
     2059        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     2060            &sid);
    13782061        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13792062
    … …  
    13902073
    13912074        display_close(disp);
    1392         rc = loc_service_unregister(sid);
    1393         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2075        rc = loc_service_unregister(srv, sid);
     2076        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2077        loc_server_unregister(srv);
    13942078}
    13952079
    … …  
    14022086        display_info_t info;
    14032087        test_response_t resp;
    1404 
    1405         async_set_fallback_port_handler(test_display_conn, &resp);
    1406 
    1407         // FIXME This causes this test to be non-reentrant!
    1408         rc = loc_server_register(test_display_server);
    1409         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1410 
    1411         rc = loc_service_register(test_display_svc, &sid);
     2088        loc_srv_t *srv;
     2089
     2090        async_set_fallback_port_handler(test_display_conn, &resp);
     2091
     2092        // FIXME This causes this test to be non-reentrant!
     2093        rc = loc_server_register(test_display_server, &srv);
     2094        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2095
     2096        rc = loc_service_register(srv, test_display_svc, fallback_port_id,
     2097            &sid);
    14122098        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14132099
    … …  
    14322118
    14332119        display_close(disp);
    1434         rc = loc_service_unregister(sid);
    1435         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2120        rc = loc_service_unregister(srv, sid);
     2121        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2122        loc_server_unregister(srv);
    14362123}
    14372124
    … …  
    14952182}
    14962183
    1497 static void test_focus_event(void *arg)
     2184static void test_focus_event(void *arg, unsigned nfocus)
    14982185{
    14992186        test_response_t *resp = (test_response_t *) arg;
    15002187
    15012188        resp->revent.etype = wev_focus;
     2189        resp->revent.ev.focus.nfocus = nfocus;
    15022190
    15032191        fibril_mutex_lock(&resp->event_lock);
    … …  
    15332221}
    15342222
    1535 static void test_unfocus_event(void *arg)
     2223static void test_unfocus_event(void *arg, unsigned nfocus)
    15362224{
    15372225        test_response_t *resp = (test_response_t *) arg;
    15382226
    15392227        resp->revent.etype = wev_unfocus;
     2228        resp->revent.ev.unfocus.nfocus = nfocus;
    15402229
    15412230        fibril_mutex_lock(&resp->event_lock);
    … …  
    15532242        resp->create_rect = params->rect;
    15542243        resp->create_min_size = params->min_size;
     2244        resp->create_idev_id = params->idev_id;
    15552245        if (resp->rc == EOK)
    15562246                *rwnd_id = resp->wnd_id;
    … …  
    15692259
    15702260static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    1571     gfx_coord2_t *pos)
     2261    gfx_coord2_t *pos, sysarg_t pos_id)
    15722262{
    15732263        test_response_t *resp = (test_response_t *) arg;
    … …  
    15762266        resp->move_req_wnd_id = wnd_id;
    15772267        resp->move_req_pos = *pos;
     2268        resp->move_req_pos_id = pos_id;
    15782269        return resp->rc;
    15792270}
    … …  
    15892280}
    15902281
     2282static errno_t test_window_get_pos(void *arg, sysarg_t wnd_id, gfx_coord2_t *dpos)
     2283{
     2284        test_response_t *resp = (test_response_t *) arg;
     2285
     2286        resp->window_get_pos_called = true;
     2287        resp->get_pos_wnd_id = wnd_id;
     2288
     2289        if (resp->rc == EOK)
     2290                *dpos = resp->get_pos_rpos;
     2291
     2292        return resp->rc;
     2293}
     2294
     2295static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id,
     2296    gfx_rect_t *rect)
     2297{
     2298        test_response_t *resp = (test_response_t *) arg;
     2299
     2300        resp->window_get_max_rect_called = true;
     2301        resp->get_max_rect_wnd_id = wnd_id;
     2302
     2303        if (resp->rc == EOK)
     2304                *rect = resp->get_max_rect_rrect;
     2305
     2306        return resp->rc;
     2307}
     2308
    15912309static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    1592     display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
     2310    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    15932311{
    15942312        test_response_t *resp = (test_response_t *) arg;
    … …  
    15982316        resp->resize_req_wnd_id = wnd_id;
    15992317        resp->resize_req_pos = *pos;
     2318        resp->resize_req_pos_id = pos_id;
    16002319        return resp->rc;
    16012320}
    … …  
    16132332}
    16142333
     2334static errno_t test_window_minimize(void *arg, sysarg_t wnd_id)
     2335{
     2336        test_response_t *resp = (test_response_t *) arg;
     2337
     2338        resp->window_minimize_called = true;
     2339        resp->resize_wnd_id = wnd_id;
     2340        return resp->rc;
     2341}
     2342
     2343static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
     2344{
     2345        test_response_t *resp = (test_response_t *) arg;
     2346
     2347        resp->window_maximize_called = true;
     2348        resp->resize_wnd_id = wnd_id;
     2349        return resp->rc;
     2350}
     2351
     2352static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id)
     2353{
     2354        test_response_t *resp = (test_response_t *) arg;
     2355
     2356        resp->window_unmaximize_called = true;
     2357        resp->resize_wnd_id = wnd_id;
     2358        return resp->rc;
     2359}
     2360
    16152361static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    16162362    display_stock_cursor_t cursor)
    … …  
    16212367        resp->set_cursor_wnd_id = wnd_id;
    16222368        resp->set_cursor_cursor = cursor;
     2369
     2370        return resp->rc;
     2371}
     2372
     2373static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id,
     2374    const char *caption)
     2375{
     2376        test_response_t *resp = (test_response_t *) arg;
     2377
     2378        resp->window_set_caption_called = true;
     2379        resp->set_caption_wnd_id = wnd_id;
     2380        resp->set_caption_caption = str_dup(caption);
    16232381
    16242382        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.