Changeset 4c6fd56 in mainline for uspace/lib/display/test/display.c


Ignore:
Timestamp:
2023-09-16T19:58:18Z (9 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7d7f5e3
Parents:
6a0b2cc
git-author:
Jiri Svoboda <jiri@…> (2023-09-16 19:48:07)
git-committer:
Jiri Svoboda <jiri@…> (2023-09-16 19:58:18)
Message:

loc_server_register() should be callable more than once (API only)

Now loc_server_register() returns a pointer to a loc_srv_t object,
that is then passed to loc_service_register() and
loc_service_add_to_cat().

Added loc_server_unregister() that unregisters the server
and frees the loc_srv_t object.

Updated all callers. The implementation, however, is a stub.
It is not actually possible to call loc_server_register() more
than once, yet.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6a0b2cc r4c6fd56  
    186186        display_t *disp = NULL;
    187187        test_response_t resp;
    188 
    189         async_set_fallback_port_handler(test_display_conn, &resp);
    190 
    191         // FIXME This causes this test to be non-reentrant!
    192         rc = loc_server_register(test_display_server);
    193         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    194 
    195         rc = loc_service_register(test_display_svc, &sid);
    196         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    197 
    198         rc = display_open(test_display_svc, &disp);
    199         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    200         PCUT_ASSERT_NOT_NULL(disp);
    201 
    202         display_close(disp);
    203         rc = loc_service_unregister(sid);
    204         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, &sid);
     197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     198
     199        rc = display_open(test_display_svc, &disp);
     200        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     201        PCUT_ASSERT_NOT_NULL(disp);
     202
     203        display_close(disp);
     204        rc = loc_service_unregister(srv, sid);
     205        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     206        loc_server_unregister(srv);
    205207}
    206208
    … …  
    214216        display_window_t *wnd;
    215217        test_response_t resp;
    216 
    217         async_set_fallback_port_handler(test_display_conn, &resp);
    218 
    219         // FIXME This causes this test to be non-reentrant!
    220         rc = loc_server_register(test_display_server);
    221         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    222 
    223         rc = loc_service_register(test_display_svc, &sid);
     218        loc_srv_t *srv;
     219
     220        async_set_fallback_port_handler(test_display_conn, &resp);
     221
     222        // FIXME This causes this test to be non-reentrant!
     223        rc = loc_server_register(test_display_server, &srv);
     224        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     225
     226        rc = loc_service_register(srv, test_display_svc, &sid);
    224227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    225228
    … …  
    254257
    255258        display_close(disp);
    256         rc = loc_service_unregister(sid);
    257         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        rc = loc_service_unregister(srv, sid);
     260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     261        loc_server_unregister(srv);
    258262}
    259263
    … …  
    270274        display_window_t *wnd;
    271275        test_response_t resp;
    272 
    273         async_set_fallback_port_handler(test_display_conn, &resp);
    274 
    275         // FIXME This causes this test to be non-reentrant!
    276         rc = loc_server_register(test_display_server);
    277         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    278 
    279         rc = loc_service_register(test_display_svc, &sid);
     276        loc_srv_t *srv;
     277
     278        async_set_fallback_port_handler(test_display_conn, &resp);
     279
     280        // FIXME This causes this test to be non-reentrant!
     281        rc = loc_server_register(test_display_server, &srv);
     282        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     283
     284        rc = loc_service_register(srv, test_display_svc, &sid);
    280285        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    281286
    … …  
    312317
    313318        display_close(disp);
    314         rc = loc_service_unregister(sid);
    315         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319        rc = loc_service_unregister(srv, sid);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321        loc_server_unregister(srv);
    316322}
    317323
    … …  
    325331        display_window_t *wnd;
    326332        test_response_t resp;
    327 
    328         async_set_fallback_port_handler(test_display_conn, &resp);
    329 
    330         // FIXME This causes this test to be non-reentrant!
    331         rc = loc_server_register(test_display_server);
    332         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    333 
    334         rc = loc_service_register(test_display_svc, &sid);
     333        loc_srv_t *srv;
     334
     335        async_set_fallback_port_handler(test_display_conn, &resp);
     336
     337        // FIXME This causes this test to be non-reentrant!
     338        rc = loc_server_register(test_display_server, &srv);
     339        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     340
     341        rc = loc_service_register(srv, test_display_svc, &sid);
    335342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    336343
    … …  
    365372
    366373        display_close(disp);
    367         rc = loc_service_unregister(sid);
    368         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     374        rc = loc_service_unregister(srv, sid);
     375        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     376        loc_server_unregister(srv);
    369377}
    370378
    … …  
    386394        gfx_coord2_t pos;
    387395        sysarg_t pos_id;
    388 
    389         async_set_fallback_port_handler(test_display_conn, &resp);
    390 
    391         // FIXME This causes this test to be non-reentrant!
    392         rc = loc_server_register(test_display_server);
    393         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    394 
    395         rc = loc_service_register(test_display_svc, &sid);
     396        loc_srv_t *srv;
     397
     398        async_set_fallback_port_handler(test_display_conn, &resp);
     399
     400        // FIXME This causes this test to be non-reentrant!
     401        rc = loc_server_register(test_display_server, &srv);
     402        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     403
     404        rc = loc_service_register(srv, test_display_svc, &sid);
    396405        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    397406
    … …  
    429438        display_window_destroy(wnd);
    430439        display_close(disp);
    431         rc = loc_service_unregister(sid);
    432         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     440        rc = loc_service_unregister(srv, sid);
     441        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     442        loc_server_unregister(srv);
    433443}
    434444
    … …  
    444454        gfx_coord2_t pos;
    445455        sysarg_t pos_id;
    446 
    447         async_set_fallback_port_handler(test_display_conn, &resp);
    448 
    449         // FIXME This causes this test to be non-reentrant!
    450         rc = loc_server_register(test_display_server);
    451         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    452 
    453         rc = loc_service_register(test_display_svc, &sid);
     456        loc_srv_t *srv;
     457
     458        async_set_fallback_port_handler(test_display_conn, &resp);
     459
     460        // FIXME This causes this test to be non-reentrant!
     461        rc = loc_server_register(test_display_server, &srv);
     462        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     463
     464        rc = loc_service_register(srv, test_display_svc, &sid);
    454465        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    455466
    … …  
    487498        display_window_destroy(wnd);
    488499        display_close(disp);
    489         rc = loc_service_unregister(sid);
    490         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     500        rc = loc_service_unregister(srv, sid);
     501        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     502        loc_server_unregister(srv);
    491503}
    492504
    … …  
    501513        gfx_coord2_t dpos;
    502514        test_response_t resp;
    503 
    504         async_set_fallback_port_handler(test_display_conn, &resp);
    505 
    506         // FIXME This causes this test to be non-reentrant!
    507         rc = loc_server_register(test_display_server);
    508         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    509 
    510         rc = loc_service_register(test_display_svc, &sid);
     515        loc_srv_t *srv;
     516
     517        async_set_fallback_port_handler(test_display_conn, &resp);
     518
     519        // FIXME This causes this test to be non-reentrant!
     520        rc = loc_server_register(test_display_server, &srv);
     521        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     522
     523        rc = loc_service_register(srv, test_display_svc, &sid);
    511524        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    512525
    … …  
    541554        display_window_destroy(wnd);
    542555        display_close(disp);
    543         rc = loc_service_unregister(sid);
    544         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     556        rc = loc_service_unregister(srv, sid);
     557        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     558        loc_server_unregister(srv);
    545559}
    546560
    … …  
    555569        gfx_coord2_t dpos;
    556570        test_response_t resp;
    557 
    558         async_set_fallback_port_handler(test_display_conn, &resp);
    559 
    560         // FIXME This causes this test to be non-reentrant!
    561         rc = loc_server_register(test_display_server);
    562         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    563 
    564         rc = loc_service_register(test_display_svc, &sid);
     571        loc_srv_t *srv;
     572
     573        async_set_fallback_port_handler(test_display_conn, &resp);
     574
     575        // FIXME This causes this test to be non-reentrant!
     576        rc = loc_server_register(test_display_server, &srv);
     577        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     578
     579        rc = loc_service_register(srv, test_display_svc, &sid);
    565580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    566581
    … …  
    595610        display_window_destroy(wnd);
    596611        display_close(disp);
    597         rc = loc_service_unregister(sid);
    598         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);
    599615}
    600616
    … …  
    609625        gfx_coord2_t dpos;
    610626        test_response_t resp;
    611 
    612         async_set_fallback_port_handler(test_display_conn, &resp);
    613 
    614         // FIXME This causes this test to be non-reentrant!
    615         rc = loc_server_register(test_display_server);
    616         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    617 
    618         rc = loc_service_register(test_display_svc, &sid);
     627        loc_srv_t *srv;
     628
     629        async_set_fallback_port_handler(test_display_conn, &resp);
     630
     631        // FIXME This causes this test to be non-reentrant!
     632        rc = loc_server_register(test_display_server, &srv);
     633        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     634
     635        rc = loc_service_register(srv, test_display_svc, &sid);
    619636        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    620637
    … …  
    650667        display_window_destroy(wnd);
    651668        display_close(disp);
    652         rc = loc_service_unregister(sid);
    653         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     669        rc = loc_service_unregister(srv, sid);
     670        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     671        loc_server_unregister(srv);
    654672}
    655673
    … …  
    664682        gfx_coord2_t dpos;
    665683        test_response_t resp;
    666 
    667         async_set_fallback_port_handler(test_display_conn, &resp);
    668 
    669         // FIXME This causes this test to be non-reentrant!
    670         rc = loc_server_register(test_display_server);
    671         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    672 
    673         rc = loc_service_register(test_display_svc, &sid);
     684        loc_srv_t *srv;
     685
     686        async_set_fallback_port_handler(test_display_conn, &resp);
     687
     688        // FIXME This causes this test to be non-reentrant!
     689        rc = loc_server_register(test_display_server, &srv);
     690        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     691
     692        rc = loc_service_register(srv, test_display_svc, &sid);
    674693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    675694
    … …  
    707726        display_window_destroy(wnd);
    708727        display_close(disp);
    709         rc = loc_service_unregister(sid);
    710         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     728        rc = loc_service_unregister(srv, sid);
     729        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     730        loc_server_unregister(srv);
    711731}
    712732
    … …  
    721741        gfx_rect_t rect;
    722742        test_response_t resp;
    723 
    724         async_set_fallback_port_handler(test_display_conn, &resp);
    725 
    726         // FIXME This causes this test to be non-reentrant!
    727         rc = loc_server_register(test_display_server);
    728         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    729 
    730         rc = loc_service_register(test_display_svc, &sid);
     743        loc_srv_t *srv;
     744
     745        async_set_fallback_port_handler(test_display_conn, &resp);
     746
     747        // FIXME This causes this test to be non-reentrant!
     748        rc = loc_server_register(test_display_server, &srv);
     749        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     750
     751        rc = loc_service_register(srv, test_display_svc, &sid);
    731752        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    732753
    … …  
    766787        display_window_destroy(wnd);
    767788        display_close(disp);
    768         rc = loc_service_unregister(sid);
    769         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     789        rc = loc_service_unregister(srv, sid);
     790        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     791        loc_server_unregister(srv);
    770792}
    771793
    … …  
    780802        gfx_rect_t rect;
    781803        test_response_t resp;
    782 
    783         async_set_fallback_port_handler(test_display_conn, &resp);
    784 
    785         // FIXME This causes this test to be non-reentrant!
    786         rc = loc_server_register(test_display_server);
    787         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    788 
    789         rc = loc_service_register(test_display_svc, &sid);
     804        loc_srv_t *srv;
     805
     806        async_set_fallback_port_handler(test_display_conn, &resp);
     807
     808        // FIXME This causes this test to be non-reentrant!
     809        rc = loc_server_register(test_display_server, &srv);
     810        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     811
     812        rc = loc_service_register(srv, test_display_svc, &sid);
    790813        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    791814
    … …  
    829852        display_window_destroy(wnd);
    830853        display_close(disp);
    831         rc = loc_service_unregister(sid);
    832         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     854        rc = loc_service_unregister(srv, sid);
     855        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     856        loc_server_unregister(srv);
    833857}
    834858
    … …  
    845869        gfx_coord2_t pos;
    846870        sysarg_t pos_id;
    847 
    848         async_set_fallback_port_handler(test_display_conn, &resp);
    849 
    850         // FIXME This causes this test to be non-reentrant!
    851         rc = loc_server_register(test_display_server);
    852         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    853 
    854         rc = loc_service_register(test_display_svc, &sid);
     871        loc_srv_t *srv;
     872
     873        async_set_fallback_port_handler(test_display_conn, &resp);
     874
     875        // FIXME This causes this test to be non-reentrant!
     876        rc = loc_server_register(test_display_server, &srv);
     877        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     878
     879        rc = loc_service_register(srv, test_display_svc, &sid);
    855880        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    856881
    … …  
    890915        display_window_destroy(wnd);
    891916        display_close(disp);
    892         rc = loc_service_unregister(sid);
    893         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     917        rc = loc_service_unregister(srv, sid);
     918        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     919        loc_server_unregister(srv);
    894920}
    895921
    … …  
    906932        gfx_coord2_t pos;
    907933        sysarg_t pos_id;
    908 
    909         async_set_fallback_port_handler(test_display_conn, &resp);
    910 
    911         // FIXME This causes this test to be non-reentrant!
    912         rc = loc_server_register(test_display_server);
    913         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    914 
    915         rc = loc_service_register(test_display_svc, &sid);
     934        loc_srv_t *srv;
     935
     936        async_set_fallback_port_handler(test_display_conn, &resp);
     937
     938        // FIXME This causes this test to be non-reentrant!
     939        rc = loc_server_register(test_display_server, &srv);
     940        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     941
     942        rc = loc_service_register(srv, test_display_svc, &sid);
    916943        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    917944
    … …  
    951978        display_window_destroy(wnd);
    952979        display_close(disp);
    953         rc = loc_service_unregister(sid);
    954         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     980        rc = loc_service_unregister(srv, sid);
     981        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     982        loc_server_unregister(srv);
    955983}
    956984
    … …  
    966994        gfx_rect_t nrect;
    967995        test_response_t resp;
    968 
    969         async_set_fallback_port_handler(test_display_conn, &resp);
    970 
    971         // FIXME This causes this test to be non-reentrant!
    972         rc = loc_server_register(test_display_server);
    973         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    974 
    975         rc = loc_service_register(test_display_svc, &sid);
     996        loc_srv_t *srv;
     997
     998        async_set_fallback_port_handler(test_display_conn, &resp);
     999
     1000        // FIXME This causes this test to be non-reentrant!
     1001        rc = loc_server_register(test_display_server, &srv);
     1002        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1003
     1004        rc = loc_service_register(srv, test_display_svc, &sid);
    9761005        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9771006
    … …  
    10141043        display_window_destroy(wnd);
    10151044        display_close(disp);
    1016         rc = loc_service_unregister(sid);
    1017         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1045        rc = loc_service_unregister(srv, sid);
     1046        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1047        loc_server_unregister(srv);
    10181048}
    10191049
    … …  
    10291059        gfx_rect_t nrect;
    10301060        test_response_t resp;
    1031 
    1032         async_set_fallback_port_handler(test_display_conn, &resp);
    1033 
    1034         // FIXME This causes this test to be non-reentrant!
    1035         rc = loc_server_register(test_display_server);
    1036         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1037 
    1038         rc = loc_service_register(test_display_svc, &sid);
     1061        loc_srv_t *srv;
     1062
     1063        async_set_fallback_port_handler(test_display_conn, &resp);
     1064
     1065        // FIXME This causes this test to be non-reentrant!
     1066        rc = loc_server_register(test_display_server, &srv);
     1067        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1068
     1069        rc = loc_service_register(srv, test_display_svc, &sid);
    10391070        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    10401071
    … …  
    10761107        display_window_destroy(wnd);
    10771108        display_close(disp);
    1078         rc = loc_service_unregister(sid);
    1079         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1109        rc = loc_service_unregister(srv, sid);
     1110        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1111        loc_server_unregister(srv);
    10801112}
    10811113
    … …  
    10891121        display_window_t *wnd;
    10901122        test_response_t resp;
    1091 
    1092         async_set_fallback_port_handler(test_display_conn, &resp);
    1093 
    1094         // FIXME This causes this test to be non-reentrant!
    1095         rc = loc_server_register(test_display_server);
    1096         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1097 
    1098         rc = loc_service_register(test_display_svc, &sid);
     1123        loc_srv_t *srv;
     1124
     1125        async_set_fallback_port_handler(test_display_conn, &resp);
     1126
     1127        // FIXME This causes this test to be non-reentrant!
     1128        rc = loc_server_register(test_display_server, &srv);
     1129        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1130
     1131        rc = loc_service_register(srv, test_display_svc, &sid);
    10991132        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11001133
    … …  
    11241157        display_window_destroy(wnd);
    11251158        display_close(disp);
    1126         rc = loc_service_unregister(sid);
    1127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1159        rc = loc_service_unregister(srv, sid);
     1160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1161        loc_server_unregister(srv);
    11281162}
    11291163
    … …  
    11371171        display_window_t *wnd;
    11381172        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);
     1173        loc_srv_t *srv;
     1174
     1175        async_set_fallback_port_handler(test_display_conn, &resp);
     1176
     1177        // FIXME This causes this test to be non-reentrant!
     1178        rc = loc_server_register(test_display_server, &srv);
     1179        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1180
     1181        rc = loc_service_register(srv, test_display_svc, &sid);
    11471182        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11481183
    … …  
    11721207        display_window_destroy(wnd);
    11731208        display_close(disp);
    1174         rc = loc_service_unregister(sid);
    1175         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1209        rc = loc_service_unregister(srv, sid);
     1210        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1211        loc_server_unregister(srv);
    11761212}
    11771213
    … …  
    11851221        display_window_t *wnd;
    11861222        test_response_t resp;
    1187 
    1188         async_set_fallback_port_handler(test_display_conn, &resp);
    1189 
    1190         // FIXME This causes this test to be non-reentrant!
    1191         rc = loc_server_register(test_display_server);
    1192         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1193 
    1194         rc = loc_service_register(test_display_svc, &sid);
     1223        loc_srv_t *srv;
     1224
     1225        async_set_fallback_port_handler(test_display_conn, &resp);
     1226
     1227        // FIXME This causes this test to be non-reentrant!
     1228        rc = loc_server_register(test_display_server, &srv);
     1229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1230
     1231        rc = loc_service_register(srv, test_display_svc, &sid);
    11951232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    11961233
    … …  
    12201257        display_window_destroy(wnd);
    12211258        display_close(disp);
    1222         rc = loc_service_unregister(sid);
    1223         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1259        rc = loc_service_unregister(srv, sid);
     1260        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1261        loc_server_unregister(srv);
    12241262}
    12251263
    … …  
    12331271        display_window_t *wnd;
    12341272        test_response_t resp;
    1235 
    1236         async_set_fallback_port_handler(test_display_conn, &resp);
    1237 
    1238         // FIXME This causes this test to be non-reentrant!
    1239         rc = loc_server_register(test_display_server);
    1240         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1241 
    1242         rc = loc_service_register(test_display_svc, &sid);
     1273        loc_srv_t *srv;
     1274
     1275        async_set_fallback_port_handler(test_display_conn, &resp);
     1276
     1277        // FIXME This causes this test to be non-reentrant!
     1278        rc = loc_server_register(test_display_server, &srv);
     1279        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1280
     1281        rc = loc_service_register(srv, test_display_svc, &sid);
    12431282        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12441283
    … …  
    12681307        display_window_destroy(wnd);
    12691308        display_close(disp);
    1270         rc = loc_service_unregister(sid);
    1271         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1309        rc = loc_service_unregister(srv, sid);
     1310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1311        loc_server_unregister(srv);
    12721312}
    12731313
    … …  
    12811321        display_window_t *wnd;
    12821322        test_response_t resp;
    1283 
    1284         async_set_fallback_port_handler(test_display_conn, &resp);
    1285 
    1286         // FIXME This causes this test to be non-reentrant!
    1287         rc = loc_server_register(test_display_server);
    1288         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1289 
    1290         rc = loc_service_register(test_display_svc, &sid);
     1323        loc_srv_t *srv;
     1324
     1325        async_set_fallback_port_handler(test_display_conn, &resp);
     1326
     1327        // FIXME This causes this test to be non-reentrant!
     1328        rc = loc_server_register(test_display_server, &srv);
     1329        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1330
     1331        rc = loc_service_register(srv, test_display_svc, &sid);
    12911332        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    12921333
    … …  
    13181359        display_window_destroy(wnd);
    13191360        display_close(disp);
    1320         rc = loc_service_unregister(sid);
    1321         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1361        rc = loc_service_unregister(srv, sid);
     1362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1363        loc_server_unregister(srv);
    13221364}
    13231365
    … …  
    13311373        display_window_t *wnd;
    13321374        test_response_t resp;
    1333 
    1334         async_set_fallback_port_handler(test_display_conn, &resp);
    1335 
    1336         // FIXME This causes this test to be non-reentrant!
    1337         rc = loc_server_register(test_display_server);
    1338         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1339 
    1340         rc = loc_service_register(test_display_svc, &sid);
     1375        loc_srv_t *srv;
     1376
     1377        async_set_fallback_port_handler(test_display_conn, &resp);
     1378
     1379        // FIXME This causes this test to be non-reentrant!
     1380        rc = loc_server_register(test_display_server, &srv);
     1381        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1382
     1383        rc = loc_service_register(srv, test_display_svc, &sid);
    13411384        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13421385
    … …  
    13681411        display_window_destroy(wnd);
    13691412        display_close(disp);
    1370         rc = loc_service_unregister(sid);
    1371         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1413        rc = loc_service_unregister(srv, sid);
     1414        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1415        loc_server_unregister(srv);
    13721416}
    13731417
    … …  
    13821426        const char *caption;
    13831427        test_response_t resp;
    1384 
    1385         async_set_fallback_port_handler(test_display_conn, &resp);
    1386 
    1387         // FIXME This causes this test to be non-reentrant!
    1388         rc = loc_server_register(test_display_server);
    1389         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1390 
    1391         rc = loc_service_register(test_display_svc, &sid);
     1428        loc_srv_t *srv;
     1429
     1430        async_set_fallback_port_handler(test_display_conn, &resp);
     1431
     1432        // FIXME This causes this test to be non-reentrant!
     1433        rc = loc_server_register(test_display_server, &srv);
     1434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1435
     1436        rc = loc_service_register(srv, test_display_svc, &sid);
    13921437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    13931438
    … …  
    14221467        display_window_destroy(wnd);
    14231468        display_close(disp);
    1424         rc = loc_service_unregister(sid);
    1425         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1469        rc = loc_service_unregister(srv, sid);
     1470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1471        loc_server_unregister(srv);
    14261472}
    14271473
    … …  
    14361482        const char *caption;
    14371483        test_response_t resp;
    1438 
    1439         async_set_fallback_port_handler(test_display_conn, &resp);
    1440 
    1441         // FIXME This causes this test to be non-reentrant!
    1442         rc = loc_server_register(test_display_server);
    1443         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1444 
    1445         rc = loc_service_register(test_display_svc, &sid);
     1484        loc_srv_t *srv;
     1485
     1486        async_set_fallback_port_handler(test_display_conn, &resp);
     1487
     1488        // FIXME This causes this test to be non-reentrant!
     1489        rc = loc_server_register(test_display_server, &srv);
     1490        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1491
     1492        rc = loc_service_register(srv, test_display_svc, &sid);
    14461493        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    14471494
    … …  
    14761523        display_window_destroy(wnd);
    14771524        display_close(disp);
    1478         rc = loc_service_unregister(sid);
    1479         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1525        rc = loc_service_unregister(srv, sid);
     1526        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1527        loc_server_unregister(srv);
    14801528}
    14811529
    … …  
    14901538        test_response_t resp;
    14911539        gfx_context_t *gc;
    1492 
    1493         async_set_fallback_port_handler(test_display_conn, &resp);
    1494 
    1495         // FIXME This causes this test to be non-reentrant!
    1496         rc = loc_server_register(test_display_server);
    1497         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1498 
    1499         rc = loc_service_register(test_display_svc, &sid);
     1540        loc_srv_t *srv;
     1541
     1542        async_set_fallback_port_handler(test_display_conn, &resp);
     1543
     1544        // FIXME This causes this test to be non-reentrant!
     1545        rc = loc_server_register(test_display_server, &srv);
     1546        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1547
     1548        rc = loc_service_register(srv, test_display_svc, &sid);
    15001549        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15011550
    … …  
    15281577
    15291578        display_close(disp);
    1530         rc = loc_service_unregister(sid);
    1531         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1579        rc = loc_service_unregister(srv, sid);
     1580        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1581        loc_server_unregister(srv);
    15321582}
    15331583
    … …  
    15431593        gfx_context_t *gc;
    15441594        gfx_color_t *color;
    1545 
    1546         async_set_fallback_port_handler(test_display_conn, &resp);
    1547 
    1548         // FIXME This causes this test to be non-reentrant!
    1549         rc = loc_server_register(test_display_server);
    1550         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1551 
    1552         rc = loc_service_register(test_display_svc, &sid);
     1595        loc_srv_t *srv;
     1596
     1597        async_set_fallback_port_handler(test_display_conn, &resp);
     1598
     1599        // FIXME This causes this test to be non-reentrant!
     1600        rc = loc_server_register(test_display_server, &srv);
     1601        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1602
     1603        rc = loc_service_register(srv, test_display_svc, &sid);
    15531604        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    15541605
    … …  
    15891640
    15901641        display_close(disp);
    1591         rc = loc_service_unregister(sid);
    1592         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1642        rc = loc_service_unregister(srv, sid);
     1643        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1644        loc_server_unregister(srv);
    15931645}
    15941646
    … …  
    16021654        display_window_t *wnd;
    16031655        test_response_t resp;
    1604 
    1605         async_set_fallback_port_handler(test_display_conn, &resp);
    1606 
    1607         // FIXME This causes this test to be non-reentrant!
    1608         rc = loc_server_register(test_display_server);
    1609         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1610 
    1611         rc = loc_service_register(test_display_svc, &sid);
     1656        loc_srv_t *srv;
     1657
     1658        async_set_fallback_port_handler(test_display_conn, &resp);
     1659
     1660        // FIXME This causes this test to be non-reentrant!
     1661        rc = loc_server_register(test_display_server, &srv);
     1662        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1663
     1664        rc = loc_service_register(srv, test_display_svc, &sid);
    16121665        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16131666
    … …  
    16541707        display_close(disp);
    16551708
    1656         rc = loc_service_unregister(sid);
    1657         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1709        rc = loc_service_unregister(srv, sid);
     1710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1711        loc_server_unregister(srv);
    16581712}
    16591713
    … …  
    16671721        display_window_t *wnd;
    16681722        test_response_t resp;
    1669 
    1670         async_set_fallback_port_handler(test_display_conn, &resp);
    1671 
    1672         // FIXME This causes this test to be non-reentrant!
    1673         rc = loc_server_register(test_display_server);
    1674         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1675 
    1676         rc = loc_service_register(test_display_svc, &sid);
     1723        loc_srv_t *srv;
     1724
     1725        async_set_fallback_port_handler(test_display_conn, &resp);
     1726
     1727        // FIXME This causes this test to be non-reentrant!
     1728        rc = loc_server_register(test_display_server, &srv);
     1729        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1730
     1731        rc = loc_service_register(srv, test_display_svc, &sid);
    16771732        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16781733
    … …  
    17221777        display_close(disp);
    17231778
    1724         rc = loc_service_unregister(sid);
    1725         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1779        rc = loc_service_unregister(srv, sid);
     1780        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1781        loc_server_unregister(srv);
    17261782}
    17271783
    … …  
    17351791        display_window_t *wnd;
    17361792        test_response_t resp;
    1737 
    1738         async_set_fallback_port_handler(test_display_conn, &resp);
    1739 
    1740         // FIXME This causes this test to be non-reentrant!
    1741         rc = loc_server_register(test_display_server);
    1742         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1743 
    1744         rc = loc_service_register(test_display_svc, &sid);
     1793        loc_srv_t *srv;
     1794
     1795        async_set_fallback_port_handler(test_display_conn, &resp);
     1796
     1797        // FIXME This causes this test to be non-reentrant!
     1798        rc = loc_server_register(test_display_server, &srv);
     1799        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1800
     1801        rc = loc_service_register(srv, test_display_svc, &sid);
    17451802        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    17461803
    … …  
    17991856        display_close(disp);
    18001857
    1801         rc = loc_service_unregister(sid);
    1802         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1858        rc = loc_service_unregister(srv, sid);
     1859        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1860        loc_server_unregister(srv);
    18031861}
    18041862
    … …  
    18121870        display_window_t *wnd;
    18131871        test_response_t resp;
    1814 
    1815         async_set_fallback_port_handler(test_display_conn, &resp);
    1816 
    1817         // FIXME This causes this test to be non-reentrant!
    1818         rc = loc_server_register(test_display_server);
    1819         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1820 
    1821         rc = loc_service_register(test_display_svc, &sid);
     1872        loc_srv_t *srv;
     1873
     1874        async_set_fallback_port_handler(test_display_conn, &resp);
     1875
     1876        // FIXME This causes this test to be non-reentrant!
     1877        rc = loc_server_register(test_display_server, &srv);
     1878        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1879
     1880        rc = loc_service_register(srv, test_display_svc, &sid);
    18221881        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    18231882
    … …  
    18761935        display_close(disp);
    18771936
    1878         rc = loc_service_unregister(sid);
    1879         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1937        rc = loc_service_unregister(srv, sid);
     1938        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1939        loc_server_unregister(srv);
    18801940}
    18811941
    … …  
    18891949        display_window_t *wnd;
    18901950        test_response_t resp;
    1891 
    1892         async_set_fallback_port_handler(test_display_conn, &resp);
    1893 
    1894         // FIXME This causes this test to be non-reentrant!
    1895         rc = loc_server_register(test_display_server);
    1896         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1897 
    1898         rc = loc_service_register(test_display_svc, &sid);
     1951        loc_srv_t *srv;
     1952
     1953        async_set_fallback_port_handler(test_display_conn, &resp);
     1954
     1955        // FIXME This causes this test to be non-reentrant!
     1956        rc = loc_server_register(test_display_server, &srv);
     1957        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1958
     1959        rc = loc_service_register(srv, test_display_svc, &sid);
    18991960        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19001961
    … …  
    19442005        display_close(disp);
    19452006
    1946         rc = loc_service_unregister(sid);
    1947         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2007        rc = loc_service_unregister(srv, sid);
     2008        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2009        loc_server_unregister(srv);
    19482010}
    19492011
    … …  
    19562018        display_info_t info;
    19572019        test_response_t resp;
    1958 
    1959         async_set_fallback_port_handler(test_display_conn, &resp);
    1960 
    1961         // FIXME This causes this test to be non-reentrant!
    1962         rc = loc_server_register(test_display_server);
    1963         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1964 
    1965         rc = loc_service_register(test_display_svc, &sid);
     2020        loc_srv_t *srv;
     2021
     2022        async_set_fallback_port_handler(test_display_conn, &resp);
     2023
     2024        // FIXME This causes this test to be non-reentrant!
     2025        rc = loc_server_register(test_display_server, &srv);
     2026        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2027
     2028        rc = loc_service_register(srv, test_display_svc, &sid);
    19662029        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    19672030
    … …  
    19782041
    19792042        display_close(disp);
    1980         rc = loc_service_unregister(sid);
    1981         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2043        rc = loc_service_unregister(srv, sid);
     2044        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2045        loc_server_unregister(srv);
    19822046}
    19832047
    … …  
    19902054        display_info_t info;
    19912055        test_response_t resp;
    1992 
    1993         async_set_fallback_port_handler(test_display_conn, &resp);
    1994 
    1995         // FIXME This causes this test to be non-reentrant!
    1996         rc = loc_server_register(test_display_server);
    1997         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    1998 
    1999         rc = loc_service_register(test_display_svc, &sid);
     2056        loc_srv_t *srv;
     2057
     2058        async_set_fallback_port_handler(test_display_conn, &resp);
     2059
     2060        // FIXME This causes this test to be non-reentrant!
     2061        rc = loc_server_register(test_display_server, &srv);
     2062        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2063
     2064        rc = loc_service_register(srv, test_display_svc, &sid);
    20002065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    20012066
    … …  
    20202085
    20212086        display_close(disp);
    2022         rc = loc_service_unregister(sid);
    2023         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2087        rc = loc_service_unregister(srv, sid);
     2088        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     2089        loc_server_unregister(srv);
    20242090}
    20252091
Note: See TracChangeset for help on using the changeset viewer.