Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4c6fd56 r7470d97  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    120120        async_sess_t *sess;
    121121        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, &sid);
     122
     123        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     124
     125        // FIXME This causes this test to be non-reentrant!
     126        rc = loc_server_register(test_ipcgfx_server);
     127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     128
     129        rc = loc_service_register(test_ipcgfx_svc, &sid);
    131130        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    132131
    … …  
    157156        async_hangup(sess);
    158157
    159         rc = loc_service_unregister(srv, sid);
    160         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    161         loc_server_unregister(srv);
     158        rc = loc_service_unregister(sid);
     159        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    162160}
    163161
    … …  
    172170        async_sess_t *sess;
    173171        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, &sid);
     172
     173        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     174
     175        // FIXME This causes this test to be non-reentrant!
     176        rc = loc_server_register(test_ipcgfx_server);
     177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     178
     179        rc = loc_service_register(test_ipcgfx_svc, &sid);
    183180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    184181
    … …  
    210207        async_hangup(sess);
    211208
    212         rc = loc_service_unregister(srv, sid);
    213         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    214         loc_server_unregister(srv);
     209        rc = loc_service_unregister(sid);
     210        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    215211}
    216212
    … …  
    224220        async_sess_t *sess;
    225221        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, &sid);
     222
     223        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     224
     225        // FIXME This causes this test to be non-reentrant!
     226        rc = loc_server_register(test_ipcgfx_server);
     227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     228
     229        rc = loc_service_register(test_ipcgfx_svc, &sid);
    235230        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    236231
    … …  
    255250        async_hangup(sess);
    256251
    257         rc = loc_service_unregister(srv, sid);
    258         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    259         loc_server_unregister(srv);
     252        rc = loc_service_unregister(sid);
     253        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    260254}
    261255
    … …  
    270264        async_sess_t *sess;
    271265        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, &sid);
     266
     267        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     268
     269        // FIXME This causes this test to be non-reentrant!
     270        rc = loc_server_register(test_ipcgfx_server);
     271        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     272
     273        rc = loc_service_register(test_ipcgfx_svc, &sid);
    281274        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282275
    … …  
    307300        async_hangup(sess);
    308301
    309         rc = loc_service_unregister(srv, sid);
    310         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    311         loc_server_unregister(srv);
     302        rc = loc_service_unregister(sid);
     303        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    312304}
    313305
    … …  
    322314        async_sess_t *sess;
    323315        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, &sid);
     316
     317        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     318
     319        // FIXME This causes this test to be non-reentrant!
     320        rc = loc_server_register(test_ipcgfx_server);
     321        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     322
     323        rc = loc_service_register(test_ipcgfx_svc, &sid);
    333324        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    334325
    … …  
    359350        async_hangup(sess);
    360351
    361         rc = loc_service_unregister(srv, sid);
    362         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    363         loc_server_unregister(srv);
     352        rc = loc_service_unregister(sid);
     353        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    364354}
    365355
    … …  
    374364        async_sess_t *sess;
    375365        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, &sid);
     366
     367        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     368
     369        // FIXME This causes this test to be non-reentrant!
     370        rc = loc_server_register(test_ipcgfx_server);
     371        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     372
     373        rc = loc_service_register(test_ipcgfx_svc, &sid);
    385374        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    386375
    … …  
    411400        async_hangup(sess);
    412401
    413         rc = loc_service_unregister(srv, sid);
    414         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    415         loc_server_unregister(srv);
     402        rc = loc_service_unregister(sid);
     403        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    416404}
    417405
    … …  
    426414        async_sess_t *sess;
    427415        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, &sid);
     416
     417        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     418
     419        // FIXME This causes this test to be non-reentrant!
     420        rc = loc_server_register(test_ipcgfx_server);
     421        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     422
     423        rc = loc_service_register(test_ipcgfx_svc, &sid);
    437424        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    438425
    … …  
    463450        async_hangup(sess);
    464451
    465         rc = loc_service_unregister(srv, sid);
    466         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    467         loc_server_unregister(srv);
     452        rc = loc_service_unregister(sid);
     453        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    468454}
    469455
    … …  
    477463        async_sess_t *sess;
    478464        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, &sid);
     465
     466        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     467
     468        // FIXME This causes this test to be non-reentrant!
     469        rc = loc_server_register(test_ipcgfx_server);
     470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     471
     472        rc = loc_service_register(test_ipcgfx_svc, &sid);
    488473        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    489474
    … …  
    506491        async_hangup(sess);
    507492
    508         rc = loc_service_unregister(srv, sid);
    509         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    510         loc_server_unregister(srv);
     493        rc = loc_service_unregister(sid);
     494        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    511495}
    512496
    … …  
    520504        async_sess_t *sess;
    521505        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, &sid);
     506
     507        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     508
     509        // FIXME This causes this test to be non-reentrant!
     510        rc = loc_server_register(test_ipcgfx_server);
     511        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     512
     513        rc = loc_service_register(test_ipcgfx_svc, &sid);
    531514        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    532515
    … …  
    549532        async_hangup(sess);
    550533
    551         rc = loc_service_unregister(srv, sid);
    552         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    553         loc_server_unregister(srv);
     534        rc = loc_service_unregister(sid);
     535        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    554536}
    555537
    … …  
    565547        async_sess_t *sess;
    566548        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, &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);
    576557        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    577558
    … …  
    610591        async_hangup(sess);
    611592
    612         rc = loc_service_unregister(srv, sid);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    614         loc_server_unregister(srv);
     593        rc = loc_service_unregister(sid);
     594        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    615595}
    616596
    … …  
    626606        async_sess_t *sess;
    627607        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, &sid);
     608
     609        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     610
     611        // FIXME This causes this test to be non-reentrant!
     612        rc = loc_server_register(test_ipcgfx_server);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614
     615        rc = loc_service_register(test_ipcgfx_svc, &sid);
    637616        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    638617
    … …  
    676655        async_hangup(sess);
    677656
    678         rc = loc_service_unregister(srv, sid);
    679         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    680         loc_server_unregister(srv);
     657        rc = loc_service_unregister(sid);
     658        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681659}
    682660
    … …  
    692670        async_sess_t *sess;
    693671        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, &sid);
     672
     673        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     674
     675        // FIXME This causes this test to be non-reentrant!
     676        rc = loc_server_register(test_ipcgfx_server);
     677        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     678
     679        rc = loc_service_register(test_ipcgfx_svc, &sid);
    703680        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    704681
    … …  
    731708        async_hangup(sess);
    732709
    733         rc = loc_service_unregister(srv, sid);
    734         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    735         loc_server_unregister(srv);
     710        rc = loc_service_unregister(sid);
     711        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    736712}
    737713
    … …  
    747723        async_sess_t *sess;
    748724        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, &sid);
     725
     726        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     727
     728        // FIXME This causes this test to be non-reentrant!
     729        rc = loc_server_register(test_ipcgfx_server);
     730        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     731
     732        rc = loc_service_register(test_ipcgfx_svc, &sid);
    758733        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    759734
    … …  
    793768        async_hangup(sess);
    794769
    795         rc = loc_service_unregister(srv, sid);
    796         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    797         loc_server_unregister(srv);
     770        rc = loc_service_unregister(sid);
     771        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    798772}
    799773
    … …  
    809783        async_sess_t *sess;
    810784        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, &sid);
     785
     786        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     787
     788        // FIXME This causes this test to be non-reentrant!
     789        rc = loc_server_register(test_ipcgfx_server);
     790        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     791
     792        rc = loc_service_register(test_ipcgfx_svc, &sid);
    820793        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    821794
    … …  
    860833        async_hangup(sess);
    861834
    862         rc = loc_service_unregister(srv, sid);
    863         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    864         loc_server_unregister(srv);
     835        rc = loc_service_unregister(sid);
     836        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    865837}
    866838
    … …  
    878850        async_sess_t *sess;
    879851        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, &sid);
     852
     853        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     854
     855        // FIXME This causes this test to be non-reentrant!
     856        rc = loc_server_register(test_ipcgfx_server);
     857        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     858
     859        rc = loc_service_register(test_ipcgfx_svc, &sid);
    889860        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    890861
    … …  
    930901        async_hangup(sess);
    931902
    932         rc = loc_service_unregister(srv, sid);
    933         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    934         loc_server_unregister(srv);
     903        rc = loc_service_unregister(sid);
     904        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    935905}
    936906
    … …  
    948918        async_sess_t *sess;
    949919        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, &sid);
     920
     921        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     922
     923        // FIXME This causes this test to be non-reentrant!
     924        rc = loc_server_register(test_ipcgfx_server);
     925        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     926
     927        rc = loc_service_register(test_ipcgfx_svc, &sid);
    959928        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    960929
    … …  
    1000969        async_hangup(sess);
    1001970
    1002         rc = loc_service_unregister(srv, sid);
    1003         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1004         loc_server_unregister(srv);
     971        rc = loc_service_unregister(sid);
     972        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1005973}
    1006974
    … …  
    1017985        async_sess_t *sess;
    1018986        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, &sid);
     987
     988        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     989
     990        // FIXME This causes this test to be non-reentrant!
     991        rc = loc_server_register(test_ipcgfx_server);
     992        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     993
     994        rc = loc_service_register(test_ipcgfx_svc, &sid);
    1028995        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1029996
    … …  
    10621029        async_hangup(sess);
    10631030
    1064         rc = loc_service_unregister(srv, sid);
    1065         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1066         loc_server_unregister(srv);
     1031        rc = loc_service_unregister(sid);
     1032        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10671033}
    10681034
Note: See TracChangeset for help on using the changeset viewer.