Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rca48672 rafcf704  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5050static void test_ipcgc_conn(ipc_call_t *, void *);
    5151
    52 static errno_t test_gc_set_clip_rect(void *, gfx_rect_t *);
    5352static errno_t test_gc_set_color(void *, gfx_color_t *);
    5453static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
    55 static errno_t test_gc_update(void *);
    5654static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
    5755    gfx_bitmap_alloc_t *, void **);
    … …  
    6159
    6260static gfx_context_ops_t test_gc_ops = {
    63         .set_clip_rect = test_gc_set_clip_rect,
    6461        .set_color = test_gc_set_color,
    6562        .fill_rect = test_gc_fill_rect,
    66         .update = test_gc_update,
    6763        .bitmap_create = test_gc_bitmap_create,
    6864        .bitmap_destroy = test_gc_bitmap_destroy,
    … …  
    7773        errno_t rc;
    7874
    79         bool set_clip_rect_called;
    80         bool do_clip;
    81         gfx_rect_t set_clip_rect_rect;
    82 
    8375        bool set_color_called;
    8476        uint16_t set_color_r;
    … …  
    8880        bool fill_rect_called;
    8981        gfx_rect_t fill_rect_rect;
    90 
    91         bool update_called;
    9282
    9383        bool bitmap_create_called;
    … …  
    110100} test_bitmap_t;
    111101
    112 /** gfx_set_clip_rect with server returning failure */
    113 PCUT_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 */
    165 PCUT_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 */
    218 PCUT_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 
    262102/** gfx_set_color with server returning failure */
    263103PCUT_TEST(set_color_failure)
    … …  
    270110        async_sess_t *sess;
    271111        ipc_gc_t *ipcgc;
    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);
     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);
    281120        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282121
    … …  
    307146        async_hangup(sess);
    308147
    309         rc = loc_service_unregister(srv, sid);
    310         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    311         loc_server_unregister(srv);
     148        rc = loc_service_unregister(sid);
     149        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    312150}
    313151
    … …  
    322160        async_sess_t *sess;
    323161        ipc_gc_t *ipcgc;
    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);
     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);
    333170        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    334171
    … …  
    359196        async_hangup(sess);
    360197
    361         rc = loc_service_unregister(srv, sid);
    362         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    363         loc_server_unregister(srv);
     198        rc = loc_service_unregister(sid);
     199        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    364200}
    365201
    … …  
    374210        async_sess_t *sess;
    375211        ipc_gc_t *ipcgc;
    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);
     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);
    385220        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    386221
    … …  
    395230
    396231        resp.rc = ENOMEM;
    397         resp.fill_rect_called = false;
     232        resp.set_color_called = false;
    398233        rect.p0.x = 1;
    399234        rect.p0.y = 2;
    … …  
    411246        async_hangup(sess);
    412247
    413         rc = loc_service_unregister(srv, sid);
    414         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    415         loc_server_unregister(srv);
     248        rc = loc_service_unregister(sid);
     249        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    416250}
    417251
    … …  
    426260        async_sess_t *sess;
    427261        ipc_gc_t *ipcgc;
    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;
     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;
    450283        rect.p0.x = 1;
    451284        rect.p0.y = 2;
    … …  
    463296        async_hangup(sess);
    464297
    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 */
    471 PCUT_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 */
    514 PCUT_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);
     298        rc = loc_service_unregister(sid);
     299        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    554300}
    555301
    … …  
    565311        async_sess_t *sess;
    566312        ipc_gc_t *ipcgc;
    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);
     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);
    576321        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    577322
    … …  
    610355        async_hangup(sess);
    611356
    612         rc = loc_service_unregister(srv, sid);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    614         loc_server_unregister(srv);
     357        rc = loc_service_unregister(sid);
     358        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    615359}
    616360
    … …  
    626370        async_sess_t *sess;
    627371        ipc_gc_t *ipcgc;
    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);
     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);
    637380        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    638381
    … …  
    676419        async_hangup(sess);
    677420
    678         rc = loc_service_unregister(srv, sid);
    679         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    680         loc_server_unregister(srv);
     421        rc = loc_service_unregister(sid);
     422        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681423}
    682424
    … …  
    692434        async_sess_t *sess;
    693435        ipc_gc_t *ipcgc;
    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);
     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);
    703444        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    704445
    … …  
    731472        async_hangup(sess);
    732473
    733         rc = loc_service_unregister(srv, sid);
    734         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    735         loc_server_unregister(srv);
     474        rc = loc_service_unregister(sid);
     475        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    736476}
    737477
    … …  
    747487        async_sess_t *sess;
    748488        ipc_gc_t *ipcgc;
    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);
     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);
    758497        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    759498
    … …  
    793532        async_hangup(sess);
    794533
    795         rc = loc_service_unregister(srv, sid);
    796         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    797         loc_server_unregister(srv);
     534        rc = loc_service_unregister(sid);
     535        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    798536}
    799537
    … …  
    809547        async_sess_t *sess;
    810548        ipc_gc_t *ipcgc;
    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);
     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);
    820557        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    821558
    … …  
    860597        async_hangup(sess);
    861598
    862         rc = loc_service_unregister(srv, sid);
    863         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    864         loc_server_unregister(srv);
     599        rc = loc_service_unregister(sid);
     600        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    865601}
    866602
    … …  
    878614        async_sess_t *sess;
    879615        ipc_gc_t *ipcgc;
    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);
     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);
    889624        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    890625
    … …  
    930665        async_hangup(sess);
    931666
    932         rc = loc_service_unregister(srv, sid);
    933         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    934         loc_server_unregister(srv);
     667        rc = loc_service_unregister(sid);
     668        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    935669}
    936670
    … …  
    948682        async_sess_t *sess;
    949683        ipc_gc_t *ipcgc;
    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);
     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);
    959692        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    960693
    … …  
    1000733        async_hangup(sess);
    1001734
    1002         rc = loc_service_unregister(srv, sid);
    1003         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1004         loc_server_unregister(srv);
     735        rc = loc_service_unregister(sid);
     736        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1005737}
    1006738
    … …  
    1017749        async_sess_t *sess;
    1018750        ipc_gc_t *ipcgc;
    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);
     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);
    1028759        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1029760
    … …  
    1062793        async_hangup(sess);
    1063794
    1064         rc = loc_service_unregister(srv, sid);
    1065         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1066         loc_server_unregister(srv);
     795        rc = loc_service_unregister(sid);
     796        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1067797}
    1068798
    … …  
    1082812}
    1083813
    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  */
    1091 static 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 
    1106814/** Set color in test GC.
    1107815 *
    … …  
    1136844        resp->fill_rect_called = true;
    1137845        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  */
    1147 static errno_t test_gc_update(void *arg)
    1148 {
    1149         test_response_t *resp = (test_response_t *) arg;
    1150 
    1151         resp->update_called = true;
    1152846        return resp->rc;
    1153847}
Note: See TracChangeset for help on using the changeset viewer.