source: mainline/uspace/lib/wndmgt/test/wndmgt.c@ ca48672

Last change on this file since ca48672 was ca48672, checked in by Jiri Svoboda <jiri@…>, 8 days ago

loc_service_register() needs to take a port ID argument.
  • Property mode set to 100644
File size: 20.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 <wndmgt.h>
32#include <wndmgt_srv.h>
33#include <fibril_synch.h>
34#include <loc.h>
35#include <pcut/pcut.h>
36#include <str.h>
37#include "../private/wndmgt.h"
38
39PCUT_INIT;
40
41PCUT_TEST_SUITE(wndmgt);
42
43static const char *test_wndmgt_server = "test-wndmgt";
44static const char *test_wndmgt_svc = "test/wndmgt";
45
46static void test_wndmgt_conn(ipc_call_t *, void *);
47
48static errno_t test_get_window_list(void *, wndmgt_window_list_t **);
49static errno_t test_get_window_info(void *, sysarg_t, wndmgt_window_info_t **);
50static errno_t test_activate_window(void *, sysarg_t, sysarg_t);
51static errno_t test_close_window(void *, sysarg_t);
52static errno_t test_get_event(void *, wndmgt_ev_t *);
53
54static void test_window_added(void *, sysarg_t);
55static void test_window_removed(void *, sysarg_t);
56static void test_window_changed(void *, sysarg_t);
57
58static wndmgt_ops_t test_wndmgt_srv_ops = {
59 .get_window_list = test_get_window_list,
60 .get_window_info = test_get_window_info,
61 .activate_window = test_activate_window,
62 .close_window = test_close_window,
63 .get_event = test_get_event
64};
65
66static wndmgt_cb_t test_wndmgt_cb = {
67 .window_added = test_window_added,
68 .window_removed = test_window_removed,
69 .window_changed = test_window_changed
70};
71
72/** Describes to the server how to respond to our request and pass tracking
73 * data back to the client.
74 */
75typedef struct {
76 errno_t rc;
77 sysarg_t wnd_id;
78 wndmgt_ev_t event;
79 wndmgt_ev_t revent;
80 int event_cnt;
81
82 bool get_window_list_called;
83 wndmgt_window_list_t *get_window_list_rlist;
84
85 bool get_window_info_called;
86 sysarg_t get_window_info_wnd_id;
87 wndmgt_window_info_t *get_window_info_rinfo;
88
89 bool activate_window_called;
90 sysarg_t activate_window_seat_id;
91 sysarg_t activate_window_wnd_id;
92
93 bool close_window_called;
94 sysarg_t close_window_wnd_id;
95
96 bool get_event_called;
97
98 bool window_added_called;
99 sysarg_t window_added_wnd_id;
100
101 bool window_removed_called;
102 sysarg_t window_removed_wnd_id;
103
104 bool window_changed_called;
105 sysarg_t window_changed_wnd_id;
106
107 fibril_condvar_t event_cv;
108 fibril_mutex_t event_lock;
109 wndmgt_srv_t *srv;
110} test_response_t;
111
112/** wndmgt_open(), wndmgt_close() work for valid window management service */
113PCUT_TEST(open_close)
114{
115 errno_t rc;
116 service_id_t sid;
117 wndmgt_t *wndmgt = NULL;
118 test_response_t resp;
119 loc_srv_t *srv;
120
121 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
122
123 // FIXME This causes this test to be non-reentrant!
124 rc = loc_server_register(test_wndmgt_server, &srv);
125 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
126
127 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
128 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
129
130 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
131 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
132 PCUT_ASSERT_NOT_NULL(wndmgt);
133
134 wndmgt_close(wndmgt);
135 rc = loc_service_unregister(srv, sid);
136 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
137 loc_server_unregister(srv);
138}
139
140/** wndmgt_get_window_list() with server returning error response works */
141PCUT_TEST(get_window_list_failure)
142{
143 errno_t rc;
144 service_id_t sid;
145 wndmgt_t *wndmgt = NULL;
146 wndmgt_window_list_t *list;
147 test_response_t resp;
148 loc_srv_t *srv;
149
150 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
151
152 // FIXME This causes this test to be non-reentrant!
153 rc = loc_server_register(test_wndmgt_server, &srv);
154 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
155
156 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
157 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
158
159 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
160 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
161 PCUT_ASSERT_NOT_NULL(wndmgt);
162
163 resp.rc = ENOMEM;
164 resp.get_window_list_called = false;
165
166 rc = wndmgt_get_window_list(wndmgt, &list);
167 PCUT_ASSERT_TRUE(resp.get_window_list_called);
168 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
169
170 wndmgt_close(wndmgt);
171 rc = loc_service_unregister(srv, sid);
172 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
173 loc_server_unregister(srv);
174}
175
176/** wndmgt_get_window_list() with server returning success response works */
177PCUT_TEST(get_window_list_success)
178{
179 errno_t rc;
180 service_id_t sid;
181 wndmgt_t *wndmgt = NULL;
182 wndmgt_window_list_t *list;
183 test_response_t resp;
184 loc_srv_t *srv;
185
186 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
187
188 // FIXME This causes this test to be non-reentrant!
189 rc = loc_server_register(test_wndmgt_server, &srv);
190 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
191
192 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
193 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
194
195 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
196 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
197 PCUT_ASSERT_NOT_NULL(wndmgt);
198
199 resp.rc = EOK;
200 resp.get_window_list_called = false;
201 resp.get_window_list_rlist = calloc(1, sizeof(wndmgt_window_list_t));
202 PCUT_ASSERT_NOT_NULL(resp.get_window_list_rlist);
203 resp.get_window_list_rlist->nwindows = 2;
204 resp.get_window_list_rlist->windows = calloc(2, sizeof(sysarg_t));
205 PCUT_ASSERT_NOT_NULL(resp.get_window_list_rlist->windows);
206 resp.get_window_list_rlist->windows[0] = 42;
207 resp.get_window_list_rlist->windows[1] = 43;
208
209 rc = wndmgt_get_window_list(wndmgt, &list);
210 PCUT_ASSERT_TRUE(resp.get_window_list_called);
211 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
212
213 PCUT_ASSERT_INT_EQUALS(2, list->nwindows);
214 PCUT_ASSERT_INT_EQUALS(42, list->windows[0]);
215 PCUT_ASSERT_INT_EQUALS(43, list->windows[1]);
216
217 wndmgt_free_window_list(list);
218 wndmgt_close(wndmgt);
219 rc = loc_service_unregister(srv, sid);
220 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
221 loc_server_unregister(srv);
222}
223
224/** wndmgt_get_window_infp() with server returning error response works */
225PCUT_TEST(get_window_info_failure)
226{
227 errno_t rc;
228 service_id_t sid;
229 wndmgt_t *wndmgt = NULL;
230 sysarg_t wnd_id;
231 wndmgt_window_info_t *info;
232 test_response_t resp;
233 loc_srv_t *srv;
234
235 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
236
237 // FIXME This causes this test to be non-reentrant!
238 rc = loc_server_register(test_wndmgt_server, &srv);
239 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
240
241 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
242 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
243
244 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
246 PCUT_ASSERT_NOT_NULL(wndmgt);
247
248 resp.rc = ENOMEM;
249 resp.get_window_info_called = false;
250 wnd_id = 1;
251
252 rc = wndmgt_get_window_info(wndmgt, wnd_id, &info);
253 PCUT_ASSERT_TRUE(resp.get_window_info_called);
254 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.get_window_info_wnd_id);
255 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
256
257 wndmgt_close(wndmgt);
258 rc = loc_service_unregister(srv, sid);
259 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
260 loc_server_unregister(srv);
261}
262
263/** wndmgt_get_window_info() with server returning success response works */
264PCUT_TEST(get_window_info_success)
265{
266 errno_t rc;
267 service_id_t sid;
268 wndmgt_t *wndmgt = NULL;
269 sysarg_t wnd_id;
270 wndmgt_window_info_t *info;
271 test_response_t resp;
272 loc_srv_t *srv;
273
274 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
275
276 // FIXME This causes this test to be non-reentrant!
277 rc = loc_server_register(test_wndmgt_server, &srv);
278 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
279
280 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
281 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
282
283 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
284 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
285 PCUT_ASSERT_NOT_NULL(wndmgt);
286
287 resp.rc = EOK;
288 resp.get_window_info_called = false;
289 resp.get_window_info_rinfo = calloc(1, sizeof(wndmgt_window_info_t));
290 PCUT_ASSERT_NOT_NULL(resp.get_window_info_rinfo);
291 resp.get_window_info_rinfo->caption = str_dup("Hello");
292 resp.get_window_info_rinfo->flags = 42;
293 resp.get_window_info_rinfo->nfocus = 123;
294 PCUT_ASSERT_NOT_NULL(resp.get_window_info_rinfo->caption);
295 wnd_id = 1;
296
297 rc = wndmgt_get_window_info(wndmgt, wnd_id, &info);
298 PCUT_ASSERT_TRUE(resp.get_window_info_called);
299 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.get_window_info_wnd_id);
300 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
301
302 PCUT_ASSERT_STR_EQUALS("Hello", info->caption);
303 PCUT_ASSERT_INT_EQUALS(42, info->flags);
304 PCUT_ASSERT_INT_EQUALS(123, info->nfocus);
305
306 wndmgt_free_window_info(info);
307 wndmgt_close(wndmgt);
308 rc = loc_service_unregister(srv, sid);
309 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
310 loc_server_unregister(srv);
311}
312
313/** wndmgt_activate_window() with server returning error response works */
314PCUT_TEST(activate_window_failure)
315{
316 errno_t rc;
317 service_id_t sid;
318 wndmgt_t *wndmgt = NULL;
319 sysarg_t seat_id;
320 sysarg_t wnd_id;
321 test_response_t resp;
322 loc_srv_t *srv;
323
324 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
325
326 // FIXME This causes this test to be non-reentrant!
327 rc = loc_server_register(test_wndmgt_server, &srv);
328 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
329
330 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
331 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
332
333 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
334 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
335 PCUT_ASSERT_NOT_NULL(wndmgt);
336
337 seat_id = 13;
338 wnd_id = 42;
339 resp.rc = ENOMEM;
340 resp.activate_window_called = false;
341
342 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
343 PCUT_ASSERT_TRUE(resp.activate_window_called);
344 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
345 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
346 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
347
348 wndmgt_close(wndmgt);
349 rc = loc_service_unregister(srv, sid);
350 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
351 loc_server_unregister(srv);
352}
353
354/** wndmgt_activate_window() with server returning success response works */
355PCUT_TEST(activate_window_success)
356{
357 errno_t rc;
358 service_id_t sid;
359 wndmgt_t *wndmgt = NULL;
360 sysarg_t seat_id;
361 sysarg_t wnd_id;
362 test_response_t resp;
363 loc_srv_t *srv;
364
365 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
366
367 // FIXME This causes this test to be non-reentrant!
368 rc = loc_server_register(test_wndmgt_server, &srv);
369 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
370
371 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
372 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
373
374 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
375 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
376 PCUT_ASSERT_NOT_NULL(wndmgt);
377
378 seat_id = 13;
379 wnd_id = 42;
380 resp.rc = EOK;
381 resp.activate_window_called = false;
382
383 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
384 PCUT_ASSERT_TRUE(resp.activate_window_called);
385 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
386 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
387 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
388
389 wndmgt_close(wndmgt);
390 rc = loc_service_unregister(srv, sid);
391 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
392 loc_server_unregister(srv);
393}
394
395/** wndmgt_close_window() with server returning error response works */
396PCUT_TEST(close_window_failure)
397{
398 errno_t rc;
399 service_id_t sid;
400 wndmgt_t *wndmgt = NULL;
401 sysarg_t wnd_id;
402 test_response_t resp;
403 loc_srv_t *srv;
404
405 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
406
407 // FIXME This causes this test to be non-reentrant!
408 rc = loc_server_register(test_wndmgt_server, &srv);
409 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
410
411 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
412 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
413
414 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
415 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
416 PCUT_ASSERT_NOT_NULL(wndmgt);
417
418 wnd_id = 42;
419 resp.rc = ENOMEM;
420 resp.close_window_called = false;
421
422 rc = wndmgt_close_window(wndmgt, wnd_id);
423 PCUT_ASSERT_TRUE(resp.close_window_called);
424 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
425 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
426
427 wndmgt_close(wndmgt);
428 rc = loc_service_unregister(srv, sid);
429 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
430 loc_server_unregister(srv);
431}
432
433/** wndmgt_close_window() with server returning success response works */
434PCUT_TEST(close_window_success)
435{
436 errno_t rc;
437 service_id_t sid;
438 wndmgt_t *wndmgt = NULL;
439 sysarg_t wnd_id;
440 test_response_t resp;
441 loc_srv_t *srv;
442
443 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
444
445 // FIXME This causes this test to be non-reentrant!
446 rc = loc_server_register(test_wndmgt_server, &srv);
447 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
448
449 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
450 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
451
452 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
453 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
454 PCUT_ASSERT_NOT_NULL(wndmgt);
455
456 wnd_id = 42;
457 resp.rc = EOK;
458 resp.close_window_called = false;
459
460 rc = wndmgt_close_window(wndmgt, wnd_id);
461 PCUT_ASSERT_TRUE(resp.close_window_called);
462 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
463 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
464
465 wndmgt_close(wndmgt);
466 rc = loc_service_unregister(srv, sid);
467 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
468 loc_server_unregister(srv);
469}
470
471/** Window added event can be delivered from server to client callback function */
472PCUT_TEST(window_added_deliver)
473{
474 errno_t rc;
475 service_id_t sid;
476 wndmgt_t *wndmgt = NULL;
477 test_response_t resp;
478 loc_srv_t *srv;
479
480 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
481
482 // FIXME This causes this test to be non-reentrant!
483 rc = loc_server_register(test_wndmgt_server, &srv);
484 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
485
486 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
487 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
488
489 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
490 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
491 PCUT_ASSERT_NOT_NULL(wndmgt);
492 PCUT_ASSERT_NOT_NULL(resp.srv);
493
494 resp.event_cnt = 1;
495 resp.event.etype = wmev_window_added;
496 resp.event.wnd_id = 42;
497 resp.window_added_called = false;
498 fibril_mutex_initialize(&resp.event_lock);
499 fibril_condvar_initialize(&resp.event_cv);
500 wndmgt_srv_ev_pending(resp.srv);
501
502 /* Wait for the event handler to be called. */
503 fibril_mutex_lock(&resp.event_lock);
504 while (!resp.window_added_called) {
505 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
506 }
507 fibril_mutex_unlock(&resp.event_lock);
508
509 /* Verify that the event was delivered correctly */
510 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
511 resp.revent.etype);
512
513 wndmgt_close(wndmgt);
514
515 rc = loc_service_unregister(srv, sid);
516 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
517 loc_server_unregister(srv);
518}
519
520/** Window removed event can be delivered from server to client callback function */
521PCUT_TEST(window_removed_deliver)
522{
523 errno_t rc;
524 service_id_t sid;
525 wndmgt_t *wndmgt = NULL;
526 test_response_t resp;
527 loc_srv_t *srv;
528
529 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
530
531 // FIXME This causes this test to be non-reentrant!
532 rc = loc_server_register(test_wndmgt_server, &srv);
533 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
534
535 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
536 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
537
538 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
539 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
540 PCUT_ASSERT_NOT_NULL(wndmgt);
541 PCUT_ASSERT_NOT_NULL(resp.srv);
542
543 resp.event_cnt = 1;
544 resp.event.etype = wmev_window_removed;
545 resp.event.wnd_id = 42;
546 resp.window_removed_called = false;
547 fibril_mutex_initialize(&resp.event_lock);
548 fibril_condvar_initialize(&resp.event_cv);
549 wndmgt_srv_ev_pending(resp.srv);
550
551 /* Wait for the event handler to be called. */
552 fibril_mutex_lock(&resp.event_lock);
553 while (!resp.window_removed_called) {
554 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
555 }
556 fibril_mutex_unlock(&resp.event_lock);
557
558 /* Verify that the event was delivered correctly */
559 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
560 resp.revent.etype);
561
562 wndmgt_close(wndmgt);
563
564 rc = loc_service_unregister(srv, sid);
565 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
566 loc_server_unregister(srv);
567}
568
569/** Window changed event can be delivered from server to client callback function */
570PCUT_TEST(window_changed_deliver)
571{
572 errno_t rc;
573 service_id_t sid;
574 wndmgt_t *wndmgt = NULL;
575 test_response_t resp;
576 loc_srv_t *srv;
577
578 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
579
580 // FIXME This causes this test to be non-reentrant!
581 rc = loc_server_register(test_wndmgt_server, &srv);
582 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
583
584 rc = loc_service_register(srv, test_wndmgt_svc, fallback_port_id, &sid);
585 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
586
587 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
588 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
589 PCUT_ASSERT_NOT_NULL(wndmgt);
590 PCUT_ASSERT_NOT_NULL(resp.srv);
591
592 resp.event_cnt = 1;
593 resp.event.etype = wmev_window_changed;
594 resp.event.wnd_id = 42;
595 resp.window_changed_called = false;
596 fibril_mutex_initialize(&resp.event_lock);
597 fibril_condvar_initialize(&resp.event_cv);
598 wndmgt_srv_ev_pending(resp.srv);
599
600 /* Wait for the event handler to be called. */
601 fibril_mutex_lock(&resp.event_lock);
602 while (!resp.window_changed_called) {
603 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
604 }
605 fibril_mutex_unlock(&resp.event_lock);
606
607 /* Verify that the event was delivered correctly */
608 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
609 resp.revent.etype);
610
611 wndmgt_close(wndmgt);
612
613 rc = loc_service_unregister(srv, sid);
614 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
615 loc_server_unregister(srv);
616}
617
618/** Test window management service connection. */
619static void test_wndmgt_conn(ipc_call_t *icall, void *arg)
620{
621 test_response_t *resp = (test_response_t *) arg;
622 wndmgt_srv_t srv;
623
624 /* Set up protocol structure */
625 wndmgt_srv_initialize(&srv);
626 srv.ops = &test_wndmgt_srv_ops;
627 srv.arg = arg;
628 resp->srv = &srv;
629
630 /* Handle connection */
631 wndmgt_conn(icall, &srv);
632
633 resp->srv = NULL;
634}
635
636static void test_window_added(void *arg, sysarg_t wnd_id)
637{
638 test_response_t *resp = (test_response_t *) arg;
639
640 resp->revent.etype = wmev_window_added;
641
642 fibril_mutex_lock(&resp->event_lock);
643 resp->window_added_called = true;
644 resp->window_added_wnd_id = wnd_id;
645 fibril_condvar_broadcast(&resp->event_cv);
646 fibril_mutex_unlock(&resp->event_lock);
647}
648
649static void test_window_removed(void *arg, sysarg_t wnd_id)
650{
651 test_response_t *resp = (test_response_t *) arg;
652
653 resp->revent.etype = wmev_window_removed;
654
655 fibril_mutex_lock(&resp->event_lock);
656 resp->window_removed_called = true;
657 resp->window_removed_wnd_id = wnd_id;
658 fibril_condvar_broadcast(&resp->event_cv);
659 fibril_mutex_unlock(&resp->event_lock);
660}
661
662static void test_window_changed(void *arg, sysarg_t wnd_id)
663{
664 test_response_t *resp = (test_response_t *) arg;
665
666 resp->revent.etype = wmev_window_changed;
667
668 fibril_mutex_lock(&resp->event_lock);
669 resp->window_changed_called = true;
670 resp->window_changed_wnd_id = wnd_id;
671 fibril_condvar_broadcast(&resp->event_cv);
672 fibril_mutex_unlock(&resp->event_lock);
673}
674
675static errno_t test_get_window_list(void *arg, wndmgt_window_list_t **rlist)
676{
677 test_response_t *resp = (test_response_t *) arg;
678
679 resp->get_window_list_called = true;
680
681 if (resp->rc != EOK)
682 return resp->rc;
683
684 *rlist = resp->get_window_list_rlist;
685 return EOK;
686}
687
688static errno_t test_get_window_info(void *arg, sysarg_t wnd_id,
689 wndmgt_window_info_t **rinfo)
690{
691 test_response_t *resp = (test_response_t *) arg;
692
693 resp->get_window_info_called = true;
694 resp->get_window_info_wnd_id = wnd_id;
695
696 if (resp->rc != EOK)
697 return resp->rc;
698
699 *rinfo = resp->get_window_info_rinfo;
700 return EOK;
701}
702
703static errno_t test_activate_window(void *arg, sysarg_t seat_id,
704 sysarg_t wnd_id)
705{
706 test_response_t *resp = (test_response_t *) arg;
707
708 resp->activate_window_called = true;
709 resp->activate_window_seat_id = seat_id;
710 resp->activate_window_wnd_id = wnd_id;
711 return resp->rc;
712}
713
714static errno_t test_close_window(void *arg, sysarg_t wnd_id)
715{
716 test_response_t *resp = (test_response_t *) arg;
717
718 resp->close_window_called = true;
719 resp->close_window_wnd_id = wnd_id;
720 return resp->rc;
721}
722
723static errno_t test_get_event(void *arg, wndmgt_ev_t *event)
724{
725 test_response_t *resp = (test_response_t *) arg;
726
727 resp->get_event_called = true;
728 if (resp->event_cnt > 0) {
729 --resp->event_cnt;
730 *event = resp->event;
731 return EOK;
732 }
733
734 return ENOENT;
735}
736
737PCUT_EXPORT(wndmgt);
Note: See TracBrowser for help on using the repository browser.