Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ipcgfx/test/ipcgfx.c

    rafcf704 rca48672  
    11/*
    2  * Copyright (c) 2019 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5050static void test_ipcgc_conn(ipc_call_t *, void *);
    5151
     52static errno_t test_gc_set_clip_rect(void *, gfx_rect_t *);
    5253static errno_t test_gc_set_color(void *, gfx_color_t *);
    5354static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
     55static errno_t test_gc_update(void *);
    5456static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
    5557    gfx_bitmap_alloc_t *, void **);
    … …  
    5961
    6062static gfx_context_ops_t test_gc_ops = {
     63        .set_clip_rect = test_gc_set_clip_rect,
    6164        .set_color = test_gc_set_color,
    6265        .fill_rect = test_gc_fill_rect,
     66        .update = test_gc_update,
    6367        .bitmap_create = test_gc_bitmap_create,
    6468        .bitmap_destroy = test_gc_bitmap_destroy,
    … …  
    7377        errno_t rc;
    7478
     79        bool set_clip_rect_called;
     80        bool do_clip;
     81        gfx_rect_t set_clip_rect_rect;
     82
    7583        bool set_color_called;
    7684        uint16_t set_color_r;
    … …  
    8088        bool fill_rect_called;
    8189        gfx_rect_t fill_rect_rect;
     90
     91        bool update_called;
    8292
    8393        bool bitmap_create_called;
    … …  
    100110} test_bitmap_t;
    101111
     112/** gfx_set_clip_rect with server returning failure */
     113PCUT_TEST(set_clip_rect_failure)
     114{
     115        errno_t rc;
     116        service_id_t sid;
     117        test_response_t resp;
     118        gfx_context_t *gc;
     119        gfx_rect_t rect;
     120        async_sess_t *sess;
     121        ipc_gc_t *ipcgc;
     122        loc_srv_t *srv;
     123
     124        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     125
     126        // FIXME This causes this test to be non-reentrant!
     127        rc = loc_server_register(test_ipcgfx_server, &srv);
     128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     129
     130        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     132
     133        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     134        PCUT_ASSERT_NOT_NULL(sess);
     135
     136        rc = ipc_gc_create(sess, &ipcgc);
     137        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     138
     139        gc = ipc_gc_get_ctx(ipcgc);
     140        PCUT_ASSERT_NOT_NULL(gc);
     141
     142        resp.rc = ENOMEM;
     143        resp.set_clip_rect_called = false;
     144        rect.p0.x = 1;
     145        rect.p0.y = 2;
     146        rect.p1.x = 3;
     147        rect.p1.y = 4;
     148        rc = gfx_set_clip_rect(gc, &rect);
     149        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     150        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     151        PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
     152        PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
     153        PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
     154        PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
     155
     156        ipc_gc_delete(ipcgc);
     157        async_hangup(sess);
     158
     159        rc = loc_service_unregister(srv, sid);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161        loc_server_unregister(srv);
     162}
     163
     164/** gfx_set_clip_rect with server returning success */
     165PCUT_TEST(set_clip_rect_success)
     166{
     167        errno_t rc;
     168        service_id_t sid;
     169        test_response_t resp;
     170        gfx_context_t *gc;
     171        gfx_rect_t rect;
     172        async_sess_t *sess;
     173        ipc_gc_t *ipcgc;
     174        loc_srv_t *srv;
     175
     176        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     177
     178        // FIXME This causes this test to be non-reentrant!
     179        rc = loc_server_register(test_ipcgfx_server, &srv);
     180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     181
     182        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     183        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     184
     185        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     186        PCUT_ASSERT_NOT_NULL(sess);
     187
     188        rc = ipc_gc_create(sess, &ipcgc);
     189        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     190
     191        gc = ipc_gc_get_ctx(ipcgc);
     192        PCUT_ASSERT_NOT_NULL(gc);
     193
     194        resp.rc = EOK;
     195        resp.set_clip_rect_called = false;
     196        rect.p0.x = 1;
     197        rect.p0.y = 2;
     198        rect.p1.x = 3;
     199        rect.p1.y = 4;
     200        rc = gfx_set_clip_rect(gc, &rect);
     201        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     202        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     203        PCUT_ASSERT_TRUE(resp.do_clip);
     204        PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
     205        PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
     206        PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
     207        PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
     208
     209        ipc_gc_delete(ipcgc);
     210        async_hangup(sess);
     211
     212        rc = loc_service_unregister(srv, sid);
     213        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     214        loc_server_unregister(srv);
     215}
     216
     217/** gfx_set_clip_rect with null rectangle, server returning success */
     218PCUT_TEST(set_clip_rect_null_success)
     219{
     220        errno_t rc;
     221        service_id_t sid;
     222        test_response_t resp;
     223        gfx_context_t *gc;
     224        async_sess_t *sess;
     225        ipc_gc_t *ipcgc;
     226        loc_srv_t *srv;
     227
     228        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     229
     230        // FIXME This causes this test to be non-reentrant!
     231        rc = loc_server_register(test_ipcgfx_server, &srv);
     232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     233
     234        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     235        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     236
     237        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     238        PCUT_ASSERT_NOT_NULL(sess);
     239
     240        rc = ipc_gc_create(sess, &ipcgc);
     241        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     242
     243        gc = ipc_gc_get_ctx(ipcgc);
     244        PCUT_ASSERT_NOT_NULL(gc);
     245
     246        resp.rc = EOK;
     247        resp.set_clip_rect_called = false;
     248
     249        rc = gfx_set_clip_rect(gc, NULL);
     250        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     251        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     252        PCUT_ASSERT_FALSE(resp.do_clip);
     253
     254        ipc_gc_delete(ipcgc);
     255        async_hangup(sess);
     256
     257        rc = loc_service_unregister(srv, sid);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        loc_server_unregister(srv);
     260}
     261
    102262/** gfx_set_color with server returning failure */
    103263PCUT_TEST(set_color_failure)
    … …  
    110270        async_sess_t *sess;
    111271        ipc_gc_t *ipcgc;
    112 
    113         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    114 
    115         // FIXME This causes this test to be non-reentrant!
    116         rc = loc_server_register(test_ipcgfx_server);
    117         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    118 
    119         rc = loc_service_register(test_ipcgfx_svc, &sid);
     272        loc_srv_t *srv;
     273
     274        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     275
     276        // FIXME This causes this test to be non-reentrant!
     277        rc = loc_server_register(test_ipcgfx_server, &srv);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279
     280        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    120281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    121282
    … …  
    146307        async_hangup(sess);
    147308
    148         rc = loc_service_unregister(sid);
    149         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     309        rc = loc_service_unregister(srv, sid);
     310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     311        loc_server_unregister(srv);
    150312}
    151313
    … …  
    160322        async_sess_t *sess;
    161323        ipc_gc_t *ipcgc;
    162 
    163         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    164 
    165         // FIXME This causes this test to be non-reentrant!
    166         rc = loc_server_register(test_ipcgfx_server);
    167         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    168 
    169         rc = loc_service_register(test_ipcgfx_svc, &sid);
     324        loc_srv_t *srv;
     325
     326        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     327
     328        // FIXME This causes this test to be non-reentrant!
     329        rc = loc_server_register(test_ipcgfx_server, &srv);
     330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     331
     332        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    170333        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    171334
    … …  
    196359        async_hangup(sess);
    197360
    198         rc = loc_service_unregister(sid);
    199         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     361        rc = loc_service_unregister(srv, sid);
     362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     363        loc_server_unregister(srv);
    200364}
    201365
    … …  
    210374        async_sess_t *sess;
    211375        ipc_gc_t *ipcgc;
    212 
    213         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    214 
    215         // FIXME This causes this test to be non-reentrant!
    216         rc = loc_server_register(test_ipcgfx_server);
    217         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    218 
    219         rc = loc_service_register(test_ipcgfx_svc, &sid);
     376        loc_srv_t *srv;
     377
     378        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     379
     380        // FIXME This causes this test to be non-reentrant!
     381        rc = loc_server_register(test_ipcgfx_server, &srv);
     382        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     383
     384        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    220385        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    221386
    … …  
    230395
    231396        resp.rc = ENOMEM;
    232         resp.set_color_called = false;
     397        resp.fill_rect_called = false;
    233398        rect.p0.x = 1;
    234399        rect.p0.y = 2;
    … …  
    246411        async_hangup(sess);
    247412
    248         rc = loc_service_unregister(sid);
    249         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     413        rc = loc_service_unregister(srv, sid);
     414        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     415        loc_server_unregister(srv);
    250416}
    251417
    … …  
    260426        async_sess_t *sess;
    261427        ipc_gc_t *ipcgc;
    262 
    263         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    264 
    265         // FIXME This causes this test to be non-reentrant!
    266         rc = loc_server_register(test_ipcgfx_server);
    267         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    268 
    269         rc = loc_service_register(test_ipcgfx_svc, &sid);
    270         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    271 
    272         sess = loc_service_connect(sid, INTERFACE_GC, 0);
    273         PCUT_ASSERT_NOT_NULL(sess);
    274 
    275         rc = ipc_gc_create(sess, &ipcgc);
    276         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    277 
    278         gc = ipc_gc_get_ctx(ipcgc);
    279         PCUT_ASSERT_NOT_NULL(gc);
    280 
    281         resp.rc = EOK;
    282         resp.set_color_called = false;
     428        loc_srv_t *srv;
     429
     430        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     431
     432        // FIXME This causes this test to be non-reentrant!
     433        rc = loc_server_register(test_ipcgfx_server, &srv);
     434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     435
     436        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     438
     439        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     440        PCUT_ASSERT_NOT_NULL(sess);
     441
     442        rc = ipc_gc_create(sess, &ipcgc);
     443        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     444
     445        gc = ipc_gc_get_ctx(ipcgc);
     446        PCUT_ASSERT_NOT_NULL(gc);
     447
     448        resp.rc = EOK;
     449        resp.fill_rect_called = false;
    283450        rect.p0.x = 1;
    284451        rect.p0.y = 2;
    … …  
    296463        async_hangup(sess);
    297464
    298         rc = loc_service_unregister(sid);
    299         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     465        rc = loc_service_unregister(srv, sid);
     466        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     467        loc_server_unregister(srv);
     468}
     469
     470/** gfx_update with server returning failure */
     471PCUT_TEST(update_failure)
     472{
     473        errno_t rc;
     474        service_id_t sid;
     475        test_response_t resp;
     476        gfx_context_t *gc;
     477        async_sess_t *sess;
     478        ipc_gc_t *ipcgc;
     479        loc_srv_t *srv;
     480
     481        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     482
     483        // FIXME This causes this test to be non-reentrant!
     484        rc = loc_server_register(test_ipcgfx_server, &srv);
     485        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     486
     487        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     488        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     489
     490        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     491        PCUT_ASSERT_NOT_NULL(sess);
     492
     493        rc = ipc_gc_create(sess, &ipcgc);
     494        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     495
     496        gc = ipc_gc_get_ctx(ipcgc);
     497        PCUT_ASSERT_NOT_NULL(gc);
     498
     499        resp.rc = ENOMEM;
     500        resp.update_called = false;
     501        rc = gfx_update(gc);
     502        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     503        PCUT_ASSERT_TRUE(resp.update_called);
     504
     505        ipc_gc_delete(ipcgc);
     506        async_hangup(sess);
     507
     508        rc = loc_service_unregister(srv, sid);
     509        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     510        loc_server_unregister(srv);
     511}
     512
     513/** gfx_update with server returning success */
     514PCUT_TEST(update_success)
     515{
     516        errno_t rc;
     517        service_id_t sid;
     518        test_response_t resp;
     519        gfx_context_t *gc;
     520        async_sess_t *sess;
     521        ipc_gc_t *ipcgc;
     522        loc_srv_t *srv;
     523
     524        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     525
     526        // FIXME This causes this test to be non-reentrant!
     527        rc = loc_server_register(test_ipcgfx_server, &srv);
     528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     529
     530        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
     531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     532
     533        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     534        PCUT_ASSERT_NOT_NULL(sess);
     535
     536        rc = ipc_gc_create(sess, &ipcgc);
     537        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     538
     539        gc = ipc_gc_get_ctx(ipcgc);
     540        PCUT_ASSERT_NOT_NULL(gc);
     541
     542        resp.rc = EOK;
     543        resp.update_called = false;
     544        rc = gfx_update(gc);
     545        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     546        PCUT_ASSERT_TRUE(resp.update_called);
     547
     548        ipc_gc_delete(ipcgc);
     549        async_hangup(sess);
     550
     551        rc = loc_service_unregister(srv, sid);
     552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553        loc_server_unregister(srv);
    300554}
    301555
    … …  
    311565        async_sess_t *sess;
    312566        ipc_gc_t *ipcgc;
    313 
    314         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    315 
    316         // FIXME This causes this test to be non-reentrant!
    317         rc = loc_server_register(test_ipcgfx_server);
    318         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    319 
    320         rc = loc_service_register(test_ipcgfx_svc, &sid);
     567        loc_srv_t *srv;
     568
     569        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     570
     571        // FIXME This causes this test to be non-reentrant!
     572        rc = loc_server_register(test_ipcgfx_server, &srv);
     573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     574
     575        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    321576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    322577
    … …  
    355610        async_hangup(sess);
    356611
    357         rc = loc_service_unregister(sid);
    358         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     612        rc = loc_service_unregister(srv, sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614        loc_server_unregister(srv);
    359615}
    360616
    … …  
    370626        async_sess_t *sess;
    371627        ipc_gc_t *ipcgc;
    372 
    373         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    374 
    375         // FIXME This causes this test to be non-reentrant!
    376         rc = loc_server_register(test_ipcgfx_server);
    377         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    378 
    379         rc = loc_service_register(test_ipcgfx_svc, &sid);
     628        loc_srv_t *srv;
     629
     630        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     631
     632        // FIXME This causes this test to be non-reentrant!
     633        rc = loc_server_register(test_ipcgfx_server, &srv);
     634        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     635
     636        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    380637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    381638
    … …  
    419676        async_hangup(sess);
    420677
    421         rc = loc_service_unregister(sid);
    422         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);
    423681}
    424682
    … …  
    434692        async_sess_t *sess;
    435693        ipc_gc_t *ipcgc;
    436 
    437         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    438 
    439         // FIXME This causes this test to be non-reentrant!
    440         rc = loc_server_register(test_ipcgfx_server);
    441         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    442 
    443         rc = loc_service_register(test_ipcgfx_svc, &sid);
     694        loc_srv_t *srv;
     695
     696        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     697
     698        // FIXME This causes this test to be non-reentrant!
     699        rc = loc_server_register(test_ipcgfx_server, &srv);
     700        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     701
     702        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    444703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    445704
    … …  
    472731        async_hangup(sess);
    473732
    474         rc = loc_service_unregister(sid);
    475         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     733        rc = loc_service_unregister(srv, sid);
     734        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     735        loc_server_unregister(srv);
    476736}
    477737
    … …  
    487747        async_sess_t *sess;
    488748        ipc_gc_t *ipcgc;
    489 
    490         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    491 
    492         // FIXME This causes this test to be non-reentrant!
    493         rc = loc_server_register(test_ipcgfx_server);
    494         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    495 
    496         rc = loc_service_register(test_ipcgfx_svc, &sid);
     749        loc_srv_t *srv;
     750
     751        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     752
     753        // FIXME This causes this test to be non-reentrant!
     754        rc = loc_server_register(test_ipcgfx_server, &srv);
     755        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     756
     757        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    497758        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    498759
    … …  
    532793        async_hangup(sess);
    533794
    534         rc = loc_service_unregister(sid);
    535         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     795        rc = loc_service_unregister(srv, sid);
     796        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     797        loc_server_unregister(srv);
    536798}
    537799
    … …  
    547809        async_sess_t *sess;
    548810        ipc_gc_t *ipcgc;
    549 
    550         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    551 
    552         // FIXME This causes this test to be non-reentrant!
    553         rc = loc_server_register(test_ipcgfx_server);
    554         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    555 
    556         rc = loc_service_register(test_ipcgfx_svc, &sid);
     811        loc_srv_t *srv;
     812
     813        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     814
     815        // FIXME This causes this test to be non-reentrant!
     816        rc = loc_server_register(test_ipcgfx_server, &srv);
     817        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     818
     819        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    557820        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    558821
    … …  
    597860        async_hangup(sess);
    598861
    599         rc = loc_service_unregister(sid);
    600         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     862        rc = loc_service_unregister(srv, sid);
     863        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     864        loc_server_unregister(srv);
    601865}
    602866
    … …  
    614878        async_sess_t *sess;
    615879        ipc_gc_t *ipcgc;
    616 
    617         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    618 
    619         // FIXME This causes this test to be non-reentrant!
    620         rc = loc_server_register(test_ipcgfx_server);
    621         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    622 
    623         rc = loc_service_register(test_ipcgfx_svc, &sid);
     880        loc_srv_t *srv;
     881
     882        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     883
     884        // FIXME This causes this test to be non-reentrant!
     885        rc = loc_server_register(test_ipcgfx_server, &srv);
     886        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     887
     888        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    624889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    625890
    … …  
    665930        async_hangup(sess);
    666931
    667         rc = loc_service_unregister(sid);
    668         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     932        rc = loc_service_unregister(srv, sid);
     933        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     934        loc_server_unregister(srv);
    669935}
    670936
    … …  
    682948        async_sess_t *sess;
    683949        ipc_gc_t *ipcgc;
    684 
    685         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    686 
    687         // FIXME This causes this test to be non-reentrant!
    688         rc = loc_server_register(test_ipcgfx_server);
    689         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    690 
    691         rc = loc_service_register(test_ipcgfx_svc, &sid);
     950        loc_srv_t *srv;
     951
     952        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     953
     954        // FIXME This causes this test to be non-reentrant!
     955        rc = loc_server_register(test_ipcgfx_server, &srv);
     956        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     957
     958        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    692959        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    693960
    … …  
    7331000        async_hangup(sess);
    7341001
    735         rc = loc_service_unregister(sid);
    736         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1002        rc = loc_service_unregister(srv, sid);
     1003        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1004        loc_server_unregister(srv);
    7371005}
    7381006
    … …  
    7491017        async_sess_t *sess;
    7501018        ipc_gc_t *ipcgc;
    751 
    752         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    753 
    754         // FIXME This causes this test to be non-reentrant!
    755         rc = loc_server_register(test_ipcgfx_server);
    756         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    757 
    758         rc = loc_service_register(test_ipcgfx_svc, &sid);
     1019        loc_srv_t *srv;
     1020
     1021        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     1022
     1023        // FIXME This causes this test to be non-reentrant!
     1024        rc = loc_server_register(test_ipcgfx_server, &srv);
     1025        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1026
     1027        rc = loc_service_register(srv, test_ipcgfx_svc, fallback_port_id, &sid);
    7591028        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    7601029
    … …  
    7931062        async_hangup(sess);
    7941063
    795         rc = loc_service_unregister(sid);
    796         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1064        rc = loc_service_unregister(srv, sid);
     1065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1066        loc_server_unregister(srv);
    7971067}
    7981068
    … …  
    8121082}
    8131083
     1084/** Set clipping rectangle in test GC.
     1085 *
     1086 * @param arg Test GC
     1087 * @param rect Rectangle
     1088 *
     1089 * @return EOK on success or an error code
     1090 */
     1091static errno_t test_gc_set_clip_rect(void *arg, gfx_rect_t *rect)
     1092{
     1093        test_response_t *resp = (test_response_t *) arg;
     1094
     1095        resp->set_clip_rect_called = true;
     1096        if (rect != NULL) {
     1097                resp->do_clip = true;
     1098                resp->set_clip_rect_rect = *rect;
     1099        } else {
     1100                resp->do_clip = false;
     1101        }
     1102
     1103        return resp->rc;
     1104}
     1105
    8141106/** Set color in test GC.
    8151107 *
    … …  
    8441136        resp->fill_rect_called = true;
    8451137        resp->fill_rect_rect = *rect;
     1138        return resp->rc;
     1139}
     1140
     1141/** Update test GC.
     1142 *
     1143 * @param arg Test GC
     1144 *
     1145 * @return EOK on success or an error code
     1146 */
     1147static errno_t test_gc_update(void *arg)
     1148{
     1149        test_response_t *resp = (test_response_t *) arg;
     1150
     1151        resp->update_called = true;
    8461152        return resp->rc;
    8471153}
Note: See TracChangeset for help on using the changeset viewer.