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 |
|
---|
40 | PCUT_INIT;
|
---|
41 |
|
---|
42 | PCUT_TEST_SUITE(dispcfg);
|
---|
43 |
|
---|
44 | static const char *test_dispcfg_server = "test-dispcfg";
|
---|
45 | static const char *test_dispcfg_svc = "test/dispcfg";
|
---|
46 |
|
---|
47 | /** dispcfg_open(), dispcfg_close() work for valid seat management service */
|
---|
48 | PCUT_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 */
|
---|
76 | PCUT_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 */
|
---|
112 | PCUT_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 */
|
---|
160 | PCUT_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 */
|
---|
199 | PCUT_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 */
|
---|
245 | PCUT_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 */
|
---|
285 | PCUT_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 */
|
---|
325 | PCUT_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 */
|
---|
363 | PCUT_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 */
|
---|
401 | PCUT_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 */
|
---|
442 | PCUT_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 */
|
---|
483 | PCUT_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 */
|
---|
521 | PCUT_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 */
|
---|
559 | PCUT_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 */
|
---|
598 | PCUT_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 */
|
---|
649 | PCUT_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 */
|
---|
698 | PCUT_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 |
|
---|
746 | PCUT_EXPORT(dispcfg);
|
---|