Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rc9927c66 rca48672  
    11/*
    2  * Copyright (c) 2021 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 *);
    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, 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);
    178208}
    179209
    … …  
    187217        display_window_t *wnd;
    188218        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);
     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);
    197229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    198230
    … …  
    211243        params.min_size.x = 11;
    212244        params.min_size.y = 12;
     245        params.idev_id = 42;
    213246
    214247        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    221254        PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
    222255        PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
     256        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    223257        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    224258        PCUT_ASSERT_NULL(wnd);
    225259
    226260        display_close(disp);
    227         rc = loc_service_unregister(sid);
    228         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);
    229264}
    230265
    … …  
    241276        display_window_t *wnd;
    242277        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);
     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);
    251288        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    252289
    … …  
    263300        params.rect.p0.x = 100;
    264301        params.rect.p0.y = 100;
     302        params.idev_id = 42;
    265303
    266304        rc = display_window_create(disp, &params, &test_display_wnd_cb,
    … …  
    271309        PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
    272310        PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
     311        PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id);
    273312        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    274313        PCUT_ASSERT_NOT_NULL(wnd);
    … …  
    281320
    282321        display_close(disp);
    283         rc = loc_service_unregister(sid);
    284         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);
    285325}
    286326
    … …  
    294334        display_window_t *wnd;
    295335        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);
     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);
    304346        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    305347
    … …  
    334376
    335377        display_close(disp);
    336         rc = loc_service_unregister(sid);
    337         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);
    338381}
    339382
    … …  
    354397        test_response_t resp;
    355398        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);
     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);
    364410        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    365411
    … …  
    385431        pos.x = 42;
    386432        pos.y = 43;
    387 
    388         rc = display_window_move_req(wnd, &pos);
     433        pos_id = 44;
     434
     435        rc = display_window_move_req(wnd, &pos, pos_id);
    389436        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    390437        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    392439        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    393440        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     441        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    394442
    395443        display_window_destroy(wnd);
    396444        display_close(disp);
    397         rc = loc_service_unregister(sid);
    398         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);
    399448}
    400449
    … …  
    409458        test_response_t resp;
    410459        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);
     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);
    419471        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    420472
    … …  
    440492        pos.x = 42;
    441493        pos.y = 43;
    442 
    443         rc = display_window_move_req(wnd, &pos);
     494        pos_id = 44;
     495
     496        rc = display_window_move_req(wnd, &pos, pos_id);
    444497        PCUT_ASSERT_TRUE(resp.window_move_req_called);
    445498        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    447500        PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
    448501        PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
     502        PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
    449503
    450504        display_window_destroy(wnd);
    451505        display_close(disp);
    452         rc = loc_service_unregister(sid);
    453         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);
    454509}
    455510
    … …  
    464519        gfx_coord2_t dpos;
    465520        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);
     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);
    474531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    475532
    … …  
    504561        display_window_destroy(wnd);
    505562        display_close(disp);
    506         rc = loc_service_unregister(sid);
    507         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);
    508566}
    509567
    … …  
    518576        gfx_coord2_t dpos;
    519577        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);
     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);
    528588        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    529589
    … …  
    558618        display_window_destroy(wnd);
    559619        display_close(disp);
    560         rc = loc_service_unregister(sid);
    561         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);
    562623}
    563624
    … …  
    572633        gfx_coord2_t dpos;
    573634        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);
     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);
    582645        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    583646
    … …  
    613676        display_window_destroy(wnd);
    614677        display_close(disp);
    615         rc = loc_service_unregister(sid);
    616         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     678        rc = loc_service_unregister(srv, sid);
     679        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     680        loc_server_unregister(srv);
    617681}
    618682
    … …  
    627691        gfx_coord2_t dpos;
    628692        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);
     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);
    637703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    638704
    … …  
    670736        display_window_destroy(wnd);
    671737        display_close(disp);
    672         rc = loc_service_unregister(sid);
    673         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     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);
    674869}
    675870
    … …  
    685880        display_wnd_rsztype_t rsztype;
    686881        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);
     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);
    695893        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    696894
    … …  
    717915        pos.x = 42;
    718916        pos.y = 43;
    719 
    720         rc = display_window_resize_req(wnd, rsztype, &pos);
     917        pos_id = 44;
     918
     919        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    721920        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    722921        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    725924        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    726925        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     926        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    727927
    728928        display_window_destroy(wnd);
    729929        display_close(disp);
    730         rc = loc_service_unregister(sid);
    731         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);
    732933}
    733934
    … …  
    743944        display_wnd_rsztype_t rsztype;
    744945        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);
     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);
    753957        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    754958
    … …  
    775979        pos.x = 42;
    776980        pos.y = 43;
    777 
    778         rc = display_window_resize_req(wnd, rsztype, &pos);
     981        pos_id = 44;
     982
     983        rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
    779984        PCUT_ASSERT_TRUE(resp.window_resize_req_called);
    780985        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    … …  
    783988        PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
    784989        PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
     990        PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
    785991
    786992        display_window_destroy(wnd);
    787993        display_close(disp);
    788         rc = loc_service_unregister(sid);
    789         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);
    790997}
    791998
    … …  
    8011008        gfx_rect_t nrect;
    8021009        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);
     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);
    8111020        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8121021
    … …  
    8491058        display_window_destroy(wnd);
    8501059        display_close(disp);
    851         rc = loc_service_unregister(sid);
    852         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);
    8531063}
    8541064
    … …  
    8641074        gfx_rect_t nrect;
    8651075        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);
     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);
    8741086        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    8751087
    … …  
    9111123        display_window_destroy(wnd);
    9121124        display_close(disp);
    913         rc = loc_service_unregister(sid);
    914         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);
    9151332}
    9161333
    … …  
    9241341        display_window_t *wnd;
    9251342        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);
     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);
    9341353        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9351354
    … …  
    9611380        display_window_destroy(wnd);
    9621381        display_close(disp);
    963         rc = loc_service_unregister(sid);
    964         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);
    9651385}
    9661386
    … …  
    9741394        display_window_t *wnd;
    9751395        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);
     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);
    9841406        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9851407
    … …  
    10111433        display_window_destroy(wnd);
    10121434        display_close(disp);
    1013         rc = loc_service_unregister(sid);
    1014         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);
    10151552}
    10161553
    … …  
    10251562        test_response_t resp;
    10261563        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);
     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);
    10351574        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10361575
    … …  
    10631602
    10641603        display_close(disp);
    1065         rc = loc_service_unregister(sid);
    1066         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);
    10671607}
    10681608
    … …  
    10781618        gfx_context_t *gc;
    10791619        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);
     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);
    10881630        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10891631
    … …  
    11241666
    11251667        display_close(disp);
    1126         rc = loc_service_unregister(sid);
    1127         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);
    11281671}
    11291672
    … …  
    11371680        display_window_t *wnd;
    11381681        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);
     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);
    11471692        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11481693
    … …  
    11891734        display_close(disp);
    11901735
    1191         rc = loc_service_unregister(sid);
    1192         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);
    11931739}
    11941740
    … …  
    12021748        display_window_t *wnd;
    12031749        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);
     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);
    12121760        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12131761
    … …  
    12321780        resp.event_cnt = 1;
    12331781        resp.event.etype = wev_focus;
     1782        resp.event.ev.focus.nfocus = 42;
    12341783        resp.wnd_id = wnd->id;
    12351784        resp.focus_event_called = false;
    … …  
    12481797        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    12491798            resp.revent.etype);
     1799        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     1800            resp.revent.ev.focus.nfocus);
    12501801
    12511802        rc = display_window_destroy(wnd);
    … …  
    12541805        display_close(disp);
    12551806
    1256         rc = loc_service_unregister(sid);
    1257         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);
    12581810}
    12591811
    … …  
    12671819        display_window_t *wnd;
    12681820        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);
     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);
    12771831        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12781832
    … …  
    13311885        display_close(disp);
    13321886
    1333         rc = loc_service_unregister(sid);
    1334         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);
    13351890}
    13361891
    … …  
    13441899        display_window_t *wnd;
    13451900        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);
     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);
    13541911        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13551912
    … …  
    14081965        display_close(disp);
    14091966
    1410         rc = loc_service_unregister(sid);
    1411         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);
    14121970}
    14131971
    … …  
    14211979        display_window_t *wnd;
    14221980        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);
     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);
    14311991        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14321992
    … …  
    14512011        resp.event_cnt = 1;
    14522012        resp.event.etype = wev_unfocus;
     2013        resp.event.ev.unfocus.nfocus = 42;
    14532014        resp.wnd_id = wnd->id;
    14542015        resp.unfocus_event_called = false;
    … …  
    14672028        PCUT_ASSERT_INT_EQUALS(resp.event.etype,
    14682029            resp.revent.etype);
     2030        PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
     2031            resp.revent.ev.focus.nfocus);
    14692032
    14702033        rc = display_window_destroy(wnd);
    … …  
    14732036        display_close(disp);
    14742037
    1475         rc = loc_service_unregister(sid);
    1476         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);
    14772041}
    14782042
    … …  
    14852049        display_info_t info;
    14862050        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);
     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);
    14952061        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14962062
    … …  
    15072073
    15082074        display_close(disp);
    1509         rc = loc_service_unregister(sid);
    1510         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);
    15112078}
    15122079
    … …  
    15192086        display_info_t info;
    15202087        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);
     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);
    15292098        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15302099
    … …  
    15492118
    15502119        display_close(disp);
    1551         rc = loc_service_unregister(sid);
    1552         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);
    15532123}
    15542124
    … …  
    16122182}
    16132183
    1614 static void test_focus_event(void *arg)
     2184static void test_focus_event(void *arg, unsigned nfocus)
    16152185{
    16162186        test_response_t *resp = (test_response_t *) arg;
    16172187
    16182188        resp->revent.etype = wev_focus;
     2189        resp->revent.ev.focus.nfocus = nfocus;
    16192190
    16202191        fibril_mutex_lock(&resp->event_lock);
    … …  
    16502221}
    16512222
    1652 static void test_unfocus_event(void *arg)
     2223static void test_unfocus_event(void *arg, unsigned nfocus)
    16532224{
    16542225        test_response_t *resp = (test_response_t *) arg;
    16552226
    16562227        resp->revent.etype = wev_unfocus;
     2228        resp->revent.ev.unfocus.nfocus = nfocus;
    16572229
    16582230        fibril_mutex_lock(&resp->event_lock);
    … …  
    16702242        resp->create_rect = params->rect;
    16712243        resp->create_min_size = params->min_size;
     2244        resp->create_idev_id = params->idev_id;
    16722245        if (resp->rc == EOK)
    16732246                *rwnd_id = resp->wnd_id;
    … …  
    16862259
    16872260static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
    1688     gfx_coord2_t *pos)
     2261    gfx_coord2_t *pos, sysarg_t pos_id)
    16892262{
    16902263        test_response_t *resp = (test_response_t *) arg;
    … …  
    16932266        resp->move_req_wnd_id = wnd_id;
    16942267        resp->move_req_pos = *pos;
     2268        resp->move_req_pos_id = pos_id;
    16952269        return resp->rc;
    16962270}
    … …  
    17192293}
    17202294
     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
    17212309static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    1722     display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
     2310    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
    17232311{
    17242312        test_response_t *resp = (test_response_t *) arg;
    … …  
    17282316        resp->resize_req_wnd_id = wnd_id;
    17292317        resp->resize_req_pos = *pos;
     2318        resp->resize_req_pos_id = pos_id;
    17302319        return resp->rc;
    17312320}
    … …  
    17432332}
    17442333
     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
    17452361static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
    17462362    display_stock_cursor_t cursor)
    … …  
    17512367        resp->set_cursor_wnd_id = wnd_id;
    17522368        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);
    17532381
    17542382        return resp->rc;
Note: See TracChangeset for help on using the changeset viewer.