source: mainline/uspace/lib/wndmgt/test/wndmgt.c@ 3a6d44b7

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

Activate window by pushing window button on taskbar

Note that with multiple seats, one would need to know which seat pushed
the button and set the appropriate focus.
  • Property mode set to 100644
File size: 19.4 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 PCUT_ASSERT_NOT_NULL(resp.get_window_info_rinfo->caption);
284 wnd_id = 1;
285
286 rc = wndmgt_get_window_info(wndmgt, wnd_id, &info);
287 PCUT_ASSERT_TRUE(resp.get_window_info_called);
288 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.get_window_info_wnd_id);
289 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
290
291 PCUT_ASSERT_STR_EQUALS("Hello", info->caption);
292
293 wndmgt_free_window_info(info);
294 wndmgt_close(wndmgt);
295 rc = loc_service_unregister(sid);
296 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
297}
298
299/** wndmgt_activate_window() with server returning error response works */
300PCUT_TEST(activate_window_failure)
301{
302 errno_t rc;
303 service_id_t sid;
304 wndmgt_t *wndmgt = NULL;
305 sysarg_t seat_id;
306 sysarg_t wnd_id;
307 test_response_t resp;
308
309 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
310
311 // FIXME This causes this test to be non-reentrant!
312 rc = loc_server_register(test_wndmgt_server);
313 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
314
315 rc = loc_service_register(test_wndmgt_svc, &sid);
316 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
317
318 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
319 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
320 PCUT_ASSERT_NOT_NULL(wndmgt);
321
322 seat_id = 13;
323 wnd_id = 42;
324 resp.rc = ENOMEM;
325 resp.activate_window_called = false;
326
327 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
328 PCUT_ASSERT_TRUE(resp.activate_window_called);
329 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
330 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
331 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
332
333 wndmgt_close(wndmgt);
334 rc = loc_service_unregister(sid);
335 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
336}
337
338/** wndmgt_activate_window() with server returning success response works */
339PCUT_TEST(activate_window_success)
340{
341 errno_t rc;
342 service_id_t sid;
343 wndmgt_t *wndmgt = NULL;
344 sysarg_t seat_id;
345 sysarg_t wnd_id;
346 test_response_t resp;
347
348 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
349
350 // FIXME This causes this test to be non-reentrant!
351 rc = loc_server_register(test_wndmgt_server);
352 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
353
354 rc = loc_service_register(test_wndmgt_svc, &sid);
355 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
356
357 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
358 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
359 PCUT_ASSERT_NOT_NULL(wndmgt);
360
361 seat_id = 13;
362 wnd_id = 42;
363 resp.rc = EOK;
364 resp.activate_window_called = false;
365
366 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
367 PCUT_ASSERT_TRUE(resp.activate_window_called);
368 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
369 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
370 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
371
372 wndmgt_close(wndmgt);
373 rc = loc_service_unregister(sid);
374 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
375}
376
377/** wndmgt_close_window() with server returning error response works */
378PCUT_TEST(close_window_failure)
379{
380 errno_t rc;
381 service_id_t sid;
382 wndmgt_t *wndmgt = NULL;
383 sysarg_t wnd_id;
384 test_response_t resp;
385
386 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
387
388 // FIXME This causes this test to be non-reentrant!
389 rc = loc_server_register(test_wndmgt_server);
390 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
391
392 rc = loc_service_register(test_wndmgt_svc, &sid);
393 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
394
395 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
396 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
397 PCUT_ASSERT_NOT_NULL(wndmgt);
398
399 wnd_id = 42;
400 resp.rc = ENOMEM;
401 resp.close_window_called = false;
402
403 rc = wndmgt_close_window(wndmgt, wnd_id);
404 PCUT_ASSERT_TRUE(resp.close_window_called);
405 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
406 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
407
408 wndmgt_close(wndmgt);
409 rc = loc_service_unregister(sid);
410 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
411}
412
413/** wndmgt_close_window() with server returning success response works */
414PCUT_TEST(close_window_success)
415{
416 errno_t rc;
417 service_id_t sid;
418 wndmgt_t *wndmgt = NULL;
419 sysarg_t wnd_id;
420 test_response_t resp;
421
422 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
423
424 // FIXME This causes this test to be non-reentrant!
425 rc = loc_server_register(test_wndmgt_server);
426 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
427
428 rc = loc_service_register(test_wndmgt_svc, &sid);
429 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
430
431 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
432 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
433 PCUT_ASSERT_NOT_NULL(wndmgt);
434
435 wnd_id = 42;
436 resp.rc = EOK;
437 resp.close_window_called = false;
438
439 rc = wndmgt_close_window(wndmgt, wnd_id);
440 PCUT_ASSERT_TRUE(resp.close_window_called);
441 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
442 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
443
444 wndmgt_close(wndmgt);
445 rc = loc_service_unregister(sid);
446 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
447}
448
449/** Window added event can be delivered from server to client callback function */
450PCUT_TEST(window_added_deliver)
451{
452 errno_t rc;
453 service_id_t sid;
454 wndmgt_t *wndmgt = NULL;
455 test_response_t resp;
456
457 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
458
459 // FIXME This causes this test to be non-reentrant!
460 rc = loc_server_register(test_wndmgt_server);
461 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
462
463 rc = loc_service_register(test_wndmgt_svc, &sid);
464 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
465
466 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
467 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
468 PCUT_ASSERT_NOT_NULL(wndmgt);
469 PCUT_ASSERT_NOT_NULL(resp.srv);
470
471 resp.event_cnt = 1;
472 resp.event.etype = wmev_window_added;
473 resp.event.wnd_id = 42;
474 resp.window_added_called = false;
475 fibril_mutex_initialize(&resp.event_lock);
476 fibril_condvar_initialize(&resp.event_cv);
477 wndmgt_srv_ev_pending(resp.srv);
478
479 /* Wait for the event handler to be called. */
480 fibril_mutex_lock(&resp.event_lock);
481 while (!resp.window_added_called) {
482 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
483 }
484 fibril_mutex_unlock(&resp.event_lock);
485
486 /* Verify that the event was delivered correctly */
487 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
488 resp.revent.etype);
489
490 wndmgt_close(wndmgt);
491
492 rc = loc_service_unregister(sid);
493 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
494}
495
496/** Window removed event can be delivered from server to client callback function */
497PCUT_TEST(window_removed_deliver)
498{
499 errno_t rc;
500 service_id_t sid;
501 wndmgt_t *wndmgt = NULL;
502 test_response_t resp;
503
504 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
505
506 // FIXME This causes this test to be non-reentrant!
507 rc = loc_server_register(test_wndmgt_server);
508 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
509
510 rc = loc_service_register(test_wndmgt_svc, &sid);
511 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
512
513 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
515 PCUT_ASSERT_NOT_NULL(wndmgt);
516 PCUT_ASSERT_NOT_NULL(resp.srv);
517
518 resp.event_cnt = 1;
519 resp.event.etype = wmev_window_removed;
520 resp.event.wnd_id = 42;
521 resp.window_removed_called = false;
522 fibril_mutex_initialize(&resp.event_lock);
523 fibril_condvar_initialize(&resp.event_cv);
524 wndmgt_srv_ev_pending(resp.srv);
525
526 /* Wait for the event handler to be called. */
527 fibril_mutex_lock(&resp.event_lock);
528 while (!resp.window_removed_called) {
529 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
530 }
531 fibril_mutex_unlock(&resp.event_lock);
532
533 /* Verify that the event was delivered correctly */
534 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
535 resp.revent.etype);
536
537 wndmgt_close(wndmgt);
538
539 rc = loc_service_unregister(sid);
540 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
541}
542
543/** Window changed event can be delivered from server to client callback function */
544PCUT_TEST(window_changed_deliver)
545{
546 errno_t rc;
547 service_id_t sid;
548 wndmgt_t *wndmgt = NULL;
549 test_response_t resp;
550
551 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
552
553 // FIXME This causes this test to be non-reentrant!
554 rc = loc_server_register(test_wndmgt_server);
555 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
556
557 rc = loc_service_register(test_wndmgt_svc, &sid);
558 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
559
560 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
561 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
562 PCUT_ASSERT_NOT_NULL(wndmgt);
563 PCUT_ASSERT_NOT_NULL(resp.srv);
564
565 resp.event_cnt = 1;
566 resp.event.etype = wmev_window_changed;
567 resp.event.wnd_id = 42;
568 resp.window_changed_called = false;
569 fibril_mutex_initialize(&resp.event_lock);
570 fibril_condvar_initialize(&resp.event_cv);
571 wndmgt_srv_ev_pending(resp.srv);
572
573 /* Wait for the event handler to be called. */
574 fibril_mutex_lock(&resp.event_lock);
575 while (!resp.window_changed_called) {
576 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
577 }
578 fibril_mutex_unlock(&resp.event_lock);
579
580 /* Verify that the event was delivered correctly */
581 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
582 resp.revent.etype);
583
584 wndmgt_close(wndmgt);
585
586 rc = loc_service_unregister(sid);
587 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
588}
589
590/** Test window management service connection. */
591static void test_wndmgt_conn(ipc_call_t *icall, void *arg)
592{
593 test_response_t *resp = (test_response_t *) arg;
594 wndmgt_srv_t srv;
595
596 /* Set up protocol structure */
597 wndmgt_srv_initialize(&srv);
598 srv.ops = &test_wndmgt_srv_ops;
599 srv.arg = arg;
600 resp->srv = &srv;
601
602 /* Handle connection */
603 wndmgt_conn(icall, &srv);
604
605 resp->srv = NULL;
606}
607
608static void test_window_added(void *arg, sysarg_t wnd_id)
609{
610 test_response_t *resp = (test_response_t *) arg;
611
612 resp->revent.etype = wmev_window_added;
613
614 fibril_mutex_lock(&resp->event_lock);
615 resp->window_added_called = true;
616 resp->window_added_wnd_id = wnd_id;
617 fibril_condvar_broadcast(&resp->event_cv);
618 fibril_mutex_unlock(&resp->event_lock);
619}
620
621static void test_window_removed(void *arg, sysarg_t wnd_id)
622{
623 test_response_t *resp = (test_response_t *) arg;
624
625 resp->revent.etype = wmev_window_removed;
626
627 fibril_mutex_lock(&resp->event_lock);
628 resp->window_removed_called = true;
629 resp->window_removed_wnd_id = wnd_id;
630 fibril_condvar_broadcast(&resp->event_cv);
631 fibril_mutex_unlock(&resp->event_lock);
632}
633
634static void test_window_changed(void *arg, sysarg_t wnd_id)
635{
636 test_response_t *resp = (test_response_t *) arg;
637
638 resp->revent.etype = wmev_window_changed;
639
640 fibril_mutex_lock(&resp->event_lock);
641 resp->window_changed_called = true;
642 resp->window_changed_wnd_id = wnd_id;
643 fibril_condvar_broadcast(&resp->event_cv);
644 fibril_mutex_unlock(&resp->event_lock);
645}
646
647static errno_t test_get_window_list(void *arg, wndmgt_window_list_t **rlist)
648{
649 test_response_t *resp = (test_response_t *) arg;
650
651 resp->get_window_list_called = true;
652
653 if (resp->rc != EOK)
654 return resp->rc;
655
656 *rlist = resp->get_window_list_rlist;
657 return EOK;
658}
659
660static errno_t test_get_window_info(void *arg, sysarg_t wnd_id,
661 wndmgt_window_info_t **rinfo)
662{
663 test_response_t *resp = (test_response_t *) arg;
664
665 resp->get_window_info_called = true;
666 resp->get_window_info_wnd_id = wnd_id;
667
668 if (resp->rc != EOK)
669 return resp->rc;
670
671 *rinfo = resp->get_window_info_rinfo;
672 return EOK;
673}
674
675static errno_t test_activate_window(void *arg, sysarg_t seat_id,
676 sysarg_t wnd_id)
677{
678 test_response_t *resp = (test_response_t *) arg;
679
680 resp->activate_window_called = true;
681 resp->activate_window_seat_id = seat_id;
682 resp->activate_window_wnd_id = wnd_id;
683 return resp->rc;
684}
685
686static errno_t test_close_window(void *arg, sysarg_t wnd_id)
687{
688 test_response_t *resp = (test_response_t *) arg;
689
690 resp->close_window_called = true;
691 resp->close_window_wnd_id = wnd_id;
692 return resp->rc;
693}
694
695static errno_t test_get_event(void *arg, wndmgt_ev_t *event)
696{
697 test_response_t *resp = (test_response_t *) arg;
698
699 resp->get_event_called = true;
700 if (resp->event_cnt > 0) {
701 --resp->event_cnt;
702 *event = resp->event;
703 return EOK;
704 }
705
706 return ENOENT;
707}
708
709PCUT_EXPORT(wndmgt);
Note: See TracBrowser for help on using the repository browser.