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

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

Assigning devices to seats
  • Property mode set to 100644
File size: 22.3 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 "../private/dispcfg.h"
38
39PCUT_INIT;
40
41PCUT_TEST_SUITE(dispcfg);
42
43static const char *test_dispcfg_server = "test-dispcfg";
44static const char *test_dispcfg_svc = "test/dispcfg";
45
46static void test_dispcfg_conn(ipc_call_t *, void *);
47
48static errno_t test_get_seat_list(void *, dispcfg_seat_list_t **);
49static errno_t test_get_seat_info(void *, sysarg_t, dispcfg_seat_info_t **);
50static errno_t test_seat_create(void *, const char *, sysarg_t *);
51static errno_t test_seat_delete(void *, sysarg_t);
52static errno_t test_dev_assign(void *, sysarg_t, sysarg_t);
53static errno_t test_dev_unassign(void *, sysarg_t);
54static errno_t test_get_event(void *, dispcfg_ev_t *);
55
56static void test_seat_added(void *, sysarg_t);
57static void test_seat_removed(void *, sysarg_t);
58
59static dispcfg_ops_t test_dispcfg_srv_ops = {
60 .get_seat_list = test_get_seat_list,
61 .get_seat_info = test_get_seat_info,
62 .seat_create = test_seat_create,
63 .seat_delete = test_seat_delete,
64 .dev_assign = test_dev_assign,
65 .dev_unassign = test_dev_unassign,
66 .get_event = test_get_event
67};
68
69static dispcfg_cb_t test_dispcfg_cb = {
70 .seat_added = test_seat_added,
71 .seat_removed = test_seat_removed
72};
73
74/** Describes to the server how to respond to our request and pass tracking
75 * data back to the client.
76 */
77typedef struct {
78 errno_t rc;
79 sysarg_t seat_id;
80 dispcfg_ev_t event;
81 dispcfg_ev_t revent;
82 int event_cnt;
83
84 bool get_seat_list_called;
85 dispcfg_seat_list_t *get_seat_list_rlist;
86
87 bool get_seat_info_called;
88 sysarg_t get_seat_info_seat_id;
89 dispcfg_seat_info_t *get_seat_info_rinfo;
90
91 bool seat_create_called;
92 char *seat_create_name;
93 sysarg_t seat_create_seat_id;
94
95 bool seat_delete_called;
96 sysarg_t seat_delete_seat_id;
97
98 bool dev_assign_called;
99 sysarg_t dev_assign_svc_id;
100 sysarg_t dev_assign_seat_id;
101
102 bool dev_unassign_called;
103 sysarg_t dev_unassign_svc_id;
104
105 bool get_event_called;
106
107 bool seat_added_called;
108 sysarg_t seat_added_seat_id;
109
110 bool seat_removed_called;
111 sysarg_t seat_removed_seat_id;
112
113 bool seat_changed_called;
114 sysarg_t seat_changed_seat_id;
115
116 fibril_condvar_t event_cv;
117 fibril_mutex_t event_lock;
118 dispcfg_srv_t *srv;
119} test_response_t;
120
121/** dispcfg_open(), dispcfg_close() work for valid seat management service */
122PCUT_TEST(open_close)
123{
124 errno_t rc;
125 service_id_t sid;
126 dispcfg_t *dispcfg = NULL;
127 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);
145}
146
147/** dispcfg_get_seat_list() with server returning error response works */
148PCUT_TEST(get_seat_list_failure)
149{
150 errno_t rc;
151 service_id_t sid;
152 dispcfg_t *dispcfg = NULL;
153 dispcfg_seat_list_t *list;
154 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);
163 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
164
165 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
167 PCUT_ASSERT_NOT_NULL(dispcfg);
168
169 resp.rc = ENOMEM;
170 resp.get_seat_list_called = false;
171
172 rc = dispcfg_get_seat_list(dispcfg, &list);
173 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
174 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
175
176 dispcfg_close(dispcfg);
177 rc = loc_service_unregister(sid);
178 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
179}
180
181/** dispcfg_get_seat_list() with server returning success response works */
182PCUT_TEST(get_seat_list_success)
183{
184 errno_t rc;
185 service_id_t sid;
186 dispcfg_t *dispcfg = NULL;
187 dispcfg_seat_list_t *list;
188 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);
197 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
198
199 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
200 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
201 PCUT_ASSERT_NOT_NULL(dispcfg);
202
203 resp.rc = EOK;
204 resp.get_seat_list_called = false;
205 resp.get_seat_list_rlist = calloc(1, sizeof(dispcfg_seat_list_t));
206 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist);
207 resp.get_seat_list_rlist->nseats = 2;
208 resp.get_seat_list_rlist->seats = calloc(2, sizeof(sysarg_t));
209 PCUT_ASSERT_NOT_NULL(resp.get_seat_list_rlist->seats);
210 resp.get_seat_list_rlist->seats[0] = 42;
211 resp.get_seat_list_rlist->seats[1] = 43;
212
213 rc = dispcfg_get_seat_list(dispcfg, &list);
214 PCUT_ASSERT_TRUE(resp.get_seat_list_called);
215 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
216
217 PCUT_ASSERT_INT_EQUALS(2, list->nseats);
218 PCUT_ASSERT_INT_EQUALS(42, list->seats[0]);
219 PCUT_ASSERT_INT_EQUALS(43, list->seats[1]);
220
221 dispcfg_free_seat_list(list);
222 dispcfg_close(dispcfg);
223 rc = loc_service_unregister(sid);
224 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
225}
226
227/** dispcfg_get_seat_infp() with server returning error response works */
228PCUT_TEST(get_seat_info_failure)
229{
230 errno_t rc;
231 service_id_t sid;
232 dispcfg_t *dispcfg = NULL;
233 sysarg_t seat_id;
234 dispcfg_seat_info_t *info;
235 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);
244 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
245
246 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
247 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
248 PCUT_ASSERT_NOT_NULL(dispcfg);
249
250 resp.rc = ENOMEM;
251 resp.get_seat_info_called = false;
252 seat_id = 1;
253
254 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
255 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
256 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
257 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
258
259 dispcfg_close(dispcfg);
260 rc = loc_service_unregister(sid);
261 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
262}
263
264/** dispcfg_get_seat_info() with server returning success response works */
265PCUT_TEST(get_seat_info_success)
266{
267 errno_t rc;
268 service_id_t sid;
269 dispcfg_t *dispcfg = NULL;
270 sysarg_t seat_id;
271 dispcfg_seat_info_t *info;
272 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);
281 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
282
283 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
284 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
285 PCUT_ASSERT_NOT_NULL(dispcfg);
286
287 resp.rc = EOK;
288 resp.get_seat_info_called = false;
289 resp.get_seat_info_rinfo = calloc(1, sizeof(dispcfg_seat_info_t));
290 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo);
291 resp.get_seat_info_rinfo->name = str_dup("Hello");
292 PCUT_ASSERT_NOT_NULL(resp.get_seat_info_rinfo->name);
293 seat_id = 1;
294
295 rc = dispcfg_get_seat_info(dispcfg, seat_id, &info);
296 PCUT_ASSERT_TRUE(resp.get_seat_info_called);
297 PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_seat_info_seat_id);
298 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
299
300 PCUT_ASSERT_STR_EQUALS("Hello", info->name);
301
302 dispcfg_free_seat_info(info);
303 dispcfg_close(dispcfg);
304 rc = loc_service_unregister(sid);
305 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
306}
307
308/** dispcfg_seat_create() with server returning error response works */
309PCUT_TEST(seat_create_failure)
310{
311 errno_t rc;
312 service_id_t sid;
313 dispcfg_t *dispcfg = NULL;
314 sysarg_t seat_id;
315 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);
324 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
325
326 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328 PCUT_ASSERT_NOT_NULL(dispcfg);
329
330 seat_id = 13;
331 seat_id = 42;
332 resp.rc = ENOMEM;
333 resp.seat_create_called = false;
334
335 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
336 PCUT_ASSERT_TRUE(resp.seat_create_called);
337 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
338 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
339 free(resp.seat_create_name);
340
341 dispcfg_close(dispcfg);
342 rc = loc_service_unregister(sid);
343 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
344}
345
346/** dispcfg_seat_create() with server returning success response works */
347PCUT_TEST(seat_create_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 resp.rc = EOK;
369 resp.seat_create_called = false;
370 resp.seat_create_seat_id = 42;
371
372 rc = dispcfg_seat_create(dispcfg, "Alice", &seat_id);
373 PCUT_ASSERT_TRUE(resp.seat_create_called);
374 PCUT_ASSERT_STR_EQUALS("Alice", resp.seat_create_name);
375 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_create_seat_id);
376 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
377 free(resp.seat_create_name);
378
379 dispcfg_close(dispcfg);
380 rc = loc_service_unregister(sid);
381 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
382}
383
384/** dispcfg_seat_delete() with server returning error response works */
385PCUT_TEST(seat_delete_failure)
386{
387 errno_t rc;
388 service_id_t sid;
389 dispcfg_t *dispcfg = NULL;
390 sysarg_t seat_id;
391 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);
400 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
401
402 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
403 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
404 PCUT_ASSERT_NOT_NULL(dispcfg);
405
406 seat_id = 42;
407 resp.rc = ENOMEM;
408 resp.seat_delete_called = false;
409
410 rc = dispcfg_seat_delete(dispcfg, seat_id);
411 PCUT_ASSERT_TRUE(resp.seat_delete_called);
412 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
413 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
414
415 dispcfg_close(dispcfg);
416 rc = loc_service_unregister(sid);
417 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
418}
419
420/** dispcfg_seat_delete() with server returning success response works */
421PCUT_TEST(seat_delete_success)
422{
423 errno_t rc;
424 service_id_t sid;
425 dispcfg_t *dispcfg = NULL;
426 sysarg_t seat_id;
427 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);
436 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
437
438 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
439 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
440 PCUT_ASSERT_NOT_NULL(dispcfg);
441
442 seat_id = 42;
443 resp.rc = EOK;
444 resp.seat_delete_called = false;
445
446 rc = dispcfg_seat_delete(dispcfg, seat_id);
447 PCUT_ASSERT_TRUE(resp.seat_delete_called);
448 PCUT_ASSERT_INT_EQUALS(seat_id, resp.seat_delete_seat_id);
449 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
450
451 dispcfg_close(dispcfg);
452 rc = loc_service_unregister(sid);
453 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
454}
455
456/** dispcfg_dev_assign() with server returning error response works */
457PCUT_TEST(dev_assign_failure)
458{
459 errno_t rc;
460 service_id_t sid;
461 dispcfg_t *dispcfg = NULL;
462 sysarg_t svc_id;
463 sysarg_t seat_id;
464 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);
473 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
474
475 rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
476 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
477 PCUT_ASSERT_NOT_NULL(dispcfg);
478
479 svc_id = 12;
480 seat_id = 13;
481 resp.rc = ENOMEM;
482 resp.dev_assign_called = false;
483
484 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
485 PCUT_ASSERT_TRUE(resp.dev_assign_called);
486 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
487 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
488 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
489
490 dispcfg_close(dispcfg);
491 rc = loc_service_unregister(sid);
492 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
493}
494
495/** dispcfg_dev_assign() with server returning success response works */
496PCUT_TEST(dev_assign_success)
497{
498 errno_t rc;
499 service_id_t sid;
500 dispcfg_t *dispcfg = NULL;
501 sysarg_t svc_id;
502 sysarg_t seat_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 seat_id = 13;
520 resp.rc = EOK;
521 resp.dev_assign_called = false;
522
523 rc = dispcfg_dev_assign(dispcfg, svc_id, seat_id);
524 PCUT_ASSERT_TRUE(resp.dev_assign_called);
525 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_assign_svc_id);
526 PCUT_ASSERT_INT_EQUALS(seat_id, resp.dev_assign_seat_id);
527 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
528
529 dispcfg_close(dispcfg);
530 rc = loc_service_unregister(sid);
531 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
532}
533
534/** dispcfg_dev_unassign() with server returning error response works */
535PCUT_TEST(dev_unassign_failure)
536{
537 errno_t rc;
538 service_id_t sid;
539 dispcfg_t *dispcfg = NULL;
540 sysarg_t svc_id;
541 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);
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 = ENOMEM;
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(sid);
567 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
568}
569
570/** dispcfg_dev_unassign() with server returning success response works */
571PCUT_TEST(dev_unassign_success)
572{
573 errno_t rc;
574 service_id_t sid;
575 dispcfg_t *dispcfg = NULL;
576 sysarg_t svc_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 svc_id = 12;
593 resp.rc = EOK;
594 resp.dev_unassign_called = false;
595
596 rc = dispcfg_dev_unassign(dispcfg, svc_id);
597 PCUT_ASSERT_TRUE(resp.dev_unassign_called);
598 PCUT_ASSERT_INT_EQUALS(svc_id, resp.dev_unassign_svc_id);
599 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
600
601 dispcfg_close(dispcfg);
602 rc = loc_service_unregister(sid);
603 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
604}
605
606/** Window added event can be delivered from server to client callback function */
607PCUT_TEST(seat_added_deliver)
608{
609 errno_t rc;
610 service_id_t sid;
611 dispcfg_t *dispcfg = NULL;
612 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);
621 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
622
623 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
624 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
625 PCUT_ASSERT_NOT_NULL(dispcfg);
626 PCUT_ASSERT_NOT_NULL(resp.srv);
627
628 resp.event_cnt = 1;
629 resp.event.etype = dcev_seat_added;
630 resp.event.seat_id = 42;
631 resp.seat_added_called = false;
632 fibril_mutex_initialize(&resp.event_lock);
633 fibril_condvar_initialize(&resp.event_cv);
634 dispcfg_srv_ev_pending(resp.srv);
635
636 /* Wait for the event handler to be called. */
637 fibril_mutex_lock(&resp.event_lock);
638 while (!resp.seat_added_called) {
639 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
640 }
641 fibril_mutex_unlock(&resp.event_lock);
642
643 /* Verify that the event was delivered correctly */
644 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
645 resp.revent.etype);
646
647 dispcfg_close(dispcfg);
648
649 rc = loc_service_unregister(sid);
650 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
651}
652
653/** Window removed event can be delivered from server to client callback function */
654PCUT_TEST(seat_removed_deliver)
655{
656 errno_t rc;
657 service_id_t sid;
658 dispcfg_t *dispcfg = NULL;
659 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);
668 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
669
670 rc = dispcfg_open(test_dispcfg_svc, &test_dispcfg_cb, &resp, &dispcfg);
671 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
672 PCUT_ASSERT_NOT_NULL(dispcfg);
673 PCUT_ASSERT_NOT_NULL(resp.srv);
674
675 resp.event_cnt = 1;
676 resp.event.etype = dcev_seat_removed;
677 resp.event.seat_id = 42;
678 resp.seat_removed_called = false;
679 fibril_mutex_initialize(&resp.event_lock);
680 fibril_condvar_initialize(&resp.event_cv);
681 dispcfg_srv_ev_pending(resp.srv);
682
683 /* Wait for the event handler to be called. */
684 fibril_mutex_lock(&resp.event_lock);
685 while (!resp.seat_removed_called) {
686 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
687 }
688 fibril_mutex_unlock(&resp.event_lock);
689
690 /* Verify that the event was delivered correctly */
691 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
692 resp.revent.etype);
693
694 dispcfg_close(dispcfg);
695
696 rc = loc_service_unregister(sid);
697 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
698}
699
700/** Test seat management service connection. */
701static void test_dispcfg_conn(ipc_call_t *icall, void *arg)
702{
703 test_response_t *resp = (test_response_t *) arg;
704 dispcfg_srv_t srv;
705
706 /* Set up protocol structure */
707 dispcfg_srv_initialize(&srv);
708 srv.ops = &test_dispcfg_srv_ops;
709 srv.arg = arg;
710 resp->srv = &srv;
711
712 /* Handle connection */
713 dispcfg_conn(icall, &srv);
714
715 resp->srv = NULL;
716}
717
718static void test_seat_added(void *arg, sysarg_t seat_id)
719{
720 test_response_t *resp = (test_response_t *) arg;
721
722 resp->revent.etype = dcev_seat_added;
723
724 fibril_mutex_lock(&resp->event_lock);
725 resp->seat_added_called = true;
726 resp->seat_added_seat_id = seat_id;
727 fibril_condvar_broadcast(&resp->event_cv);
728 fibril_mutex_unlock(&resp->event_lock);
729}
730
731static void test_seat_removed(void *arg, sysarg_t seat_id)
732{
733 test_response_t *resp = (test_response_t *) arg;
734
735 resp->revent.etype = dcev_seat_removed;
736
737 fibril_mutex_lock(&resp->event_lock);
738 resp->seat_removed_called = true;
739 resp->seat_removed_seat_id = seat_id;
740 fibril_condvar_broadcast(&resp->event_cv);
741 fibril_mutex_unlock(&resp->event_lock);
742}
743
744static errno_t test_get_seat_list(void *arg, dispcfg_seat_list_t **rlist)
745{
746 test_response_t *resp = (test_response_t *) arg;
747
748 resp->get_seat_list_called = true;
749
750 if (resp->rc != EOK)
751 return resp->rc;
752
753 *rlist = resp->get_seat_list_rlist;
754 return EOK;
755}
756
757static errno_t test_get_seat_info(void *arg, sysarg_t seat_id,
758 dispcfg_seat_info_t **rinfo)
759{
760 test_response_t *resp = (test_response_t *) arg;
761
762 resp->get_seat_info_called = true;
763 resp->get_seat_info_seat_id = seat_id;
764
765 if (resp->rc != EOK)
766 return resp->rc;
767
768 *rinfo = resp->get_seat_info_rinfo;
769 return EOK;
770}
771
772static errno_t test_seat_create(void *arg, const char *name, sysarg_t *rseat_id)
773{
774 test_response_t *resp = (test_response_t *) arg;
775
776 resp->seat_create_called = true;
777 resp->seat_create_name = str_dup(name);
778 *rseat_id = resp->seat_create_seat_id;
779 return resp->rc;
780}
781
782static errno_t test_seat_delete(void *arg, sysarg_t seat_id)
783{
784 test_response_t *resp = (test_response_t *) arg;
785
786 resp->seat_delete_called = true;
787 resp->seat_delete_seat_id = seat_id;
788 return resp->rc;
789}
790
791static errno_t test_dev_assign(void *arg, sysarg_t svc_id, sysarg_t seat_id)
792{
793 test_response_t *resp = (test_response_t *) arg;
794
795 resp->dev_assign_called = true;
796 resp->dev_assign_svc_id = svc_id;
797 resp->dev_assign_seat_id = seat_id;
798 return resp->rc;
799}
800
801static errno_t test_dev_unassign(void *arg, sysarg_t svc_id)
802{
803 test_response_t *resp = (test_response_t *) arg;
804
805 resp->dev_unassign_called = true;
806 resp->dev_unassign_svc_id = svc_id;
807 return resp->rc;
808}
809
810static errno_t test_get_event(void *arg, dispcfg_ev_t *event)
811{
812 test_response_t *resp = (test_response_t *) arg;
813
814 resp->get_event_called = true;
815 if (resp->event_cnt > 0) {
816 --resp->event_cnt;
817 *event = resp->event;
818 return EOK;
819 }
820
821 return ENOENT;
822}
823
824PCUT_EXPORT(dispcfg);
Note: See TracBrowser for help on using the repository browser.