source: mainline/uspace/lib/dispcfg/test/dispcfg.c@ b1397ab

topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b1397ab was 4c6fd56, checked in by Jiri Svoboda <jiri@…>, 2 years ago

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.

  • Property mode set to 100644
File size: 21.2 KB
Line 
1/*
2 * Copyright (c) 2023 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <async.h>
30#include <errno.h>
31#include <dispcfg.h>
32#include <dispcfg_srv.h>
33#include <fibril_synch.h>
34#include <loc.h>
35#include <pcut/pcut.h>
36#include <str.h>
37#include <testdc.h>
38#include "../private/dispcfg.h"
39
40PCUT_INIT;
41
42PCUT_TEST_SUITE(dispcfg);
43
44static const char *test_dispcfg_server = "test-dispcfg";
45static const char *test_dispcfg_svc = "test/dispcfg";
46
47/** dispcfg_open(), dispcfg_close() work for valid seat management service */
48PCUT_TEST(open_close)
49{
50 errno_t rc;
51 service_id_t sid;
52 dispcfg_t *dispcfg = NULL;
53 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);
73}
74
75/** dispcfg_get_seat_list() with server returning error response works */
76PCUT_TEST(get_seat_list_failure)
77{
78 errno_t rc;
79 service_id_t sid;
80 dispcfg_t *dispcfg = NULL;
81 dispcfg_seat_list_t *list;
82 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);
92 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
93
94 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
95 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
96 PCUT_ASSERT_NOT_NULL(dispcfg);
97
98 resp.rc = ENOMEM;
99 resp.get_seat_list_called = false;
100
101 rc = dispcfg_get_seat_list(dispcfg, &list);
102 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
103 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
104
105 dispcfg_close(dispcfg);
106 rc = loc_service_unregister(srv, sid);
107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
108 loc_server_unregister(srv);
109}
110
111/** dispcfg_get_seat_list() with server returning success response works */
112PCUT_TEST(get_seat_list_success)
113{
114 errno_t rc;
115 service_id_t sid;
116 dispcfg_t *dispcfg = NULL;
117 dispcfg_seat_list_t *list;
118 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);
128 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
129
130 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
131 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
132 PCUT_ASSERT_NOT_NULL(dispcfg);
133
134 resp.rc = EOK;
135 resp.get_seat_list_called = false;
136 resp.get_seat_list_rlist = calloc(1, sizeof(dispcfg_seat_list_t));
137 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist);
138 resp.get_seat_list_rlist->nseats = 2;
139 resp.get_seat_list_rlist->seats = calloc(2, sizeof(sysarg_t));
140 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist->seats);
141 resp.get_seat_list_rlist->seats[0] = 42;
142 resp.get_seat_list_rlist->seats[1] = 43;
143
144 rc = dispcfg_get_seat_list(dispcfg, &list);
145 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
146 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
147
148 PCUT_ASSERT_INT_EQUALS(2, list->nseats);
149 PCUT_ASSERT_INT_EQUALS(42, list->seats[0]);
150 PCUT_ASSERT_INT_EQUALS(43, list->seats[1]);
151
152 dispcfg_free_seat_list(list);
153 dispcfg_close(dispcfg);
154 rc = loc_service_unregister(srv, sid);
155 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
156 loc_server_unregister(srv);
157}
158
159/** dispcfg_get_seat_infp() with server returning error response works */
160PCUT_TEST(get_seat_info_failure)
161{
162 errno_t rc;
163 service_id_t sid;
164 dispcfg_t *dispcfg = NULL;
165 sysarg_t seat_id;
166 dispcfg_seat_info_t *info;
167 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);
177 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
178
179 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
180 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
181 PCUT_ASSERT_NOT_NULL(dispcfg);
182
183 resp.rc = ENOMEM;
184 resp.get_seat_info_called = false;
185 seat_id = 1;
186
187 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
188 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
189 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
190 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
191
192 dispcfg_close(dispcfg);
193 rc = loc_service_unregister(srv, sid);
194 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
195 loc_server_unregister(srv);
196}
197
198/** dispcfg_get_seat_info() with server returning success response works */
199PCUT_TEST(get_seat_info_success)
200{
201 errno_t rc;
202 service_id_t sid;
203 dispcfg_t *dispcfg = NULL;
204 sysarg_t seat_id;
205 dispcfg_seat_info_t *info;
206 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);
216 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
217
218 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
219 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
220 PCUT_ASSERT_NOT_NULL(dispcfg);
221
222 resp.rc = EOK;
223 resp.get_seat_info_called = false;
224 resp.get_seat_info_rinfo = calloc(1, sizeof(dispcfg_seat_info_t));
225 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo);
226 resp.get_seat_info_rinfo->name = str_dup("Hello");
227 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo->name);
228 seat_id = 1;
229
230 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
231 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
232 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
233 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
234
235 PCUT_ASSERT_STR_EQUALS("Hello", info->name);
236
237 dispcfg_free_seat_info(info);
238 dispcfg_close(dispcfg);
239 rc = loc_service_unregister(srv, sid);
240 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
241 loc_server_unregister(srv);
242}
243
244/** dispcfg_seat_create() with server returning error response works */
245PCUT_TEST(seat_create_failure)
246{
247 errno_t rc;
248 service_id_t sid;
249 dispcfg_t *dispcfg = NULL;
250 sysarg_t seat_id;
251 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);
261 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
262
263 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
264 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
265 PCUT_ASSERT_NOT_NULL(dispcfg);
266
267 seat_id = 13;
268 seat_id = 42;
269 resp.rc = ENOMEM;
270 resp.seat_create_called = false;
271
272 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
273 PCUT_ASSERT_TRUE(resp.seat_create_called);
274 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
275 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
276 free(resp.seat_create_name);
277
278 dispcfg_close(dispcfg);
279 rc = loc_service_unregister(srv, sid);
280 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
281 loc_server_unregister(srv);
282}
283
284/** dispcfg_seat_create() with server returning success response works */
285PCUT_TEST(seat_create_success)
286{
287 errno_t rc;
288 service_id_t sid;
289 dispcfg_t *dispcfg = NULL;
290 sysarg_t seat_id;
291 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);
301 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
302
303 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
304 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
305 PCUT_ASSERT_NOT_NULL(dispcfg);
306
307 resp.rc = EOK;
308 resp.seat_create_called = false;
309 resp.seat_create_seat_id = 42;
310
311 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
312 PCUT_ASSERT_TRUE(resp.seat_create_called);
313 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
314 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_create_seat_id);
315 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
316 free(resp.seat_create_name);
317
318 dispcfg_close(dispcfg);
319 rc = loc_service_unregister(srv, sid);
320 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
321 loc_server_unregister(srv);
322}
323
324/** dispcfg_seat_delete() with server returning error response works */
325PCUT_TEST(seat_delete_failure)
326{
327 errno_t rc;
328 service_id_t sid;
329 dispcfg_t *dispcfg = NULL;
330 sysarg_t seat_id;
331 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);
341 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
342
343 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
344 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
345 PCUT_ASSERT_NOT_NULL(dispcfg);
346
347 seat_id = 42;
348 resp.rc = ENOMEM;
349 resp.seat_delete_called = false;
350
351 rc = dispcfg_seat_delete(dispcfg, seat_id);
352 PCUT_ASSERT_TRUE(resp.seat_delete_called);
353 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
354 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
355
356 dispcfg_close(dispcfg);
357 rc = loc_service_unregister(srv, sid);
358 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
359 loc_server_unregister(srv);
360}
361
362/** dispcfg_seat_delete() with server returning success response works */
363PCUT_TEST(seat_delete_success)
364{
365 errno_t rc;
366 service_id_t sid;
367 dispcfg_t *dispcfg = NULL;
368 sysarg_t seat_id;
369 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);
379 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
380
381 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
382 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
383 PCUT_ASSERT_NOT_NULL(dispcfg);
384
385 seat_id = 42;
386 resp.rc = EOK;
387 resp.seat_delete_called = false;
388
389 rc = dispcfg_seat_delete(dispcfg, seat_id);
390 PCUT_ASSERT_TRUE(resp.seat_delete_called);
391 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
392 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
393
394 dispcfg_close(dispcfg);
395 rc = loc_service_unregister(srv, sid);
396 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
397 loc_server_unregister(srv);
398}
399
400/** dispcfg_dev_assign() with server returning error response works */
401PCUT_TEST(dev_assign_failure)
402{
403 errno_t rc;
404 service_id_t sid;
405 dispcfg_t *dispcfg = NULL;
406 sysarg_t svc_id;
407 sysarg_t seat_id;
408 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);
418 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
419
420 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
421 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
422 PCUT_ASSERT_NOT_NULL(dispcfg);
423
424 svc_id = 12;
425 seat_id = 13;
426 resp.rc = ENOMEM;
427 resp.dev_assign_called = false;
428
429 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
430 PCUT_ASSERT_TRUE(resp.dev_assign_called);
431 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
432 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
433 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
434
435 dispcfg_close(dispcfg);
436 rc = loc_service_unregister(srv, sid);
437 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
438 loc_server_unregister(srv);
439}
440
441/** dispcfg_dev_assign() with server returning success response works */
442PCUT_TEST(dev_assign_success)
443{
444 errno_t rc;
445 service_id_t sid;
446 dispcfg_t *dispcfg = NULL;
447 sysarg_t svc_id;
448 sysarg_t seat_id;
449 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);
459 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
460
461 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
462 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
463 PCUT_ASSERT_NOT_NULL(dispcfg);
464
465 svc_id = 12;
466 seat_id = 13;
467 resp.rc = EOK;
468 resp.dev_assign_called = false;
469
470 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
471 PCUT_ASSERT_TRUE(resp.dev_assign_called);
472 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
473 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
474 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
475
476 dispcfg_close(dispcfg);
477 rc = loc_service_unregister(srv, sid);
478 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
479 loc_server_unregister(srv);
480}
481
482/** dispcfg_dev_unassign() with server returning error response works */
483PCUT_TEST(dev_unassign_failure)
484{
485 errno_t rc;
486 service_id_t sid;
487 dispcfg_t *dispcfg = NULL;
488 sysarg_t svc_id;
489 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);
499 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
500
501 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
502 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
503 PCUT_ASSERT_NOT_NULL(dispcfg);
504
505 svc_id = 12;
506 resp.rc = ENOMEM;
507 resp.dev_unassign_called = false;
508
509 rc = dispcfg_dev_unassign(dispcfg, svc_id);
510 PCUT_ASSERT_TRUE(resp.dev_unassign_called);
511 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_unassign_svc_id);
512 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
513
514 dispcfg_close(dispcfg);
515 rc = loc_service_unregister(srv, sid);
516 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
517 loc_server_unregister(srv);
518}
519
520/** dispcfg_dev_unassign() with server returning success response works */
521PCUT_TEST(dev_unassign_success)
522{
523 errno_t rc;
524 service_id_t sid;
525 dispcfg_t *dispcfg = NULL;
526 sysarg_t svc_id;
527 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);
537 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
538
539 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
540 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
541 PCUT_ASSERT_NOT_NULL(dispcfg);
542
543 svc_id = 12;
544 resp.rc = EOK;
545 resp.dev_unassign_called = false;
546
547 rc = dispcfg_dev_unassign(dispcfg, svc_id);
548 PCUT_ASSERT_TRUE(resp.dev_unassign_called);
549 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_unassign_svc_id);
550 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
551
552 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 */
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);
646}
647
648/** Window added event can be delivered from server to client callback function */
649PCUT_TEST(seat_added_deliver)
650{
651 errno_t rc;
652 service_id_t sid;
653 dispcfg_t *dispcfg = NULL;
654 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);
664 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
665
666 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
667 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
668 PCUT_ASSERT_NOT_NULL(dispcfg);
669 PCUT_ASSERT_NOT_NULL(resp.srv);
670
671 resp.event_cnt = 1;
672 resp.event.etype = dcev_seat_added;
673 resp.event.seat_id = 42;
674 resp.seat_added_called = false;
675 fibril_mutex_initialize(&resp.event_lock);
676 fibril_condvar_initialize(&resp.event_cv);
677 dispcfg_srv_ev_pending(resp.srv);
678
679 /* Wait for the event handler to be called. */
680 fibril_mutex_lock(&resp.event_lock);
681 while (!resp.seat_added_called) {
682 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
683 }
684 fibril_mutex_unlock(&resp.event_lock);
685
686 /* Verify that the event was delivered correctly */
687 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
688 resp.revent.etype);
689
690 dispcfg_close(dispcfg);
691
692 rc = loc_service_unregister(srv, sid);
693 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
694 loc_server_unregister(srv);
695}
696
697/** Window removed event can be delivered from server to client callback function */
698PCUT_TEST(seat_removed_deliver)
699{
700 errno_t rc;
701 service_id_t sid;
702 dispcfg_t *dispcfg = NULL;
703 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);
713 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
714
715 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
716 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
717 PCUT_ASSERT_NOT_NULL(dispcfg);
718 PCUT_ASSERT_NOT_NULL(resp.srv);
719
720 resp.event_cnt = 1;
721 resp.event.etype = dcev_seat_removed;
722 resp.event.seat_id = 42;
723 resp.seat_removed_called = false;
724 fibril_mutex_initialize(&resp.event_lock);
725 fibril_condvar_initialize(&resp.event_cv);
726 dispcfg_srv_ev_pending(resp.srv);
727
728 /* Wait for the event handler to be called. */
729 fibril_mutex_lock(&resp.event_lock);
730 while (!resp.seat_removed_called) {
731 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
732 }
733 fibril_mutex_unlock(&resp.event_lock);
734
735 /* Verify that the event was delivered correctly */
736 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
737 resp.revent.etype);
738
739 dispcfg_close(dispcfg);
740
741 rc = loc_service_unregister(srv, sid);
742 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
743 loc_server_unregister(srv);
744}
745
746PCUT_EXPORT(dispcfg);
Note: See TracBrowser for help on using the repository browser.