Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/dispcfg/test/dispcfg.c

    r4c6fd56 rb3eeae5  
    3535#include <pcut/pcut.h>
    3636#include <str.h>
    37 #include <testdc.h>
    3837#include "../private/dispcfg.h"
    3938
    … …  
    4544static const char *test_dispcfg_svc = "test/dispcfg";
    4645
     46static void test_dispcfg_conn(ipc_call_t *, void *);
     47
     48static errno_t test_get_seat_list(void *, dispcfg_seat_list_t **);
     49static errno_t test_get_seat_info(void *, sysarg_t, dispcfg_seat_info_t **);
     50static errno_t test_seat_create(void *, const char *, sysarg_t *);
     51static errno_t test_seat_delete(void *, sysarg_t);
     52static errno_t test_dev_assign(void *, sysarg_t, sysarg_t);
     53static errno_t test_dev_unassign(void *, sysarg_t);
     54static errno_t test_get_event(void *, dispcfg_ev_t *);
     55
     56static void test_seat_added(void *, sysarg_t);
     57static void test_seat_removed(void *, sysarg_t);
     58
     59static dispcfg_ops_t test_dispcfg_srv_ops = {
     60        .get_seat_list = test_get_seat_list,
     61        .get_seat_info = test_get_seat_info,
     62        .seat_create = test_seat_create,
     63        .seat_delete = test_seat_delete,
     64        .dev_assign = test_dev_assign,
     65        .dev_unassign = test_dev_unassign,
     66        .get_event = test_get_event
     67};
     68
     69static dispcfg_cb_t test_dispcfg_cb = {
     70        .seat_added = test_seat_added,
     71        .seat_removed = test_seat_removed
     72};
     73
     74/** Describes to the server how to respond to our request and pass tracking
     75 * data back to the client.
     76 */
     77typedef struct {
     78        errno_t rc;
     79        sysarg_t seat_id;
     80        dispcfg_ev_t event;
     81        dispcfg_ev_t revent;
     82        int event_cnt;
     83
     84        bool get_seat_list_called;
     85        dispcfg_seat_list_t *get_seat_list_rlist;
     86
     87        bool get_seat_info_called;
     88        sysarg_t get_seat_info_seat_id;
     89        dispcfg_seat_info_t *get_seat_info_rinfo;
     90
     91        bool seat_create_called;
     92        char *seat_create_name;
     93        sysarg_t seat_create_seat_id;
     94
     95        bool seat_delete_called;
     96        sysarg_t seat_delete_seat_id;
     97
     98        bool dev_assign_called;
     99        sysarg_t dev_assign_svc_id;
     100        sysarg_t dev_assign_seat_id;
     101
     102        bool dev_unassign_called;
     103        sysarg_t dev_unassign_svc_id;
     104
     105        bool get_event_called;
     106
     107        bool seat_added_called;
     108        sysarg_t seat_added_seat_id;
     109
     110        bool seat_removed_called;
     111        sysarg_t seat_removed_seat_id;
     112
     113        bool seat_changed_called;
     114        sysarg_t seat_changed_seat_id;
     115
     116        fibril_condvar_t event_cv;
     117        fibril_mutex_t event_lock;
     118        dispcfg_srv_t *srv;
     119} test_response_t;
     120
    47121/** dispcfg_open(), dispcfg_close() work for valid seat management service */
    48122PCUT_TEST(open_close)
    … …  
    52126        dispcfg_t *dispcfg = NULL;
    53127        test_response_t resp;
    54         loc_srv_t *srv;
    55 
    56         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    57 
    58         // FIXME This causes this test to be non-reentrant!
    59         rc = loc_server_register(test_dispcfg_server, &srv);
    60         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    61 
    62         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    63         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    64 
    65         rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
    66         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    67         PCUT_ASSERT_NOT_NULL(dispcfg);
    68 
    69         dispcfg_close(dispcfg);
    70         rc = loc_service_unregister(srv, sid);
    71         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    72         loc_server_unregister(srv);
     128
     129        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     130
     131        // FIXME This causes this test to be non-reentrant!
     132        rc = loc_server_register(test_dispcfg_server);
     133        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     134
     135        rc = loc_service_register(test_dispcfg_svc, &sid);
     136        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     137
     138        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     139        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     140        PCUT_ASSERT_NOT_NULL(dispcfg);
     141
     142        dispcfg_close(dispcfg);
     143        rc = loc_service_unregister(sid);
     144        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    73145}
    74146
    … …  
    81153        dispcfg_seat_list_t *list;
    82154        test_response_t resp;
    83         loc_srv_t *srv;
    84 
    85         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    86 
    87         // FIXME This causes this test to be non-reentrant!
    88         rc = loc_server_register(test_dispcfg_server, &srv);
    89         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    90 
    91         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     155
     156        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     157
     158        // FIXME This causes this test to be non-reentrant!
     159        rc = loc_server_register(test_dispcfg_server);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161
     162        rc = loc_service_register(test_dispcfg_svc, &sid);
    92163        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    93164
    … …  
    104175
    105176        dispcfg_close(dispcfg);
    106         rc = loc_service_unregister(srv, sid);
    107         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    108         loc_server_unregister(srv);
     177        rc = loc_service_unregister(sid);
     178        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    109179}
    110180
    … …  
    117187        dispcfg_seat_list_t *list;
    118188        test_response_t resp;
    119         loc_srv_t *srv;
    120 
    121         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    122 
    123         // FIXME This causes this test to be non-reentrant!
    124         rc = loc_server_register(test_dispcfg_server, &srv);
    125         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    126 
    127         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     189
     190        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     191
     192        // FIXME This causes this test to be non-reentrant!
     193        rc = loc_server_register(test_dispcfg_server);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195
     196        rc = loc_service_register(test_dispcfg_svc, &sid);
    128197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    129198
    … …  
    152221        dispcfg_free_seat_list(list);
    153222        dispcfg_close(dispcfg);
    154         rc = loc_service_unregister(srv, sid);
    155         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    156         loc_server_unregister(srv);
     223        rc = loc_service_unregister(sid);
     224        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    157225}
    158226
    … …  
    166234        dispcfg_seat_info_t *info;
    167235        test_response_t resp;
    168         loc_srv_t *srv;
    169 
    170         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    171 
    172         // FIXME This causes this test to be non-reentrant!
    173         rc = loc_server_register(test_dispcfg_server, &srv);
    174         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    175 
    176         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     236
     237        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     238
     239        // FIXME This causes this test to be non-reentrant!
     240        rc = loc_server_register(test_dispcfg_server);
     241        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     242
     243        rc = loc_service_register(test_dispcfg_svc, &sid);
    177244        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178245
    … …  
    191258
    192259        dispcfg_close(dispcfg);
    193         rc = loc_service_unregister(srv, sid);
    194         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    195         loc_server_unregister(srv);
     260        rc = loc_service_unregister(sid);
     261        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    196262}
    197263
    … …  
    205271        dispcfg_seat_info_t *info;
    206272        test_response_t resp;
    207         loc_srv_t *srv;
    208 
    209         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    210 
    211         // FIXME This causes this test to be non-reentrant!
    212         rc = loc_server_register(test_dispcfg_server, &srv);
    213         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    214 
    215         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     273
     274        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     275
     276        // FIXME This causes this test to be non-reentrant!
     277        rc = loc_server_register(test_dispcfg_server);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279
     280        rc = loc_service_register(test_dispcfg_svc, &sid);
    216281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    217282
    … …  
    237302        dispcfg_free_seat_info(info);
    238303        dispcfg_close(dispcfg);
    239         rc = loc_service_unregister(srv, sid);
    240         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    241         loc_server_unregister(srv);
     304        rc = loc_service_unregister(sid);
     305        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    242306}
    243307
    … …  
    250314        sysarg_t seat_id;
    251315        test_response_t resp;
    252         loc_srv_t *srv;
    253 
    254         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    255 
    256         // FIXME This causes this test to be non-reentrant!
    257         rc = loc_server_register(test_dispcfg_server, &srv);
    258         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    259 
    260         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     316
     317        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     318
     319        // FIXME This causes this test to be non-reentrant!
     320        rc = loc_server_register(test_dispcfg_server);
     321        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     322
     323        rc = loc_service_register(test_dispcfg_svc, &sid);
    261324        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    262325
    … …  
    277340
    278341        dispcfg_close(dispcfg);
    279         rc = loc_service_unregister(srv, sid);
    280         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    281         loc_server_unregister(srv);
     342        rc = loc_service_unregister(sid);
     343        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282344}
    283345
    … …  
    290352        sysarg_t seat_id;
    291353        test_response_t resp;
    292         loc_srv_t *srv;
    293 
    294         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    295 
    296         // FIXME This causes this test to be non-reentrant!
    297         rc = loc_server_register(test_dispcfg_server, &srv);
    298         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    299 
    300         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     354
     355        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     356
     357        // FIXME This causes this test to be non-reentrant!
     358        rc = loc_server_register(test_dispcfg_server);
     359        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     360
     361        rc = loc_service_register(test_dispcfg_svc, &sid);
    301362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    302363
    … …  
    317378
    318379        dispcfg_close(dispcfg);
    319         rc = loc_service_unregister(srv, sid);
    320         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    321         loc_server_unregister(srv);
     380        rc = loc_service_unregister(sid);
     381        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    322382}
    323383
    … …  
    330390        sysarg_t seat_id;
    331391        test_response_t resp;
    332         loc_srv_t *srv;
    333 
    334         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    335 
    336         // FIXME This causes this test to be non-reentrant!
    337         rc = loc_server_register(test_dispcfg_server, &srv);
    338         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    339 
    340         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     392
     393        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     394
     395        // FIXME This causes this test to be non-reentrant!
     396        rc = loc_server_register(test_dispcfg_server);
     397        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     398
     399        rc = loc_service_register(test_dispcfg_svc, &sid);
    341400        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    342401
    … …  
    355414
    356415        dispcfg_close(dispcfg);
    357         rc = loc_service_unregister(srv, sid);
    358         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    359         loc_server_unregister(srv);
     416        rc = loc_service_unregister(sid);
     417        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    360418}
    361419
    … …  
    368426        sysarg_t seat_id;
    369427        test_response_t resp;
    370         loc_srv_t *srv;
    371 
    372         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    373 
    374         // FIXME This causes this test to be non-reentrant!
    375         rc = loc_server_register(test_dispcfg_server, &srv);
    376         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    377 
    378         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     428
     429        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     430
     431        // FIXME This causes this test to be non-reentrant!
     432        rc = loc_server_register(test_dispcfg_server);
     433        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     434
     435        rc = loc_service_register(test_dispcfg_svc, &sid);
    379436        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    380437
    … …  
    393450
    394451        dispcfg_close(dispcfg);
    395         rc = loc_service_unregister(srv, sid);
    396         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    397         loc_server_unregister(srv);
     452        rc = loc_service_unregister(sid);
     453        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    398454}
    399455
    … …  
    407463        sysarg_t seat_id;
    408464        test_response_t resp;
    409         loc_srv_t *srv;
    410 
    411         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    412 
    413         // FIXME This causes this test to be non-reentrant!
    414         rc = loc_server_register(test_dispcfg_server, &srv);
    415         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    416 
    417         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     465
     466        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     467
     468        // FIXME This causes this test to be non-reentrant!
     469        rc = loc_server_register(test_dispcfg_server);
     470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     471
     472        rc = loc_service_register(test_dispcfg_svc, &sid);
    418473        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    419474
    … …  
    434489
    435490        dispcfg_close(dispcfg);
    436         rc = loc_service_unregister(srv, sid);
    437         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    438         loc_server_unregister(srv);
     491        rc = loc_service_unregister(sid);
     492        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    439493}
    440494
    … …  
    448502        sysarg_t seat_id;
    449503        test_response_t resp;
    450         loc_srv_t *srv;
    451 
    452         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    453 
    454         // FIXME This causes this test to be non-reentrant!
    455         rc = loc_server_register(test_dispcfg_server, &srv);
    456         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    457 
    458         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     504
     505        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     506
     507        // FIXME This causes this test to be non-reentrant!
     508        rc = loc_server_register(test_dispcfg_server);
     509        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     510
     511        rc = loc_service_register(test_dispcfg_svc, &sid);
    459512        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    460513
    … …  
    475528
    476529        dispcfg_close(dispcfg);
    477         rc = loc_service_unregister(srv, sid);
    478         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    479         loc_server_unregister(srv);
     530        rc = loc_service_unregister(sid);
     531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    480532}
    481533
    … …  
    488540        sysarg_t svc_id;
    489541        test_response_t resp;
    490         loc_srv_t *srv;
    491 
    492         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    493 
    494         // FIXME This causes this test to be non-reentrant!
    495         rc = loc_server_register(test_dispcfg_server, &srv);
    496         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    497 
    498         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     542
     543        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     544
     545        // FIXME This causes this test to be non-reentrant!
     546        rc = loc_server_register(test_dispcfg_server);
     547        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     548
     549        rc = loc_service_register(test_dispcfg_svc, &sid);
    499550        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    500551
    … …  
    513564
    514565        dispcfg_close(dispcfg);
    515         rc = loc_service_unregister(srv, sid);
    516         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    517         loc_server_unregister(srv);
     566        rc = loc_service_unregister(sid);
     567        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    518568}
    519569
    … …  
    526576        sysarg_t svc_id;
    527577        test_response_t resp;
    528         loc_srv_t *srv;
    529 
    530         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    531 
    532         // FIXME This causes this test to be non-reentrant!
    533         rc = loc_server_register(test_dispcfg_server, &srv);
    534         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    535 
    536         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     578
     579        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     580
     581        // FIXME This causes this test to be non-reentrant!
     582        rc = loc_server_register(test_dispcfg_server);
     583        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     584
     585        rc = loc_service_register(test_dispcfg_svc, &sid);
    537586        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    538587
    … …  
    551600
    552601        dispcfg_close(dispcfg);
    553         rc = loc_service_unregister(srv, sid);
    554         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    555         loc_server_unregister(srv);
    556 }
    557 
    558 /** dispcfg_get_asgn_dev_list() with server returning error response works */
    559 PCUT_TEST(get_asgn_dev_list_failure)
    560 {
    561         errno_t rc;
    562         service_id_t sid;
    563         dispcfg_t *dispcfg = NULL;
    564         dispcfg_dev_list_t *list;
    565         sysarg_t seat_id;
    566         test_response_t resp;
    567         loc_srv_t *srv;
    568 
    569         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    570 
    571         // FIXME This causes this test to be non-reentrant!
    572         rc = loc_server_register(test_dispcfg_server, &srv);
    573         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    574 
    575         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    576         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    577 
    578         rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
    579         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    580         PCUT_ASSERT_NOT_NULL(dispcfg);
    581 
    582         resp.rc = ENOMEM;
    583         resp.get_asgn_dev_list_called = false;
    584         seat_id = 42;
    585 
    586         rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
    587         PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
    588         PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
    589         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    590 
    591         dispcfg_close(dispcfg);
    592         rc = loc_service_unregister(srv, sid);
    593         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    594         loc_server_unregister(srv);
    595 }
    596 
    597 /** dispcfg_get_asgn_dev_list() with server returning success response works */
    598 PCUT_TEST(get_asgn_dev_list_success)
    599 {
    600         errno_t rc;
    601         service_id_t sid;
    602         dispcfg_t *dispcfg = NULL;
    603         dispcfg_dev_list_t *list;
    604         sysarg_t seat_id;
    605         test_response_t resp;
    606         loc_srv_t *srv;
    607 
    608         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    609 
    610         // FIXME This causes this test to be non-reentrant!
    611         rc = loc_server_register(test_dispcfg_server, &srv);
    612         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    613 
    614         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    615         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    616 
    617         rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
    618         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    619         PCUT_ASSERT_NOT_NULL(dispcfg);
    620 
    621         resp.rc = EOK;
    622         resp.get_asgn_dev_list_called = false;
    623         resp.get_asgn_dev_list_rlist = calloc(1, sizeof(dispcfg_dev_list_t));
    624         PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist);
    625         resp.get_asgn_dev_list_rlist->ndevs = 2;
    626         resp.get_asgn_dev_list_rlist->devs = calloc(2, sizeof(sysarg_t));
    627         PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist->devs);
    628         resp.get_asgn_dev_list_rlist->devs[0] = 11;
    629         resp.get_asgn_dev_list_rlist->devs[1] = 12;
    630         seat_id = 42;
    631 
    632         rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
    633         PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
    634         PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
    635         PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    636 
    637         PCUT_ASSERT_INT_EQUALS(2, list->ndevs);
    638         PCUT_ASSERT_INT_EQUALS(11, list->devs[0]);
    639         PCUT_ASSERT_INT_EQUALS(12, list->devs[1]);
    640 
    641         dispcfg_free_dev_list(list);
    642         dispcfg_close(dispcfg);
    643         rc = loc_service_unregister(srv, sid);
    644         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    645         loc_server_unregister(srv);
     602        rc = loc_service_unregister(sid);
     603        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    646604}
    647605
    … …  
    653611        dispcfg_t *dispcfg = NULL;
    654612        test_response_t resp;
    655         loc_srv_t *srv;
    656 
    657         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    658 
    659         // FIXME This causes this test to be non-reentrant!
    660         rc = loc_server_register(test_dispcfg_server, &srv);
    661         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    662 
    663         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     613
     614        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     615
     616        // FIXME This causes this test to be non-reentrant!
     617        rc = loc_server_register(test_dispcfg_server);
     618        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     619
     620        rc = loc_service_register(test_dispcfg_svc, &sid);
    664621        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    665622
    … …  
    690647        dispcfg_close(dispcfg);
    691648
    692         rc = loc_service_unregister(srv, sid);
    693         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    694         loc_server_unregister(srv);
     649        rc = loc_service_unregister(sid);
     650        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    695651}
    696652
    … …  
    702658        dispcfg_t *dispcfg = NULL;
    703659        test_response_t resp;
    704         loc_srv_t *srv;
    705 
    706         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    707 
    708         // FIXME This causes this test to be non-reentrant!
    709         rc = loc_server_register(test_dispcfg_server, &srv);
    710         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    711 
    712         rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     660
     661        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     662
     663        // FIXME This causes this test to be non-reentrant!
     664        rc = loc_server_register(test_dispcfg_server);
     665        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     666
     667        rc = loc_service_register(test_dispcfg_svc, &sid);
    713668        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    714669
    … …  
    739694        dispcfg_close(dispcfg);
    740695
    741         rc = loc_service_unregister(srv, sid);
    742         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    743         loc_server_unregister(srv);
     696        rc = loc_service_unregister(sid);
     697        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     698}
     699
     700/** Test seat management service connection. */
     701static void test_dispcfg_conn(ipc_call_t *icall, void *arg)
     702{
     703        test_response_t *resp = (test_response_t *) arg;
     704        dispcfg_srv_t srv;
     705
     706        /* Set up protocol structure */
     707        dispcfg_srv_initialize(&srv);
     708        srv.ops = &test_dispcfg_srv_ops;
     709        srv.arg = arg;
     710        resp->srv = &srv;
     711
     712        /* Handle connection */
     713        dispcfg_conn(icall, &srv);
     714
     715        resp->srv = NULL;
     716}
     717
     718static void test_seat_added(void *arg, sysarg_t seat_id)
     719{
     720        test_response_t *resp = (test_response_t *) arg;
     721
     722        resp->revent.etype = dcev_seat_added;
     723
     724        fibril_mutex_lock(&resp->event_lock);
     725        resp->seat_added_called = true;
     726        resp->seat_added_seat_id = seat_id;
     727        fibril_condvar_broadcast(&resp->event_cv);
     728        fibril_mutex_unlock(&resp->event_lock);
     729}
     730
     731static void test_seat_removed(void *arg, sysarg_t seat_id)
     732{
     733        test_response_t *resp = (test_response_t *) arg;
     734
     735        resp->revent.etype = dcev_seat_removed;
     736
     737        fibril_mutex_lock(&resp->event_lock);
     738        resp->seat_removed_called = true;
     739        resp->seat_removed_seat_id = seat_id;
     740        fibril_condvar_broadcast(&resp->event_cv);
     741        fibril_mutex_unlock(&resp->event_lock);
     742}
     743
     744static errno_t test_get_seat_list(void *arg, dispcfg_seat_list_t **rlist)
     745{
     746        test_response_t *resp = (test_response_t *) arg;
     747
     748        resp->get_seat_list_called = true;
     749
     750        if (resp->rc != EOK)
     751                return resp->rc;
     752
     753        *rlist = resp->get_seat_list_rlist;
     754        return EOK;
     755}
     756
     757static errno_t test_get_seat_info(void *arg, sysarg_t seat_id,
     758    dispcfg_seat_info_t **rinfo)
     759{
     760        test_response_t *resp = (test_response_t *) arg;
     761
     762        resp->get_seat_info_called = true;
     763        resp->get_seat_info_seat_id = seat_id;
     764
     765        if (resp->rc != EOK)
     766                return resp->rc;
     767
     768        *rinfo = resp->get_seat_info_rinfo;
     769        return EOK;
     770}
     771
     772static errno_t test_seat_create(void *arg, const char *name, sysarg_t *rseat_id)
     773{
     774        test_response_t *resp = (test_response_t *) arg;
     775
     776        resp->seat_create_called = true;
     777        resp->seat_create_name = str_dup(name);
     778        *rseat_id = resp->seat_create_seat_id;
     779        return resp->rc;
     780}
     781
     782static errno_t test_seat_delete(void *arg, sysarg_t seat_id)
     783{
     784        test_response_t *resp = (test_response_t *) arg;
     785
     786        resp->seat_delete_called = true;
     787        resp->seat_delete_seat_id = seat_id;
     788        return resp->rc;
     789}
     790
     791static errno_t test_dev_assign(void *arg, sysarg_t svc_id, sysarg_t seat_id)
     792{
     793        test_response_t *resp = (test_response_t *) arg;
     794
     795        resp->dev_assign_called = true;
     796        resp->dev_assign_svc_id = svc_id;
     797        resp->dev_assign_seat_id = seat_id;
     798        return resp->rc;
     799}
     800
     801static errno_t test_dev_unassign(void *arg, sysarg_t svc_id)
     802{
     803        test_response_t *resp = (test_response_t *) arg;
     804
     805        resp->dev_unassign_called = true;
     806        resp->dev_unassign_svc_id = svc_id;
     807        return resp->rc;
     808}
     809
     810static errno_t test_get_event(void *arg, dispcfg_ev_t *event)
     811{
     812        test_response_t *resp = (test_response_t *) arg;
     813
     814        resp->get_event_called = true;
     815        if (resp->event_cnt > 0) {
     816                --resp->event_cnt;
     817                *event = resp->event;
     818                return EOK;
     819        }
     820
     821        return ENOENT;
    744822}
    745823
Note: See TracChangeset for help on using the changeset viewer.