source: mainline/uspace/lib/wndmgt/test/wndmgt.c@ 68704ab

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

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