Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb3eeae5 r4c6fd56  
    3535#include <pcut/pcut.h>
    3636#include <str.h>
     37#include <testdc.h>
    3738#include "../private/dispcfg.h"
    3839
    … …  
    4445static const char *test_dispcfg_svc = "test/dispcfg";
    4546
    46 static void test_dispcfg_conn(ipc_call_t *, void *);
    47 
    48 static errno_t test_get_seat_list(void *, dispcfg_seat_list_t **);
    49 static errno_t test_get_seat_info(void *, sysarg_t, dispcfg_seat_info_t **);
    50 static errno_t test_seat_create(void *, const char *, sysarg_t *);
    51 static errno_t test_seat_delete(void *, sysarg_t);
    52 static errno_t test_dev_assign(void *, sysarg_t, sysarg_t);
    53 static errno_t test_dev_unassign(void *, sysarg_t);
    54 static errno_t test_get_event(void *, dispcfg_ev_t *);
    55 
    56 static void test_seat_added(void *, sysarg_t);
    57 static void test_seat_removed(void *, sysarg_t);
    58 
    59 static 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 
    69 static 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  */
    77 typedef 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 
    12147/** dispcfg_open(), dispcfg_close() work for valid seat management service */
    12248PCUT_TEST(open_close)
    … …  
    12652        dispcfg_t *dispcfg = NULL;
    12753        test_response_t resp;
    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);
     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);
    14573}
    14674
    … …  
    15381        dispcfg_seat_list_t *list;
    15482        test_response_t resp;
    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);
     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);
    16392        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    16493
    … …  
    175104
    176105        dispcfg_close(dispcfg);
    177         rc = loc_service_unregister(sid);
    178         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     106        rc = loc_service_unregister(srv, sid);
     107        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     108        loc_server_unregister(srv);
    179109}
    180110
    … …  
    187117        dispcfg_seat_list_t *list;
    188118        test_response_t resp;
    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);
     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);
    197128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    198129
    … …  
    221152        dispcfg_free_seat_list(list);
    222153        dispcfg_close(dispcfg);
    223         rc = loc_service_unregister(sid);
    224         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     154        rc = loc_service_unregister(srv, sid);
     155        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     156        loc_server_unregister(srv);
    225157}
    226158
    … …  
    234166        dispcfg_seat_info_t *info;
    235167        test_response_t resp;
    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);
     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);
    244177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    245178
    … …  
    258191
    259192        dispcfg_close(dispcfg);
    260         rc = loc_service_unregister(sid);
    261         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     193        rc = loc_service_unregister(srv, sid);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195        loc_server_unregister(srv);
    262196}
    263197
    … …  
    271205        dispcfg_seat_info_t *info;
    272206        test_response_t resp;
    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);
     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);
    281216        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282217
    … …  
    302237        dispcfg_free_seat_info(info);
    303238        dispcfg_close(dispcfg);
    304         rc = loc_service_unregister(sid);
    305         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     239        rc = loc_service_unregister(srv, sid);
     240        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     241        loc_server_unregister(srv);
    306242}
    307243
    … …  
    314250        sysarg_t seat_id;
    315251        test_response_t resp;
    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);
     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);
    324261        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    325262
    … …  
    340277
    341278        dispcfg_close(dispcfg);
    342         rc = loc_service_unregister(sid);
    343         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279        rc = loc_service_unregister(srv, sid);
     280        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     281        loc_server_unregister(srv);
    344282}
    345283
    … …  
    352290        sysarg_t seat_id;
    353291        test_response_t resp;
    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);
     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);
    362301        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    363302
    … …  
    378317
    379318        dispcfg_close(dispcfg);
    380         rc = loc_service_unregister(sid);
    381         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);
    382322}
    383323
    … …  
    390330        sysarg_t seat_id;
    391331        test_response_t resp;
    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);
     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);
    400341        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    401342
    … …  
    414355
    415356        dispcfg_close(dispcfg);
    416         rc = loc_service_unregister(sid);
    417         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     357        rc = loc_service_unregister(srv, sid);
     358        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     359        loc_server_unregister(srv);
    418360}
    419361
    … …  
    426368        sysarg_t seat_id;
    427369        test_response_t resp;
    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);
     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);
    436379        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    437380
    … …  
    450393
    451394        dispcfg_close(dispcfg);
    452         rc = loc_service_unregister(sid);
    453         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     395        rc = loc_service_unregister(srv, sid);
     396        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     397        loc_server_unregister(srv);
    454398}
    455399
    … …  
    463407        sysarg_t seat_id;
    464408        test_response_t resp;
    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);
     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);
    473418        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    474419
    … …  
    489434
    490435        dispcfg_close(dispcfg);
    491         rc = loc_service_unregister(sid);
    492         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     436        rc = loc_service_unregister(srv, sid);
     437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     438        loc_server_unregister(srv);
    493439}
    494440
    … …  
    502448        sysarg_t seat_id;
    503449        test_response_t resp;
    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);
     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);
    512459        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    513460
    … …  
    528475
    529476        dispcfg_close(dispcfg);
    530         rc = loc_service_unregister(sid);
    531         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     477        rc = loc_service_unregister(srv, sid);
     478        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     479        loc_server_unregister(srv);
    532480}
    533481
    … …  
    540488        sysarg_t svc_id;
    541489        test_response_t resp;
    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);
     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);
    550499        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    551500
    … …  
    564513
    565514        dispcfg_close(dispcfg);
    566         rc = loc_service_unregister(sid);
    567         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     515        rc = loc_service_unregister(srv, sid);
     516        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     517        loc_server_unregister(srv);
    568518}
    569519
    … …  
    576526        sysarg_t svc_id;
    577527        test_response_t resp;
    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);
     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);
    586537        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    587538
    … …  
    600551
    601552        dispcfg_close(dispcfg);
    602         rc = loc_service_unregister(sid);
    603         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     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 */
     559PCUT_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 */
     598PCUT_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);
    604646}
    605647
    … …  
    611653        dispcfg_t *dispcfg = NULL;
    612654        test_response_t resp;
    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);
     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);
    621664        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    622665
    … …  
    647690        dispcfg_close(dispcfg);
    648691
    649         rc = loc_service_unregister(sid);
    650         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     692        rc = loc_service_unregister(srv, sid);
     693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     694        loc_server_unregister(srv);
    651695}
    652696
    … …  
    658702        dispcfg_t *dispcfg = NULL;
    659703        test_response_t resp;
    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);
     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);
    668713        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    669714
    … …  
    694739        dispcfg_close(dispcfg);
    695740
    696         rc = loc_service_unregister(sid);
    697         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    698 }
    699 
    700 /** Test seat management service connection. */
    701 static 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 
    718 static 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 
    731 static 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 
    744 static 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 
    757 static 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 
    772 static 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 
    782 static 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 
    791 static 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 
    801 static 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 
    810 static 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;
     741        rc = loc_service_unregister(srv, sid);
     742        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     743        loc_server_unregister(srv);
    822744}
    823745
Note: See TracChangeset for help on using the changeset viewer.