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

Last change on this file was ca48672, checked in by Jiri Svoboda <jiri@…>, 4 weeks ago

loc_service_register() needs to take a port ID argument.
  • Property mode set to 100644
File size: 21.5 KB
Line 
1/*
2 * Copyright (c) 2025 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, fallback_port_id,
63 &sid);
64 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
65
66 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
67 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
68 PCUT_ASSERT_NOT_NULL(dispcfg);
69
70 dispcfg_close(dispcfg);
71 rc = loc_service_unregister(srv, sid);
72 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
73 loc_server_unregister(srv);
74}
75
76/** dispcfg_get_seat_list() with server returning error response works */
77PCUT_TEST(get_seat_list_failure)
78{
79 errno_t rc;
80 service_id_t sid;
81 dispcfg_t *dispcfg = NULL;
82 dispcfg_seat_list_t *list;
83 test_response_t resp;
84 loc_srv_t *srv;
85
86 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
87
88 // FIXME This causes this test to be non-reentrant!
89 rc = loc_server_register(test_dispcfg_server, &srv);
90 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
91
92 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
93 &sid);
94 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
95
96 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
97 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
98 PCUT_ASSERT_NOT_NULL(dispcfg);
99
100 resp.rc = ENOMEM;
101 resp.get_seat_list_called = false;
102
103 rc = dispcfg_get_seat_list(dispcfg, &list);
104 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
105 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
106
107 dispcfg_close(dispcfg);
108 rc = loc_service_unregister(srv, sid);
109 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
110 loc_server_unregister(srv);
111}
112
113/** dispcfg_get_seat_list() with server returning success response works */
114PCUT_TEST(get_seat_list_success)
115{
116 errno_t rc;
117 service_id_t sid;
118 dispcfg_t *dispcfg = NULL;
119 dispcfg_seat_list_t *list;
120 test_response_t resp;
121 loc_srv_t *srv;
122
123 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
124
125 // FIXME This causes this test to be non-reentrant!
126 rc = loc_server_register(test_dispcfg_server, &srv);
127 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
128
129 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
130 &sid);
131 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
132
133 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
134 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
135 PCUT_ASSERT_NOT_NULL(dispcfg);
136
137 resp.rc = EOK;
138 resp.get_seat_list_called = false;
139 resp.get_seat_list_rlist = calloc(1, sizeof(dispcfg_seat_list_t));
140 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist);
141 resp.get_seat_list_rlist->nseats = 2;
142 resp.get_seat_list_rlist->seats = calloc(2, sizeof(sysarg_t));
143 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist->seats);
144 resp.get_seat_list_rlist->seats[0] = 42;
145 resp.get_seat_list_rlist->seats[1] = 43;
146
147 rc = dispcfg_get_seat_list(dispcfg, &list);
148 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
149 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
150
151 PCUT_ASSERT_INT_EQUALS(2, list->nseats);
152 PCUT_ASSERT_INT_EQUALS(42, list->seats[0]);
153 PCUT_ASSERT_INT_EQUALS(43, list->seats[1]);
154
155 dispcfg_free_seat_list(list);
156 dispcfg_close(dispcfg);
157 rc = loc_service_unregister(srv, sid);
158 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
159 loc_server_unregister(srv);
160}
161
162/** dispcfg_get_seat_infp() with server returning error response works */
163PCUT_TEST(get_seat_info_failure)
164{
165 errno_t rc;
166 service_id_t sid;
167 dispcfg_t *dispcfg = NULL;
168 sysarg_t seat_id;
169 dispcfg_seat_info_t *info;
170 test_response_t resp;
171 loc_srv_t *srv;
172
173 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
174
175 // FIXME This causes this test to be non-reentrant!
176 rc = loc_server_register(test_dispcfg_server, &srv);
177 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
178
179 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
180 &sid);
181 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
182
183 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
184 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
185 PCUT_ASSERT_NOT_NULL(dispcfg);
186
187 resp.rc = ENOMEM;
188 resp.get_seat_info_called = false;
189 seat_id = 1;
190
191 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
192 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
193 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
194 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
195
196 dispcfg_close(dispcfg);
197 rc = loc_service_unregister(srv, sid);
198 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
199 loc_server_unregister(srv);
200}
201
202/** dispcfg_get_seat_info() with server returning success response works */
203PCUT_TEST(get_seat_info_success)
204{
205 errno_t rc;
206 service_id_t sid;
207 dispcfg_t *dispcfg = NULL;
208 sysarg_t seat_id;
209 dispcfg_seat_info_t *info;
210 test_response_t resp;
211 loc_srv_t *srv;
212
213 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
214
215 // FIXME This causes this test to be non-reentrant!
216 rc = loc_server_register(test_dispcfg_server, &srv);
217 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
218
219 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
220 &sid);
221 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
222
223 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
224 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
225 PCUT_ASSERT_NOT_NULL(dispcfg);
226
227 resp.rc = EOK;
228 resp.get_seat_info_called = false;
229 resp.get_seat_info_rinfo = calloc(1, sizeof(dispcfg_seat_info_t));
230 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo);
231 resp.get_seat_info_rinfo->name = str_dup("Hello");
232 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo->name);
233 seat_id = 1;
234
235 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
236 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
237 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
238 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
239
240 PCUT_ASSERT_STR_EQUALS("Hello", info->name);
241
242 dispcfg_free_seat_info(info);
243 dispcfg_close(dispcfg);
244 rc = loc_service_unregister(srv, sid);
245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
246 loc_server_unregister(srv);
247}
248
249/** dispcfg_seat_create() with server returning error response works */
250PCUT_TEST(seat_create_failure)
251{
252 errno_t rc;
253 service_id_t sid;
254 dispcfg_t *dispcfg = NULL;
255 sysarg_t seat_id;
256 test_response_t resp;
257 loc_srv_t *srv;
258
259 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
260
261 // FIXME This causes this test to be non-reentrant!
262 rc = loc_server_register(test_dispcfg_server, &srv);
263 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
264
265 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
266 &sid);
267 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
268
269 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
270 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
271 PCUT_ASSERT_NOT_NULL(dispcfg);
272
273 seat_id = 13;
274 seat_id = 42;
275 resp.rc = ENOMEM;
276 resp.seat_create_called = false;
277
278 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
279 PCUT_ASSERT_TRUE(resp.seat_create_called);
280 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
281 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
282 free(resp.seat_create_name);
283
284 dispcfg_close(dispcfg);
285 rc = loc_service_unregister(srv, sid);
286 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
287 loc_server_unregister(srv);
288}
289
290/** dispcfg_seat_create() with server returning success response works */
291PCUT_TEST(seat_create_success)
292{
293 errno_t rc;
294 service_id_t sid;
295 dispcfg_t *dispcfg = NULL;
296 sysarg_t seat_id;
297 test_response_t resp;
298 loc_srv_t *srv;
299
300 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
301
302 // FIXME This causes this test to be non-reentrant!
303 rc = loc_server_register(test_dispcfg_server, &srv);
304 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
305
306 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
307 &sid);
308 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
309
310 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
311 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
312 PCUT_ASSERT_NOT_NULL(dispcfg);
313
314 resp.rc = EOK;
315 resp.seat_create_called = false;
316 resp.seat_create_seat_id = 42;
317
318 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
319 PCUT_ASSERT_TRUE(resp.seat_create_called);
320 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
321 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_create_seat_id);
322 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
323 free(resp.seat_create_name);
324
325 dispcfg_close(dispcfg);
326 rc = loc_service_unregister(srv, sid);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328 loc_server_unregister(srv);
329}
330
331/** dispcfg_seat_delete() with server returning error response works */
332PCUT_TEST(seat_delete_failure)
333{
334 errno_t rc;
335 service_id_t sid;
336 dispcfg_t *dispcfg = NULL;
337 sysarg_t seat_id;
338 test_response_t resp;
339 loc_srv_t *srv;
340
341 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
342
343 // FIXME This causes this test to be non-reentrant!
344 rc = loc_server_register(test_dispcfg_server, &srv);
345 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
346
347 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
348 &sid);
349 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
350
351 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
352 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
353 PCUT_ASSERT_NOT_NULL(dispcfg);
354
355 seat_id = 42;
356 resp.rc = ENOMEM;
357 resp.seat_delete_called = false;
358
359 rc = dispcfg_seat_delete(dispcfg, seat_id);
360 PCUT_ASSERT_TRUE(resp.seat_delete_called);
361 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
362 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
363
364 dispcfg_close(dispcfg);
365 rc = loc_service_unregister(srv, sid);
366 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
367 loc_server_unregister(srv);
368}
369
370/** dispcfg_seat_delete() with server returning success response works */
371PCUT_TEST(seat_delete_success)
372{
373 errno_t rc;
374 service_id_t sid;
375 dispcfg_t *dispcfg = NULL;
376 sysarg_t seat_id;
377 test_response_t resp;
378 loc_srv_t *srv;
379
380 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
381
382 // FIXME This causes this test to be non-reentrant!
383 rc = loc_server_register(test_dispcfg_server, &srv);
384 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
385
386 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
387 &sid);
388 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
389
390 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
391 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
392 PCUT_ASSERT_NOT_NULL(dispcfg);
393
394 seat_id = 42;
395 resp.rc = EOK;
396 resp.seat_delete_called = false;
397
398 rc = dispcfg_seat_delete(dispcfg, seat_id);
399 PCUT_ASSERT_TRUE(resp.seat_delete_called);
400 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
401 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
402
403 dispcfg_close(dispcfg);
404 rc = loc_service_unregister(srv, sid);
405 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
406 loc_server_unregister(srv);
407}
408
409/** dispcfg_dev_assign() with server returning error response works */
410PCUT_TEST(dev_assign_failure)
411{
412 errno_t rc;
413 service_id_t sid;
414 dispcfg_t *dispcfg = NULL;
415 sysarg_t svc_id;
416 sysarg_t seat_id;
417 test_response_t resp;
418 loc_srv_t *srv;
419
420 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
421
422 // FIXME This causes this test to be non-reentrant!
423 rc = loc_server_register(test_dispcfg_server, &srv);
424 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
425
426 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
427 &sid);
428 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
429
430 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
431 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
432 PCUT_ASSERT_NOT_NULL(dispcfg);
433
434 svc_id = 12;
435 seat_id = 13;
436 resp.rc = ENOMEM;
437 resp.dev_assign_called = false;
438
439 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
440 PCUT_ASSERT_TRUE(resp.dev_assign_called);
441 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
442 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
443 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
444
445 dispcfg_close(dispcfg);
446 rc = loc_service_unregister(srv, sid);
447 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
448 loc_server_unregister(srv);
449}
450
451/** dispcfg_dev_assign() with server returning success response works */
452PCUT_TEST(dev_assign_success)
453{
454 errno_t rc;
455 service_id_t sid;
456 dispcfg_t *dispcfg = NULL;
457 sysarg_t svc_id;
458 sysarg_t seat_id;
459 test_response_t resp;
460 loc_srv_t *srv;
461
462 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
463
464 // FIXME This causes this test to be non-reentrant!
465 rc = loc_server_register(test_dispcfg_server, &srv);
466 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
467
468 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
469 &sid);
470 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
471
472 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
473 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
474 PCUT_ASSERT_NOT_NULL(dispcfg);
475
476 svc_id = 12;
477 seat_id = 13;
478 resp.rc = EOK;
479 resp.dev_assign_called = false;
480
481 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
482 PCUT_ASSERT_TRUE(resp.dev_assign_called);
483 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
484 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
485 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
486
487 dispcfg_close(dispcfg);
488 rc = loc_service_unregister(srv, sid);
489 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
490 loc_server_unregister(srv);
491}
492
493/** dispcfg_dev_unassign() with server returning error response works */
494PCUT_TEST(dev_unassign_failure)
495{
496 errno_t rc;
497 service_id_t sid;
498 dispcfg_t *dispcfg = NULL;
499 sysarg_t svc_id;
500 test_response_t resp;
501 loc_srv_t *srv;
502
503 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
504
505 // FIXME This causes this test to be non-reentrant!
506 rc = loc_server_register(test_dispcfg_server, &srv);
507 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
508
509 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
510 &sid);
511 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
512
513 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
515 PCUT_ASSERT_NOT_NULL(dispcfg);
516
517 svc_id = 12;
518 resp.rc = ENOMEM;
519 resp.dev_unassign_called = false;
520
521 rc = dispcfg_dev_unassign(dispcfg, svc_id);
522 PCUT_ASSERT_TRUE(resp.dev_unassign_called);
523 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_unassign_svc_id);
524 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
525
526 dispcfg_close(dispcfg);
527 rc = loc_service_unregister(srv, sid);
528 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
529 loc_server_unregister(srv);
530}
531
532/** dispcfg_dev_unassign() with server returning success response works */
533PCUT_TEST(dev_unassign_success)
534{
535 errno_t rc;
536 service_id_t sid;
537 dispcfg_t *dispcfg = NULL;
538 sysarg_t svc_id;
539 test_response_t resp;
540 loc_srv_t *srv;
541
542 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
543
544 // FIXME This causes this test to be non-reentrant!
545 rc = loc_server_register(test_dispcfg_server, &srv);
546 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
547
548 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
549 &sid);
550 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
551
552 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
553 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
554 PCUT_ASSERT_NOT_NULL(dispcfg);
555
556 svc_id = 12;
557 resp.rc = EOK;
558 resp.dev_unassign_called = false;
559
560 rc = dispcfg_dev_unassign(dispcfg, svc_id);
561 PCUT_ASSERT_TRUE(resp.dev_unassign_called);
562 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_unassign_svc_id);
563 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
564
565 dispcfg_close(dispcfg);
566 rc = loc_service_unregister(srv, sid);
567 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
568 loc_server_unregister(srv);
569}
570
571/** dispcfg_get_asgn_dev_list() with server returning error response works */
572PCUT_TEST(get_asgn_dev_list_failure)
573{
574 errno_t rc;
575 service_id_t sid;
576 dispcfg_t *dispcfg = NULL;
577 dispcfg_dev_list_t *list;
578 sysarg_t seat_id;
579 test_response_t resp;
580 loc_srv_t *srv;
581
582 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
583
584 // FIXME This causes this test to be non-reentrant!
585 rc = loc_server_register(test_dispcfg_server, &srv);
586 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
587
588 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
589 &sid);
590 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
591
592 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
593 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
594 PCUT_ASSERT_NOT_NULL(dispcfg);
595
596 resp.rc = ENOMEM;
597 resp.get_asgn_dev_list_called = false;
598 seat_id = 42;
599
600 rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
601 PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
602 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
603 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
604
605 dispcfg_close(dispcfg);
606 rc = loc_service_unregister(srv, sid);
607 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
608 loc_server_unregister(srv);
609}
610
611/** dispcfg_get_asgn_dev_list() with server returning success response works */
612PCUT_TEST(get_asgn_dev_list_success)
613{
614 errno_t rc;
615 service_id_t sid;
616 dispcfg_t *dispcfg = NULL;
617 dispcfg_dev_list_t *list;
618 sysarg_t seat_id;
619 test_response_t resp;
620 loc_srv_t *srv;
621
622 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
623
624 // FIXME This causes this test to be non-reentrant!
625 rc = loc_server_register(test_dispcfg_server, &srv);
626 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
627
628 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
629 &sid);
630 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
631
632 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
633 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
634 PCUT_ASSERT_NOT_NULL(dispcfg);
635
636 resp.rc = EOK;
637 resp.get_asgn_dev_list_called = false;
638 resp.get_asgn_dev_list_rlist = calloc(1, sizeof(dispcfg_dev_list_t));
639 PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist);
640 resp.get_asgn_dev_list_rlist->ndevs = 2;
641 resp.get_asgn_dev_list_rlist->devs = calloc(2, sizeof(sysarg_t));
642 PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist->devs);
643 resp.get_asgn_dev_list_rlist->devs[0] = 11;
644 resp.get_asgn_dev_list_rlist->devs[1] = 12;
645 seat_id = 42;
646
647 rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
648 PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
649 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
650 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
651
652 PCUT_ASSERT_INT_EQUALS(2, list->ndevs);
653 PCUT_ASSERT_INT_EQUALS(11, list->devs[0]);
654 PCUT_ASSERT_INT_EQUALS(12, list->devs[1]);
655
656 dispcfg_free_dev_list(list);
657 dispcfg_close(dispcfg);
658 rc = loc_service_unregister(srv, sid);
659 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
660 loc_server_unregister(srv);
661}
662
663/** Window added event can be delivered from server to client callback function */
664PCUT_TEST(seat_added_deliver)
665{
666 errno_t rc;
667 service_id_t sid;
668 dispcfg_t *dispcfg = NULL;
669 test_response_t resp;
670 loc_srv_t *srv;
671
672 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
673
674 // FIXME This causes this test to be non-reentrant!
675 rc = loc_server_register(test_dispcfg_server, &srv);
676 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
677
678 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
679 &sid);
680 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
681
682 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
683 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
684 PCUT_ASSERT_NOT_NULL(dispcfg);
685 PCUT_ASSERT_NOT_NULL(resp.srv);
686
687 resp.event_cnt = 1;
688 resp.event.etype = dcev_seat_added;
689 resp.event.seat_id = 42;
690 resp.seat_added_called = false;
691 fibril_mutex_initialize(&resp.event_lock);
692 fibril_condvar_initialize(&resp.event_cv);
693 dispcfg_srv_ev_pending(resp.srv);
694
695 /* Wait for the event handler to be called. */
696 fibril_mutex_lock(&resp.event_lock);
697 while (!resp.seat_added_called) {
698 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
699 }
700 fibril_mutex_unlock(&resp.event_lock);
701
702 /* Verify that the event was delivered correctly */
703 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
704 resp.revent.etype);
705
706 dispcfg_close(dispcfg);
707
708 rc = loc_service_unregister(srv, sid);
709 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
710 loc_server_unregister(srv);
711}
712
713/** Window removed event can be delivered from server to client callback function */
714PCUT_TEST(seat_removed_deliver)
715{
716 errno_t rc;
717 service_id_t sid;
718 dispcfg_t *dispcfg = NULL;
719 test_response_t resp;
720 loc_srv_t *srv;
721
722 async_set_fallback_port_handler(test_dispcfg_conn, &resp);
723
724 // FIXME This causes this test to be non-reentrant!
725 rc = loc_server_register(test_dispcfg_server, &srv);
726 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
727
728 rc = loc_service_register(srv, test_dispcfg_svc, fallback_port_id,
729 &sid);
730 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
731
732 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
733 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
734 PCUT_ASSERT_NOT_NULL(dispcfg);
735 PCUT_ASSERT_NOT_NULL(resp.srv);
736
737 resp.event_cnt = 1;
738 resp.event.etype = dcev_seat_removed;
739 resp.event.seat_id = 42;
740 resp.seat_removed_called = false;
741 fibril_mutex_initialize(&resp.event_lock);
742 fibril_condvar_initialize(&resp.event_cv);
743 dispcfg_srv_ev_pending(resp.srv);
744
745 /* Wait for the event handler to be called. */
746 fibril_mutex_lock(&resp.event_lock);
747 while (!resp.seat_removed_called) {
748 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
749 }
750 fibril_mutex_unlock(&resp.event_lock);
751
752 /* Verify that the event was delivered correctly */
753 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
754 resp.revent.etype);
755
756 dispcfg_close(dispcfg);
757
758 rc = loc_service_unregister(srv, sid);
759 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
760 loc_server_unregister(srv);
761}
762
763PCUT_EXPORT(dispcfg);
Note: See TracBrowser for help on using the repository browser.