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

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

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