source: mainline/uspace/lib/dispcfg/test/dispcfg.c@ 24be331e

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 24be331e was cdf5361, checked in by Jiri Svoboda <jiri@…>, 3 years ago

Factor out test display service

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