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

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

Highlight active window in task bar
  • Property mode set to 100644
File size: 19.6 KB
Line 
1/*
2 * Copyright (c) 2023 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <async.h>
30#include <errno.h>
31#include <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 resp.get_window_info_rinfo->nfocus = 123;
285 PCUT_ASSERT_NOT_NULL(resp.get_window_info_rinfo->caption);
286 wnd_id = 1;
287
288 rc = wndmgt_get_window_info(wndmgt, wnd_id, &info);
289 PCUT_ASSERT_TRUE(resp.get_window_info_called);
290 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.get_window_info_wnd_id);
291 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
292
293 PCUT_ASSERT_STR_EQUALS("Hello", info->caption);
294 PCUT_ASSERT_INT_EQUALS(42, info->flags);
295 PCUT_ASSERT_INT_EQUALS(123, info->nfocus);
296
297 wndmgt_free_window_info(info);
298 wndmgt_close(wndmgt);
299 rc = loc_service_unregister(sid);
300 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
301}
302
303/** wndmgt_activate_window() with server returning error response works */
304PCUT_TEST(activate_window_failure)
305{
306 errno_t rc;
307 service_id_t sid;
308 wndmgt_t *wndmgt = NULL;
309 sysarg_t seat_id;
310 sysarg_t wnd_id;
311 test_response_t resp;
312
313 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
314
315 // FIXME This causes this test to be non-reentrant!
316 rc = loc_server_register(test_wndmgt_server);
317 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
318
319 rc = loc_service_register(test_wndmgt_svc, &sid);
320 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
321
322 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
323 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
324 PCUT_ASSERT_NOT_NULL(wndmgt);
325
326 seat_id = 13;
327 wnd_id = 42;
328 resp.rc = ENOMEM;
329 resp.activate_window_called = false;
330
331 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
332 PCUT_ASSERT_TRUE(resp.activate_window_called);
333 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
334 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
335 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
336
337 wndmgt_close(wndmgt);
338 rc = loc_service_unregister(sid);
339 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
340}
341
342/** wndmgt_activate_window() with server returning success response works */
343PCUT_TEST(activate_window_success)
344{
345 errno_t rc;
346 service_id_t sid;
347 wndmgt_t *wndmgt = NULL;
348 sysarg_t seat_id;
349 sysarg_t wnd_id;
350 test_response_t resp;
351
352 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
353
354 // FIXME This causes this test to be non-reentrant!
355 rc = loc_server_register(test_wndmgt_server);
356 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
357
358 rc = loc_service_register(test_wndmgt_svc, &sid);
359 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
360
361 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
362 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
363 PCUT_ASSERT_NOT_NULL(wndmgt);
364
365 seat_id = 13;
366 wnd_id = 42;
367 resp.rc = EOK;
368 resp.activate_window_called = false;
369
370 rc = wndmgt_activate_window(wndmgt, seat_id, wnd_id);
371 PCUT_ASSERT_TRUE(resp.activate_window_called);
372 PCUT_ASSERT_INT_EQUALS(seat_id, resp.activate_window_seat_id);
373 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.activate_window_wnd_id);
374 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
375
376 wndmgt_close(wndmgt);
377 rc = loc_service_unregister(sid);
378 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
379}
380
381/** wndmgt_close_window() with server returning error response works */
382PCUT_TEST(close_window_failure)
383{
384 errno_t rc;
385 service_id_t sid;
386 wndmgt_t *wndmgt = NULL;
387 sysarg_t wnd_id;
388 test_response_t resp;
389
390 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
391
392 // FIXME This causes this test to be non-reentrant!
393 rc = loc_server_register(test_wndmgt_server);
394 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
395
396 rc = loc_service_register(test_wndmgt_svc, &sid);
397 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
398
399 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
400 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
401 PCUT_ASSERT_NOT_NULL(wndmgt);
402
403 wnd_id = 42;
404 resp.rc = ENOMEM;
405 resp.close_window_called = false;
406
407 rc = wndmgt_close_window(wndmgt, wnd_id);
408 PCUT_ASSERT_TRUE(resp.close_window_called);
409 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
410 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
411
412 wndmgt_close(wndmgt);
413 rc = loc_service_unregister(sid);
414 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
415}
416
417/** wndmgt_close_window() with server returning success response works */
418PCUT_TEST(close_window_success)
419{
420 errno_t rc;
421 service_id_t sid;
422 wndmgt_t *wndmgt = NULL;
423 sysarg_t wnd_id;
424 test_response_t resp;
425
426 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
427
428 // FIXME This causes this test to be non-reentrant!
429 rc = loc_server_register(test_wndmgt_server);
430 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
431
432 rc = loc_service_register(test_wndmgt_svc, &sid);
433 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
434
435 rc = wndmgt_open(test_wndmgt_svc, NULL, NULL, &wndmgt);
436 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
437 PCUT_ASSERT_NOT_NULL(wndmgt);
438
439 wnd_id = 42;
440 resp.rc = EOK;
441 resp.close_window_called = false;
442
443 rc = wndmgt_close_window(wndmgt, wnd_id);
444 PCUT_ASSERT_TRUE(resp.close_window_called);
445 PCUT_ASSERT_INT_EQUALS(wnd_id, resp.close_window_wnd_id);
446 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
447
448 wndmgt_close(wndmgt);
449 rc = loc_service_unregister(sid);
450 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
451}
452
453/** Window added event can be delivered from server to client callback function */
454PCUT_TEST(window_added_deliver)
455{
456 errno_t rc;
457 service_id_t sid;
458 wndmgt_t *wndmgt = NULL;
459 test_response_t resp;
460
461 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
462
463 // FIXME This causes this test to be non-reentrant!
464 rc = loc_server_register(test_wndmgt_server);
465 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
466
467 rc = loc_service_register(test_wndmgt_svc, &sid);
468 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
469
470 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
471 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
472 PCUT_ASSERT_NOT_NULL(wndmgt);
473 PCUT_ASSERT_NOT_NULL(resp.srv);
474
475 resp.event_cnt = 1;
476 resp.event.etype = wmev_window_added;
477 resp.event.wnd_id = 42;
478 resp.window_added_called = false;
479 fibril_mutex_initialize(&resp.event_lock);
480 fibril_condvar_initialize(&resp.event_cv);
481 wndmgt_srv_ev_pending(resp.srv);
482
483 /* Wait for the event handler to be called. */
484 fibril_mutex_lock(&resp.event_lock);
485 while (!resp.window_added_called) {
486 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
487 }
488 fibril_mutex_unlock(&resp.event_lock);
489
490 /* Verify that the event was delivered correctly */
491 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
492 resp.revent.etype);
493
494 wndmgt_close(wndmgt);
495
496 rc = loc_service_unregister(sid);
497 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
498}
499
500/** Window removed event can be delivered from server to client callback function */
501PCUT_TEST(window_removed_deliver)
502{
503 errno_t rc;
504 service_id_t sid;
505 wndmgt_t *wndmgt = NULL;
506 test_response_t resp;
507
508 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
509
510 // FIXME This causes this test to be non-reentrant!
511 rc = loc_server_register(test_wndmgt_server);
512 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
513
514 rc = loc_service_register(test_wndmgt_svc, &sid);
515 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
516
517 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
518 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
519 PCUT_ASSERT_NOT_NULL(wndmgt);
520 PCUT_ASSERT_NOT_NULL(resp.srv);
521
522 resp.event_cnt = 1;
523 resp.event.etype = wmev_window_removed;
524 resp.event.wnd_id = 42;
525 resp.window_removed_called = false;
526 fibril_mutex_initialize(&resp.event_lock);
527 fibril_condvar_initialize(&resp.event_cv);
528 wndmgt_srv_ev_pending(resp.srv);
529
530 /* Wait for the event handler to be called. */
531 fibril_mutex_lock(&resp.event_lock);
532 while (!resp.window_removed_called) {
533 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
534 }
535 fibril_mutex_unlock(&resp.event_lock);
536
537 /* Verify that the event was delivered correctly */
538 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
539 resp.revent.etype);
540
541 wndmgt_close(wndmgt);
542
543 rc = loc_service_unregister(sid);
544 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
545}
546
547/** Window changed event can be delivered from server to client callback function */
548PCUT_TEST(window_changed_deliver)
549{
550 errno_t rc;
551 service_id_t sid;
552 wndmgt_t *wndmgt = NULL;
553 test_response_t resp;
554
555 async_set_fallback_port_handler(test_wndmgt_conn, &resp);
556
557 // FIXME This causes this test to be non-reentrant!
558 rc = loc_server_register(test_wndmgt_server);
559 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
560
561 rc = loc_service_register(test_wndmgt_svc, &sid);
562 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
563
564 rc = wndmgt_open(test_wndmgt_svc, &test_wndmgt_cb, &resp, &wndmgt);
565 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
566 PCUT_ASSERT_NOT_NULL(wndmgt);
567 PCUT_ASSERT_NOT_NULL(resp.srv);
568
569 resp.event_cnt = 1;
570 resp.event.etype = wmev_window_changed;
571 resp.event.wnd_id = 42;
572 resp.window_changed_called = false;
573 fibril_mutex_initialize(&resp.event_lock);
574 fibril_condvar_initialize(&resp.event_cv);
575 wndmgt_srv_ev_pending(resp.srv);
576
577 /* Wait for the event handler to be called. */
578 fibril_mutex_lock(&resp.event_lock);
579 while (!resp.window_changed_called) {
580 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
581 }
582 fibril_mutex_unlock(&resp.event_lock);
583
584 /* Verify that the event was delivered correctly */
585 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
586 resp.revent.etype);
587
588 wndmgt_close(wndmgt);
589
590 rc = loc_service_unregister(sid);
591 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
592}
593
594/** Test window management service connection. */
595static void test_wndmgt_conn(ipc_call_t *icall, void *arg)
596{
597 test_response_t *resp = (test_response_t *) arg;
598 wndmgt_srv_t srv;
599
600 /* Set up protocol structure */
601 wndmgt_srv_initialize(&srv);
602 srv.ops = &test_wndmgt_srv_ops;
603 srv.arg = arg;
604 resp->srv = &srv;
605
606 /* Handle connection */
607 wndmgt_conn(icall, &srv);
608
609 resp->srv = NULL;
610}
611
612static void test_window_added(void *arg, sysarg_t wnd_id)
613{
614 test_response_t *resp = (test_response_t *) arg;
615
616 resp->revent.etype = wmev_window_added;
617
618 fibril_mutex_lock(&resp->event_lock);
619 resp->window_added_called = true;
620 resp->window_added_wnd_id = wnd_id;
621 fibril_condvar_broadcast(&resp->event_cv);
622 fibril_mutex_unlock(&resp->event_lock);
623}
624
625static void test_window_removed(void *arg, sysarg_t wnd_id)
626{
627 test_response_t *resp = (test_response_t *) arg;
628
629 resp->revent.etype = wmev_window_removed;
630
631 fibril_mutex_lock(&resp->event_lock);
632 resp->window_removed_called = true;
633 resp->window_removed_wnd_id = wnd_id;
634 fibril_condvar_broadcast(&resp->event_cv);
635 fibril_mutex_unlock(&resp->event_lock);
636}
637
638static void test_window_changed(void *arg, sysarg_t wnd_id)
639{
640 test_response_t *resp = (test_response_t *) arg;
641
642 resp->revent.etype = wmev_window_changed;
643
644 fibril_mutex_lock(&resp->event_lock);
645 resp->window_changed_called = true;
646 resp->window_changed_wnd_id = wnd_id;
647 fibril_condvar_broadcast(&resp->event_cv);
648 fibril_mutex_unlock(&resp->event_lock);
649}
650
651static errno_t test_get_window_list(void *arg, wndmgt_window_list_t **rlist)
652{
653 test_response_t *resp = (test_response_t *) arg;
654
655 resp->get_window_list_called = true;
656
657 if (resp->rc != EOK)
658 return resp->rc;
659
660 *rlist = resp->get_window_list_rlist;
661 return EOK;
662}
663
664static errno_t test_get_window_info(void *arg, sysarg_t wnd_id,
665 wndmgt_window_info_t **rinfo)
666{
667 test_response_t *resp = (test_response_t *) arg;
668
669 resp->get_window_info_called = true;
670 resp->get_window_info_wnd_id = wnd_id;
671
672 if (resp->rc != EOK)
673 return resp->rc;
674
675 *rinfo = resp->get_window_info_rinfo;
676 return EOK;
677}
678
679static errno_t test_activate_window(void *arg, sysarg_t seat_id,
680 sysarg_t wnd_id)
681{
682 test_response_t *resp = (test_response_t *) arg;
683
684 resp->activate_window_called = true;
685 resp->activate_window_seat_id = seat_id;
686 resp->activate_window_wnd_id = wnd_id;
687 return resp->rc;
688}
689
690static errno_t test_close_window(void *arg, sysarg_t wnd_id)
691{
692 test_response_t *resp = (test_response_t *) arg;
693
694 resp->close_window_called = true;
695 resp->close_window_wnd_id = wnd_id;
696 return resp->rc;
697}
698
699static errno_t test_get_event(void *arg, wndmgt_ev_t *event)
700{
701 test_response_t *resp = (test_response_t *) arg;
702
703 resp->get_event_called = true;
704 if (resp->event_cnt > 0) {
705 --resp->event_cnt;
706 *event = resp->event;
707 return EOK;
708 }
709
710 return ENOENT;
711}
712
713PCUT_EXPORT(wndmgt);
Note: See TracBrowser for help on using the repository browser.