source: mainline/uspace/lib/display/test/display.c@ 6828a56

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

Add pos_id information to move request, too

This will become useful momentarily.
  • Property mode set to 100644
File size: 61.4 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 <display.h>
32#include <disp_srv.h>
33#include <fibril_synch.h>
34#include <gfx/color.h>
35#include <gfx/context.h>
36#include <gfx/render.h>
37#include <ipcgfx/server.h>
38#include <loc.h>
39#include <pcut/pcut.h>
40#include <str.h>
41#include "../private/display.h"
42
43PCUT_INIT;
44
45PCUT_TEST_SUITE(display);
46
47static const char *test_display_server = "test-display";
48static const char *test_display_svc = "test/display";
49
50static void test_display_conn(ipc_call_t *, void *);
51
52static void test_close_event(void *);
53static void test_focus_event(void *, unsigned);
54static void test_kbd_event(void *, kbd_event_t *);
55static void test_pos_event(void *, pos_event_t *);
56static void test_unfocus_event(void *, unsigned);
57
58static errno_t test_window_create(void *, display_wnd_params_t *, sysarg_t *);
59static errno_t test_window_destroy(void *, sysarg_t);
60static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *, sysarg_t);
61static errno_t test_window_move(void *, sysarg_t, gfx_coord2_t *);
62static errno_t test_window_get_pos(void *, sysarg_t, gfx_coord2_t *);
63static errno_t test_window_get_max_rect(void *, sysarg_t, gfx_rect_t *);
64static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
65 gfx_coord2_t *, sysarg_t);
66static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
67 gfx_rect_t *);
68static errno_t test_window_minimize(void *, sysarg_t);
69static errno_t test_window_maximize(void *, sysarg_t);
70static errno_t test_window_unmaximize(void *, sysarg_t);
71static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t);
72static errno_t test_window_set_caption(void *, sysarg_t, const char *);
73static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
74static errno_t test_get_info(void *, display_info_t *);
75
76static errno_t test_gc_set_color(void *, gfx_color_t *);
77
78static display_ops_t test_display_srv_ops = {
79 .window_create = test_window_create,
80 .window_destroy = test_window_destroy,
81 .window_move_req = test_window_move_req,
82 .window_move = test_window_move,
83 .window_get_pos = test_window_get_pos,
84 .window_get_max_rect = test_window_get_max_rect,
85 .window_resize_req = test_window_resize_req,
86 .window_resize = test_window_resize,
87 .window_minimize = test_window_minimize,
88 .window_maximize = test_window_maximize,
89 .window_unmaximize = test_window_unmaximize,
90 .window_set_cursor = test_window_set_cursor,
91 .window_set_caption = test_window_set_caption,
92 .get_event = test_get_event,
93 .get_info = test_get_info
94};
95
96static display_wnd_cb_t test_display_wnd_cb = {
97 .close_event = test_close_event,
98 .focus_event = test_focus_event,
99 .kbd_event = test_kbd_event,
100 .pos_event = test_pos_event,
101 .unfocus_event = test_unfocus_event
102};
103
104static gfx_context_ops_t test_gc_ops = {
105 .set_color = test_gc_set_color
106};
107
108/** Describes to the server how to respond to our request and pass tracking
109 * data back to the client.
110 */
111typedef struct {
112 errno_t rc;
113 sysarg_t wnd_id;
114 display_wnd_ev_t event;
115 display_wnd_ev_t revent;
116 int event_cnt;
117 bool window_create_called;
118 gfx_rect_t create_rect;
119 gfx_coord2_t create_min_size;
120 bool window_destroy_called;
121 sysarg_t destroy_wnd_id;
122
123 bool window_move_req_called;
124 sysarg_t move_req_wnd_id;
125 gfx_coord2_t move_req_pos;
126 sysarg_t move_req_pos_id;
127
128 bool window_move_called;
129 sysarg_t move_wnd_id;
130 gfx_coord2_t move_dpos;
131
132 bool window_get_pos_called;
133 sysarg_t get_pos_wnd_id;
134 gfx_coord2_t get_pos_rpos;
135
136 bool window_get_max_rect_called;
137 sysarg_t get_max_rect_wnd_id;
138 gfx_rect_t get_max_rect_rrect;
139
140 bool window_resize_req_called;
141 sysarg_t resize_req_wnd_id;
142 display_wnd_rsztype_t resize_req_rsztype;
143 gfx_coord2_t resize_req_pos;
144 sysarg_t resize_req_pos_id;
145
146 bool window_resize_called;
147 gfx_coord2_t resize_offs;
148 gfx_rect_t resize_nbound;
149 sysarg_t resize_wnd_id;
150
151 bool window_minimize_called;
152 bool window_maximize_called;
153 bool window_unmaximize_called;
154
155 bool window_set_cursor_called;
156 sysarg_t set_cursor_wnd_id;
157 display_stock_cursor_t set_cursor_cursor;
158
159 bool window_set_caption_called;
160 sysarg_t set_caption_wnd_id;
161 char *set_caption_caption;
162
163 bool get_event_called;
164
165 bool get_info_called;
166 gfx_rect_t get_info_rect;
167
168 bool set_color_called;
169 bool close_event_called;
170
171 bool focus_event_called;
172 bool kbd_event_called;
173 bool pos_event_called;
174 bool unfocus_event_called;
175 fibril_condvar_t event_cv;
176 fibril_mutex_t event_lock;
177 display_srv_t *srv;
178} test_response_t;
179
180/** display_open(), display_close() work for valid display service */
181PCUT_TEST(open_close)
182{
183 errno_t rc;
184 service_id_t sid;
185 display_t *disp = NULL;
186 test_response_t resp;
187
188 async_set_fallback_port_handler(test_display_conn, &resp);
189
190 // FIXME This causes this test to be non-reentrant!
191 rc = loc_server_register(test_display_server);
192 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
193
194 rc = loc_service_register(test_display_svc, &sid);
195 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
196
197 rc = display_open(test_display_svc, &disp);
198 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
199 PCUT_ASSERT_NOT_NULL(disp);
200
201 display_close(disp);
202 rc = loc_service_unregister(sid);
203 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
204}
205
206/** display_window_create() with server returning error response works */
207PCUT_TEST(window_create_failure)
208{
209 errno_t rc;
210 service_id_t sid;
211 display_t *disp = NULL;
212 display_wnd_params_t params;
213 display_window_t *wnd;
214 test_response_t resp;
215
216 async_set_fallback_port_handler(test_display_conn, &resp);
217
218 // FIXME This causes this test to be non-reentrant!
219 rc = loc_server_register(test_display_server);
220 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
221
222 rc = loc_service_register(test_display_svc, &sid);
223 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
224
225 rc = display_open(test_display_svc, &disp);
226 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
227 PCUT_ASSERT_NOT_NULL(disp);
228
229 wnd = NULL;
230 resp.rc = ENOMEM;
231 resp.window_create_called = false;
232 display_wnd_params_init(&params);
233 params.rect.p0.x = 0;
234 params.rect.p0.y = 0;
235 params.rect.p0.x = 100;
236 params.rect.p0.y = 100;
237 params.min_size.x = 11;
238 params.min_size.y = 12;
239
240 rc = display_window_create(disp, &params, &test_display_wnd_cb,
241 (void *) &resp, &wnd);
242 PCUT_ASSERT_TRUE(resp.window_create_called);
243 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.create_rect.p0.x);
244 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.create_rect.p0.y);
245 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
246 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
247 PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x);
248 PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y);
249 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
250 PCUT_ASSERT_NULL(wnd);
251
252 display_close(disp);
253 rc = loc_service_unregister(sid);
254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
255}
256
257/** display_window_create() and display_window_destroy() with success
258 *
259 * with server returning success,
260 */
261PCUT_TEST(window_create_destroy_success)
262{
263 errno_t rc;
264 service_id_t sid;
265 display_t *disp = NULL;
266 display_wnd_params_t params;
267 display_window_t *wnd;
268 test_response_t resp;
269
270 async_set_fallback_port_handler(test_display_conn, &resp);
271
272 // FIXME This causes this test to be non-reentrant!
273 rc = loc_server_register(test_display_server);
274 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
275
276 rc = loc_service_register(test_display_svc, &sid);
277 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
278
279 rc = display_open(test_display_svc, &disp);
280 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
281 PCUT_ASSERT_NOT_NULL(disp);
282
283 wnd = NULL;
284 resp.rc = EOK;
285 resp.window_create_called = false;
286 display_wnd_params_init(&params);
287 params.rect.p0.x = 0;
288 params.rect.p0.y = 0;
289 params.rect.p0.x = 100;
290 params.rect.p0.y = 100;
291
292 rc = display_window_create(disp, &params, &test_display_wnd_cb,
293 (void *) &resp, &wnd);
294 PCUT_ASSERT_TRUE(resp.window_create_called);
295 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.create_rect.p0.x);
296 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.create_rect.p0.y);
297 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
298 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
299 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
300 PCUT_ASSERT_NOT_NULL(wnd);
301
302 resp.window_destroy_called = false;
303 rc = display_window_destroy(wnd);
304 PCUT_ASSERT_TRUE(resp.window_destroy_called);
305 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.destroy_wnd_id);
306 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
307
308 display_close(disp);
309 rc = loc_service_unregister(sid);
310 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
311}
312
313/** display_window_create() with server returning error response works. */
314PCUT_TEST(window_destroy_failure)
315{
316 errno_t rc;
317 service_id_t sid;
318 display_t *disp = NULL;
319 display_wnd_params_t params;
320 display_window_t *wnd;
321 test_response_t resp;
322
323 async_set_fallback_port_handler(test_display_conn, &resp);
324
325 // FIXME This causes this test to be non-reentrant!
326 rc = loc_server_register(test_display_server);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328
329 rc = loc_service_register(test_display_svc, &sid);
330 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
331
332 rc = display_open(test_display_svc, &disp);
333 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
334 PCUT_ASSERT_NOT_NULL(disp);
335
336 resp.rc = EOK;
337 resp.window_create_called = false;
338 display_wnd_params_init(&params);
339 params.rect.p0.x = 0;
340 params.rect.p0.y = 0;
341 params.rect.p0.x = 100;
342 params.rect.p0.y = 100;
343
344 rc = display_window_create(disp, &params, &test_display_wnd_cb,
345 (void *) &resp, &wnd);
346 PCUT_ASSERT_TRUE(resp.window_create_called);
347 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.create_rect.p0.x);
348 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.create_rect.p0.y);
349 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x);
350 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y);
351 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
352 PCUT_ASSERT_NOT_NULL(wnd);
353
354 resp.rc = EIO;
355 resp.window_destroy_called = false;
356 rc = display_window_destroy(wnd);
357 PCUT_ASSERT_TRUE(resp.window_destroy_called);
358 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.destroy_wnd_id);
359 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
360
361 display_close(disp);
362 rc = loc_service_unregister(sid);
363 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
364}
365
366/** display_window_destroy() can handle NULL argument */
367PCUT_TEST(window_destroy_null)
368{
369 display_window_destroy(NULL);
370}
371
372/** display_window_move_req() with server returning error response works. */
373PCUT_TEST(window_move_req_failure)
374{
375 errno_t rc;
376 service_id_t sid;
377 display_t *disp = NULL;
378 display_wnd_params_t params;
379 display_window_t *wnd;
380 test_response_t resp;
381 gfx_coord2_t pos;
382 sysarg_t pos_id;
383
384 async_set_fallback_port_handler(test_display_conn, &resp);
385
386 // FIXME This causes this test to be non-reentrant!
387 rc = loc_server_register(test_display_server);
388 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
389
390 rc = loc_service_register(test_display_svc, &sid);
391 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
392
393 rc = display_open(test_display_svc, &disp);
394 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
395 PCUT_ASSERT_NOT_NULL(disp);
396
397 resp.rc = EOK;
398 display_wnd_params_init(&params);
399 params.rect.p0.x = 0;
400 params.rect.p0.y = 0;
401 params.rect.p0.x = 100;
402 params.rect.p0.y = 100;
403
404 rc = display_window_create(disp, &params, &test_display_wnd_cb,
405 (void *) &resp, &wnd);
406 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
407 PCUT_ASSERT_NOT_NULL(wnd);
408
409 resp.rc = EIO;
410 resp.window_move_req_called = false;
411
412 pos.x = 42;
413 pos.y = 43;
414 pos_id = 44;
415
416 rc = display_window_move_req(wnd, &pos, pos_id);
417 PCUT_ASSERT_TRUE(resp.window_move_req_called);
418 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
419 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.move_req_wnd_id);
420 PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
421 PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
422 PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
423
424 display_window_destroy(wnd);
425 display_close(disp);
426 rc = loc_service_unregister(sid);
427 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
428}
429
430/** display_window_move_req() with server returning success response works. */
431PCUT_TEST(window_move_req_success)
432{
433 errno_t rc;
434 service_id_t sid;
435 display_t *disp = NULL;
436 display_wnd_params_t params;
437 display_window_t *wnd;
438 test_response_t resp;
439 gfx_coord2_t pos;
440 sysarg_t pos_id;
441
442 async_set_fallback_port_handler(test_display_conn, &resp);
443
444 // FIXME This causes this test to be non-reentrant!
445 rc = loc_server_register(test_display_server);
446 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
447
448 rc = loc_service_register(test_display_svc, &sid);
449 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
450
451 rc = display_open(test_display_svc, &disp);
452 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
453 PCUT_ASSERT_NOT_NULL(disp);
454
455 resp.rc = EOK;
456 display_wnd_params_init(&params);
457 params.rect.p0.x = 0;
458 params.rect.p0.y = 0;
459 params.rect.p0.x = 100;
460 params.rect.p0.y = 100;
461
462 rc = display_window_create(disp, &params, &test_display_wnd_cb,
463 (void *) &resp, &wnd);
464 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
465 PCUT_ASSERT_NOT_NULL(wnd);
466
467 resp.rc = EOK;
468 resp.window_move_req_called = false;
469
470 pos.x = 42;
471 pos.y = 43;
472 pos_id = 44;
473
474 rc = display_window_move_req(wnd, &pos, pos_id);
475 PCUT_ASSERT_TRUE(resp.window_move_req_called);
476 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
477 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.move_req_wnd_id);
478 PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x);
479 PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y);
480 PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id);
481
482 display_window_destroy(wnd);
483 display_close(disp);
484 rc = loc_service_unregister(sid);
485 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
486}
487
488/** display_window_move() with server returning error response works. */
489PCUT_TEST(window_move_failure)
490{
491 errno_t rc;
492 service_id_t sid;
493 display_t *disp = NULL;
494 display_wnd_params_t params;
495 display_window_t *wnd;
496 gfx_coord2_t dpos;
497 test_response_t resp;
498
499 async_set_fallback_port_handler(test_display_conn, &resp);
500
501 // FIXME This causes this test to be non-reentrant!
502 rc = loc_server_register(test_display_server);
503 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
504
505 rc = loc_service_register(test_display_svc, &sid);
506 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
507
508 rc = display_open(test_display_svc, &disp);
509 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
510 PCUT_ASSERT_NOT_NULL(disp);
511
512 resp.rc = EOK;
513 display_wnd_params_init(&params);
514 params.rect.p0.x = 0;
515 params.rect.p0.y = 0;
516 params.rect.p0.x = 100;
517 params.rect.p0.y = 100;
518
519 rc = display_window_create(disp, &params, &test_display_wnd_cb,
520 (void *) &resp, &wnd);
521 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
522 PCUT_ASSERT_NOT_NULL(wnd);
523
524 resp.rc = EIO;
525 resp.window_move_called = false;
526 dpos.x = 11;
527 dpos.y = 12;
528
529 rc = display_window_move(wnd, &dpos);
530 PCUT_ASSERT_TRUE(resp.window_move_called);
531 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
532 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.move_wnd_id);
533 PCUT_ASSERT_INT_EQUALS(dpos.x, resp.move_dpos.x);
534 PCUT_ASSERT_INT_EQUALS(dpos.y, resp.move_dpos.y);
535
536 display_window_destroy(wnd);
537 display_close(disp);
538 rc = loc_service_unregister(sid);
539 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
540}
541
542/** display_window_move() with server returning success response works. */
543PCUT_TEST(window_move_success)
544{
545 errno_t rc;
546 service_id_t sid;
547 display_t *disp = NULL;
548 display_wnd_params_t params;
549 display_window_t *wnd;
550 gfx_coord2_t dpos;
551 test_response_t resp;
552
553 async_set_fallback_port_handler(test_display_conn, &resp);
554
555 // FIXME This causes this test to be non-reentrant!
556 rc = loc_server_register(test_display_server);
557 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
558
559 rc = loc_service_register(test_display_svc, &sid);
560 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
561
562 rc = display_open(test_display_svc, &disp);
563 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
564 PCUT_ASSERT_NOT_NULL(disp);
565
566 resp.rc = EOK;
567 display_wnd_params_init(&params);
568 params.rect.p0.x = 0;
569 params.rect.p0.y = 0;
570 params.rect.p0.x = 100;
571 params.rect.p0.y = 100;
572
573 rc = display_window_create(disp, &params, &test_display_wnd_cb,
574 (void *) &resp, &wnd);
575 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
576 PCUT_ASSERT_NOT_NULL(wnd);
577
578 resp.rc = EOK;
579 resp.window_move_called = false;
580 dpos.x = 11;
581 dpos.y = 12;
582
583 rc = display_window_move(wnd, &dpos);
584 PCUT_ASSERT_TRUE(resp.window_move_called);
585 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
586 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.move_wnd_id);
587 PCUT_ASSERT_INT_EQUALS(dpos.x, resp.move_dpos.x);
588 PCUT_ASSERT_INT_EQUALS(dpos.y, resp.move_dpos.y);
589
590 display_window_destroy(wnd);
591 display_close(disp);
592 rc = loc_service_unregister(sid);
593 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
594}
595
596/** display_window_get_pos() with server returning error response works. */
597PCUT_TEST(window_get_pos_failure)
598{
599 errno_t rc;
600 service_id_t sid;
601 display_t *disp = NULL;
602 display_wnd_params_t params;
603 display_window_t *wnd;
604 gfx_coord2_t dpos;
605 test_response_t resp;
606
607 async_set_fallback_port_handler(test_display_conn, &resp);
608
609 // FIXME This causes this test to be non-reentrant!
610 rc = loc_server_register(test_display_server);
611 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
612
613 rc = loc_service_register(test_display_svc, &sid);
614 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
615
616 rc = display_open(test_display_svc, &disp);
617 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
618 PCUT_ASSERT_NOT_NULL(disp);
619
620 resp.rc = EOK;
621 display_wnd_params_init(&params);
622 params.rect.p0.x = 0;
623 params.rect.p0.y = 0;
624 params.rect.p0.x = 100;
625 params.rect.p0.y = 100;
626
627 rc = display_window_create(disp, &params, &test_display_wnd_cb,
628 (void *) &resp, &wnd);
629 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
630 PCUT_ASSERT_NOT_NULL(wnd);
631
632 resp.rc = EIO;
633 resp.window_get_pos_called = false;
634
635 dpos.x = 0;
636 dpos.y = 0;
637
638 rc = display_window_get_pos(wnd, &dpos);
639 PCUT_ASSERT_TRUE(resp.window_get_pos_called);
640 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
641 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
642 PCUT_ASSERT_INT_EQUALS(0, dpos.x);
643 PCUT_ASSERT_INT_EQUALS(0, dpos.y);
644
645 display_window_destroy(wnd);
646 display_close(disp);
647 rc = loc_service_unregister(sid);
648 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
649}
650
651/** display_window_get_pos() with server returning success response works. */
652PCUT_TEST(window_get_pos_success)
653{
654 errno_t rc;
655 service_id_t sid;
656 display_t *disp = NULL;
657 display_wnd_params_t params;
658 display_window_t *wnd;
659 gfx_coord2_t dpos;
660 test_response_t resp;
661
662 async_set_fallback_port_handler(test_display_conn, &resp);
663
664 // FIXME This causes this test to be non-reentrant!
665 rc = loc_server_register(test_display_server);
666 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
667
668 rc = loc_service_register(test_display_svc, &sid);
669 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
670
671 rc = display_open(test_display_svc, &disp);
672 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
673 PCUT_ASSERT_NOT_NULL(disp);
674
675 resp.rc = EOK;
676 display_wnd_params_init(&params);
677 params.rect.p0.x = 0;
678 params.rect.p0.y = 0;
679 params.rect.p0.x = 100;
680 params.rect.p0.y = 100;
681
682 rc = display_window_create(disp, &params, &test_display_wnd_cb,
683 (void *) &resp, &wnd);
684 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
685 PCUT_ASSERT_NOT_NULL(wnd);
686
687 resp.rc = EOK;
688 resp.window_get_pos_called = false;
689 resp.get_pos_rpos.x = 11;
690 resp.get_pos_rpos.y = 12;
691
692 dpos.x = 0;
693 dpos.y = 0;
694
695 rc = display_window_get_pos(wnd, &dpos);
696 PCUT_ASSERT_TRUE(resp.window_get_pos_called);
697 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
698 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_pos_wnd_id);
699 PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.x, dpos.x);
700 PCUT_ASSERT_INT_EQUALS(resp.get_pos_rpos.y, dpos.y);
701
702 display_window_destroy(wnd);
703 display_close(disp);
704 rc = loc_service_unregister(sid);
705 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
706}
707
708/** display_window_get_max_rect() with server returning error response works. */
709PCUT_TEST(window_get_max_rect_failure)
710{
711 errno_t rc;
712 service_id_t sid;
713 display_t *disp = NULL;
714 display_wnd_params_t params;
715 display_window_t *wnd;
716 gfx_rect_t rect;
717 test_response_t resp;
718
719 async_set_fallback_port_handler(test_display_conn, &resp);
720
721 // FIXME This causes this test to be non-reentrant!
722 rc = loc_server_register(test_display_server);
723 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
724
725 rc = loc_service_register(test_display_svc, &sid);
726 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
727
728 rc = display_open(test_display_svc, &disp);
729 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
730 PCUT_ASSERT_NOT_NULL(disp);
731
732 resp.rc = EOK;
733 display_wnd_params_init(&params);
734 params.rect.p0.x = 0;
735 params.rect.p0.y = 0;
736 params.rect.p0.x = 100;
737 params.rect.p0.y = 100;
738
739 rc = display_window_create(disp, &params, &test_display_wnd_cb,
740 (void *) &resp, &wnd);
741 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
742 PCUT_ASSERT_NOT_NULL(wnd);
743
744 resp.rc = EIO;
745 resp.window_get_max_rect_called = false;
746
747 rect.p0.x = 0;
748 rect.p0.y = 0;
749 rect.p1.x = 0;
750 rect.p1.y = 0;
751
752 rc = display_window_get_max_rect(wnd, &rect);
753 PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
754 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
755 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
756 PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
757 PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
758 PCUT_ASSERT_INT_EQUALS(0, rect.p1.x);
759 PCUT_ASSERT_INT_EQUALS(0, rect.p1.y);
760
761 display_window_destroy(wnd);
762 display_close(disp);
763 rc = loc_service_unregister(sid);
764 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
765}
766
767/** display_window_get_max_rect() with server returning success response works. */
768PCUT_TEST(window_get_max_rect_success)
769{
770 errno_t rc;
771 service_id_t sid;
772 display_t *disp = NULL;
773 display_wnd_params_t params;
774 display_window_t *wnd;
775 gfx_rect_t rect;
776 test_response_t resp;
777
778 async_set_fallback_port_handler(test_display_conn, &resp);
779
780 // FIXME This causes this test to be non-reentrant!
781 rc = loc_server_register(test_display_server);
782 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
783
784 rc = loc_service_register(test_display_svc, &sid);
785 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
786
787 rc = display_open(test_display_svc, &disp);
788 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
789 PCUT_ASSERT_NOT_NULL(disp);
790
791 resp.rc = EOK;
792 display_wnd_params_init(&params);
793 params.rect.p0.x = 0;
794 params.rect.p0.y = 0;
795 params.rect.p0.x = 100;
796 params.rect.p0.y = 100;
797
798 rc = display_window_create(disp, &params, &test_display_wnd_cb,
799 (void *) &resp, &wnd);
800 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
801 PCUT_ASSERT_NOT_NULL(wnd);
802
803 resp.rc = EOK;
804 resp.window_get_max_rect_called = false;
805 resp.get_max_rect_rrect.p0.x = 11;
806 resp.get_max_rect_rrect.p0.y = 12;
807 resp.get_max_rect_rrect.p1.x = 13;
808 resp.get_max_rect_rrect.p1.y = 14;
809
810 rect.p0.x = 0;
811 rect.p0.y = 0;
812 rect.p1.x = 0;
813 rect.p1.y = 0;
814
815 rc = display_window_get_max_rect(wnd, &rect);
816 PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
817 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
818 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
819 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x);
820 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y);
821 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x);
822 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y);
823
824 display_window_destroy(wnd);
825 display_close(disp);
826 rc = loc_service_unregister(sid);
827 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
828}
829
830/** display_window_resize_req() with server returning error response works. */
831PCUT_TEST(window_resize_req_failure)
832{
833 errno_t rc;
834 service_id_t sid;
835 display_t *disp = NULL;
836 display_wnd_params_t params;
837 display_window_t *wnd;
838 test_response_t resp;
839 display_wnd_rsztype_t rsztype;
840 gfx_coord2_t pos;
841 sysarg_t pos_id;
842
843 async_set_fallback_port_handler(test_display_conn, &resp);
844
845 // FIXME This causes this test to be non-reentrant!
846 rc = loc_server_register(test_display_server);
847 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
848
849 rc = loc_service_register(test_display_svc, &sid);
850 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
851
852 rc = display_open(test_display_svc, &disp);
853 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
854 PCUT_ASSERT_NOT_NULL(disp);
855
856 resp.rc = EOK;
857 display_wnd_params_init(&params);
858 params.rect.p0.x = 0;
859 params.rect.p0.y = 0;
860 params.rect.p0.x = 100;
861 params.rect.p0.y = 100;
862
863 rc = display_window_create(disp, &params, &test_display_wnd_cb,
864 (void *) &resp, &wnd);
865 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
866 PCUT_ASSERT_NOT_NULL(wnd);
867
868 resp.rc = EIO;
869 resp.window_resize_req_called = false;
870
871 rsztype = display_wr_top_right;
872 pos.x = 42;
873 pos.y = 43;
874 pos_id = 44;
875
876 rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
877 PCUT_ASSERT_TRUE(resp.window_resize_req_called);
878 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
879 PCUT_ASSERT_INT_EQUALS(rsztype, resp.resize_req_rsztype);
880 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.resize_req_wnd_id);
881 PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
882 PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
883 PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
884
885 display_window_destroy(wnd);
886 display_close(disp);
887 rc = loc_service_unregister(sid);
888 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
889}
890
891/** display_window_resize_req() with server returning success response works. */
892PCUT_TEST(window_resize_req_success)
893{
894 errno_t rc;
895 service_id_t sid;
896 display_t *disp = NULL;
897 display_wnd_params_t params;
898 display_window_t *wnd;
899 test_response_t resp;
900 display_wnd_rsztype_t rsztype;
901 gfx_coord2_t pos;
902 sysarg_t pos_id;
903
904 async_set_fallback_port_handler(test_display_conn, &resp);
905
906 // FIXME This causes this test to be non-reentrant!
907 rc = loc_server_register(test_display_server);
908 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
909
910 rc = loc_service_register(test_display_svc, &sid);
911 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
912
913 rc = display_open(test_display_svc, &disp);
914 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
915 PCUT_ASSERT_NOT_NULL(disp);
916
917 resp.rc = EOK;
918 display_wnd_params_init(&params);
919 params.rect.p0.x = 0;
920 params.rect.p0.y = 0;
921 params.rect.p0.x = 100;
922 params.rect.p0.y = 100;
923
924 rc = display_window_create(disp, &params, &test_display_wnd_cb,
925 (void *) &resp, &wnd);
926 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
927 PCUT_ASSERT_NOT_NULL(wnd);
928
929 resp.rc = EOK;
930 resp.window_resize_req_called = false;
931
932 rsztype = display_wr_top_right;
933 pos.x = 42;
934 pos.y = 43;
935 pos_id = 44;
936
937 rc = display_window_resize_req(wnd, rsztype, &pos, pos_id);
938 PCUT_ASSERT_TRUE(resp.window_resize_req_called);
939 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
940 PCUT_ASSERT_INT_EQUALS(rsztype, resp.resize_req_rsztype);
941 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.resize_req_wnd_id);
942 PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x);
943 PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y);
944 PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id);
945
946 display_window_destroy(wnd);
947 display_close(disp);
948 rc = loc_service_unregister(sid);
949 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
950}
951
952/** display_window_resize() with server returning error response works. */
953PCUT_TEST(window_resize_failure)
954{
955 errno_t rc;
956 service_id_t sid;
957 display_t *disp = NULL;
958 display_wnd_params_t params;
959 display_window_t *wnd;
960 gfx_coord2_t offs;
961 gfx_rect_t nrect;
962 test_response_t resp;
963
964 async_set_fallback_port_handler(test_display_conn, &resp);
965
966 // FIXME This causes this test to be non-reentrant!
967 rc = loc_server_register(test_display_server);
968 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
969
970 rc = loc_service_register(test_display_svc, &sid);
971 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
972
973 rc = display_open(test_display_svc, &disp);
974 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
975 PCUT_ASSERT_NOT_NULL(disp);
976
977 resp.rc = EOK;
978 display_wnd_params_init(&params);
979 params.rect.p0.x = 0;
980 params.rect.p0.y = 0;
981 params.rect.p0.x = 100;
982 params.rect.p0.y = 100;
983
984 rc = display_window_create(disp, &params, &test_display_wnd_cb,
985 (void *) &resp, &wnd);
986 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
987 PCUT_ASSERT_NOT_NULL(wnd);
988
989 resp.rc = EIO;
990 resp.window_resize_called = false;
991 offs.x = 11;
992 offs.y = 12;
993 nrect.p0.x = 13;
994 nrect.p0.y = 14;
995 nrect.p1.x = 15;
996 nrect.p1.y = 16;
997
998 rc = display_window_resize(wnd, &offs, &nrect);
999 PCUT_ASSERT_TRUE(resp.window_resize_called);
1000 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1001 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.resize_wnd_id);
1002 PCUT_ASSERT_INT_EQUALS(offs.x, resp.resize_offs.x);
1003 PCUT_ASSERT_INT_EQUALS(offs.y, resp.resize_offs.y);
1004 PCUT_ASSERT_INT_EQUALS(nrect.p0.x, resp.resize_nbound.p0.x);
1005 PCUT_ASSERT_INT_EQUALS(nrect.p0.y, resp.resize_nbound.p0.y);
1006 PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
1007 PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
1008
1009 display_window_destroy(wnd);
1010 display_close(disp);
1011 rc = loc_service_unregister(sid);
1012 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1013}
1014
1015/** display_window_resize() with server returning success response works. */
1016PCUT_TEST(window_resize_success)
1017{
1018 errno_t rc;
1019 service_id_t sid;
1020 display_t *disp = NULL;
1021 display_wnd_params_t params;
1022 display_window_t *wnd;
1023 gfx_coord2_t offs;
1024 gfx_rect_t nrect;
1025 test_response_t resp;
1026
1027 async_set_fallback_port_handler(test_display_conn, &resp);
1028
1029 // FIXME This causes this test to be non-reentrant!
1030 rc = loc_server_register(test_display_server);
1031 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1032
1033 rc = loc_service_register(test_display_svc, &sid);
1034 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1035
1036 rc = display_open(test_display_svc, &disp);
1037 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1038 PCUT_ASSERT_NOT_NULL(disp);
1039
1040 resp.rc = EOK;
1041 display_wnd_params_init(&params);
1042 params.rect.p0.x = 0;
1043 params.rect.p0.y = 0;
1044 params.rect.p0.x = 100;
1045 params.rect.p0.y = 100;
1046
1047 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1048 (void *) &resp, &wnd);
1049 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1050 PCUT_ASSERT_NOT_NULL(wnd);
1051
1052 resp.rc = EOK;
1053 resp.window_resize_called = false;
1054 offs.x = 11;
1055 offs.y = 12;
1056 nrect.p0.x = 13;
1057 nrect.p0.y = 14;
1058 nrect.p1.x = 15;
1059 nrect.p1.y = 16;
1060
1061 rc = display_window_resize(wnd, &offs, &nrect);
1062 PCUT_ASSERT_TRUE(resp.window_resize_called);
1063 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1064 PCUT_ASSERT_INT_EQUALS(offs.x, resp.resize_offs.x);
1065 PCUT_ASSERT_INT_EQUALS(offs.y, resp.resize_offs.y);
1066 PCUT_ASSERT_INT_EQUALS(nrect.p0.x, resp.resize_nbound.p0.x);
1067 PCUT_ASSERT_INT_EQUALS(nrect.p0.y, resp.resize_nbound.p0.y);
1068 PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
1069 PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
1070
1071 display_window_destroy(wnd);
1072 display_close(disp);
1073 rc = loc_service_unregister(sid);
1074 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1075}
1076
1077/** display_window_minimize() with server returning error response works. */
1078PCUT_TEST(window_minimize_failure)
1079{
1080 errno_t rc;
1081 service_id_t sid;
1082 display_t *disp = NULL;
1083 display_wnd_params_t params;
1084 display_window_t *wnd;
1085 test_response_t resp;
1086
1087 async_set_fallback_port_handler(test_display_conn, &resp);
1088
1089 // FIXME This causes this test to be non-reentrant!
1090 rc = loc_server_register(test_display_server);
1091 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1092
1093 rc = loc_service_register(test_display_svc, &sid);
1094 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1095
1096 rc = display_open(test_display_svc, &disp);
1097 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1098 PCUT_ASSERT_NOT_NULL(disp);
1099
1100 resp.rc = EOK;
1101 display_wnd_params_init(&params);
1102 params.rect.p0.x = 0;
1103 params.rect.p0.y = 0;
1104 params.rect.p0.x = 100;
1105 params.rect.p0.y = 100;
1106
1107 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1108 (void *) &resp, &wnd);
1109 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1110 PCUT_ASSERT_NOT_NULL(wnd);
1111
1112 resp.rc = EIO;
1113 resp.window_minimize_called = false;
1114
1115 rc = display_window_minimize(wnd);
1116 PCUT_ASSERT_TRUE(resp.window_minimize_called);
1117 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1118
1119 display_window_destroy(wnd);
1120 display_close(disp);
1121 rc = loc_service_unregister(sid);
1122 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1123}
1124
1125/** display_window_minimize() with server returning success response works. */
1126PCUT_TEST(window_minimize_success)
1127{
1128 errno_t rc;
1129 service_id_t sid;
1130 display_t *disp = NULL;
1131 display_wnd_params_t params;
1132 display_window_t *wnd;
1133 test_response_t resp;
1134
1135 async_set_fallback_port_handler(test_display_conn, &resp);
1136
1137 // FIXME This causes this test to be non-reentrant!
1138 rc = loc_server_register(test_display_server);
1139 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1140
1141 rc = loc_service_register(test_display_svc, &sid);
1142 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1143
1144 rc = display_open(test_display_svc, &disp);
1145 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1146 PCUT_ASSERT_NOT_NULL(disp);
1147
1148 resp.rc = EOK;
1149 display_wnd_params_init(&params);
1150 params.rect.p0.x = 0;
1151 params.rect.p0.y = 0;
1152 params.rect.p0.x = 100;
1153 params.rect.p0.y = 100;
1154
1155 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1156 (void *) &resp, &wnd);
1157 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1158 PCUT_ASSERT_NOT_NULL(wnd);
1159
1160 resp.rc = EOK;
1161 resp.window_minimize_called = false;
1162
1163 rc = display_window_minimize(wnd);
1164 PCUT_ASSERT_TRUE(resp.window_minimize_called);
1165 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1166
1167 display_window_destroy(wnd);
1168 display_close(disp);
1169 rc = loc_service_unregister(sid);
1170 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1171}
1172
1173/** display_window_maximize() with server returning error response works. */
1174PCUT_TEST(window_maximize_failure)
1175{
1176 errno_t rc;
1177 service_id_t sid;
1178 display_t *disp = NULL;
1179 display_wnd_params_t params;
1180 display_window_t *wnd;
1181 test_response_t resp;
1182
1183 async_set_fallback_port_handler(test_display_conn, &resp);
1184
1185 // FIXME This causes this test to be non-reentrant!
1186 rc = loc_server_register(test_display_server);
1187 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1188
1189 rc = loc_service_register(test_display_svc, &sid);
1190 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1191
1192 rc = display_open(test_display_svc, &disp);
1193 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1194 PCUT_ASSERT_NOT_NULL(disp);
1195
1196 resp.rc = EOK;
1197 display_wnd_params_init(&params);
1198 params.rect.p0.x = 0;
1199 params.rect.p0.y = 0;
1200 params.rect.p0.x = 100;
1201 params.rect.p0.y = 100;
1202
1203 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1204 (void *) &resp, &wnd);
1205 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1206 PCUT_ASSERT_NOT_NULL(wnd);
1207
1208 resp.rc = EIO;
1209 resp.window_maximize_called = false;
1210
1211 rc = display_window_maximize(wnd);
1212 PCUT_ASSERT_TRUE(resp.window_maximize_called);
1213 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1214
1215 display_window_destroy(wnd);
1216 display_close(disp);
1217 rc = loc_service_unregister(sid);
1218 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1219}
1220
1221/** display_window_maximize() with server returning success response works. */
1222PCUT_TEST(window_maximize_success)
1223{
1224 errno_t rc;
1225 service_id_t sid;
1226 display_t *disp = NULL;
1227 display_wnd_params_t params;
1228 display_window_t *wnd;
1229 test_response_t resp;
1230
1231 async_set_fallback_port_handler(test_display_conn, &resp);
1232
1233 // FIXME This causes this test to be non-reentrant!
1234 rc = loc_server_register(test_display_server);
1235 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1236
1237 rc = loc_service_register(test_display_svc, &sid);
1238 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1239
1240 rc = display_open(test_display_svc, &disp);
1241 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1242 PCUT_ASSERT_NOT_NULL(disp);
1243
1244 resp.rc = EOK;
1245 display_wnd_params_init(&params);
1246 params.rect.p0.x = 0;
1247 params.rect.p0.y = 0;
1248 params.rect.p0.x = 100;
1249 params.rect.p0.y = 100;
1250
1251 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1252 (void *) &resp, &wnd);
1253 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1254 PCUT_ASSERT_NOT_NULL(wnd);
1255
1256 resp.rc = EOK;
1257 resp.window_maximize_called = false;
1258
1259 rc = display_window_maximize(wnd);
1260 PCUT_ASSERT_TRUE(resp.window_maximize_called);
1261 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1262
1263 display_window_destroy(wnd);
1264 display_close(disp);
1265 rc = loc_service_unregister(sid);
1266 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1267}
1268
1269/** display_window_set_cursor() with server returning error response works. */
1270PCUT_TEST(window_set_cursor_failure)
1271{
1272 errno_t rc;
1273 service_id_t sid;
1274 display_t *disp = NULL;
1275 display_wnd_params_t params;
1276 display_window_t *wnd;
1277 test_response_t resp;
1278
1279 async_set_fallback_port_handler(test_display_conn, &resp);
1280
1281 // FIXME This causes this test to be non-reentrant!
1282 rc = loc_server_register(test_display_server);
1283 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1284
1285 rc = loc_service_register(test_display_svc, &sid);
1286 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1287
1288 rc = display_open(test_display_svc, &disp);
1289 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1290 PCUT_ASSERT_NOT_NULL(disp);
1291
1292 resp.rc = EOK;
1293 display_wnd_params_init(&params);
1294 params.rect.p0.x = 0;
1295 params.rect.p0.y = 0;
1296 params.rect.p0.x = 100;
1297 params.rect.p0.y = 100;
1298
1299 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1300 (void *) &resp, &wnd);
1301 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1302 PCUT_ASSERT_NOT_NULL(wnd);
1303
1304 resp.rc = EIO;
1305 resp.window_set_cursor_called = false;
1306
1307 rc = display_window_set_cursor(wnd, dcurs_size_ud);
1308 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_cursor_wnd_id);
1309 PCUT_ASSERT_TRUE(resp.window_set_cursor_called);
1310 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1311 PCUT_ASSERT_INT_EQUALS(dcurs_size_ud, resp.set_cursor_cursor);
1312
1313 display_window_destroy(wnd);
1314 display_close(disp);
1315 rc = loc_service_unregister(sid);
1316 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1317}
1318
1319/** display_window_set_cursor() with server returning success response works. */
1320PCUT_TEST(window_set_cursor_success)
1321{
1322 errno_t rc;
1323 service_id_t sid;
1324 display_t *disp = NULL;
1325 display_wnd_params_t params;
1326 display_window_t *wnd;
1327 test_response_t resp;
1328
1329 async_set_fallback_port_handler(test_display_conn, &resp);
1330
1331 // FIXME This causes this test to be non-reentrant!
1332 rc = loc_server_register(test_display_server);
1333 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1334
1335 rc = loc_service_register(test_display_svc, &sid);
1336 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1337
1338 rc = display_open(test_display_svc, &disp);
1339 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1340 PCUT_ASSERT_NOT_NULL(disp);
1341
1342 resp.rc = EOK;
1343 display_wnd_params_init(&params);
1344 params.rect.p0.x = 0;
1345 params.rect.p0.y = 0;
1346 params.rect.p0.x = 100;
1347 params.rect.p0.y = 100;
1348
1349 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1350 (void *) &resp, &wnd);
1351 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1352 PCUT_ASSERT_NOT_NULL(wnd);
1353
1354 resp.rc = EOK;
1355 resp.window_set_cursor_called = false;
1356
1357 rc = display_window_set_cursor(wnd, dcurs_size_ud);
1358 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_cursor_wnd_id);
1359 PCUT_ASSERT_TRUE(resp.window_set_cursor_called);
1360 PCUT_ASSERT_ERRNO_VAL(resp.rc, EOK);
1361 PCUT_ASSERT_INT_EQUALS(dcurs_size_ud, resp.set_cursor_cursor);
1362
1363 display_window_destroy(wnd);
1364 display_close(disp);
1365 rc = loc_service_unregister(sid);
1366 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1367}
1368
1369/** display_window_set_caption() with server returning error response works. */
1370PCUT_TEST(window_set_caption_failure)
1371{
1372 errno_t rc;
1373 service_id_t sid;
1374 display_t *disp = NULL;
1375 display_wnd_params_t params;
1376 display_window_t *wnd;
1377 const char *caption;
1378 test_response_t resp;
1379
1380 async_set_fallback_port_handler(test_display_conn, &resp);
1381
1382 // FIXME This causes this test to be non-reentrant!
1383 rc = loc_server_register(test_display_server);
1384 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1385
1386 rc = loc_service_register(test_display_svc, &sid);
1387 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1388
1389 rc = display_open(test_display_svc, &disp);
1390 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1391 PCUT_ASSERT_NOT_NULL(disp);
1392
1393 resp.rc = EOK;
1394 display_wnd_params_init(&params);
1395 params.rect.p0.x = 0;
1396 params.rect.p0.y = 0;
1397 params.rect.p0.x = 100;
1398 params.rect.p0.y = 100;
1399
1400 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1401 (void *) &resp, &wnd);
1402 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1403 PCUT_ASSERT_NOT_NULL(wnd);
1404
1405 caption = "Hello";
1406
1407 resp.rc = EIO;
1408 resp.window_set_caption_called = false;
1409
1410 rc = display_window_set_caption(wnd, caption);
1411 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
1412 PCUT_ASSERT_TRUE(resp.window_set_caption_called);
1413 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1414 PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
1415
1416 //free(resp.set_caption_caption);
1417 display_window_destroy(wnd);
1418 display_close(disp);
1419 rc = loc_service_unregister(sid);
1420 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1421}
1422
1423/** display_window_set_caption() with server returning success response works. */
1424PCUT_TEST(window_set_caption_success)
1425{
1426 errno_t rc;
1427 service_id_t sid;
1428 display_t *disp = NULL;
1429 display_wnd_params_t params;
1430 display_window_t *wnd;
1431 const char *caption;
1432 test_response_t resp;
1433
1434 async_set_fallback_port_handler(test_display_conn, &resp);
1435
1436 // FIXME This causes this test to be non-reentrant!
1437 rc = loc_server_register(test_display_server);
1438 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1439
1440 rc = loc_service_register(test_display_svc, &sid);
1441 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1442
1443 rc = display_open(test_display_svc, &disp);
1444 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1445 PCUT_ASSERT_NOT_NULL(disp);
1446
1447 resp.rc = EOK;
1448 display_wnd_params_init(&params);
1449 params.rect.p0.x = 0;
1450 params.rect.p0.y = 0;
1451 params.rect.p0.x = 100;
1452 params.rect.p0.y = 100;
1453
1454 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1455 (void *) &resp, &wnd);
1456 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1457 PCUT_ASSERT_NOT_NULL(wnd);
1458
1459 caption = "Hello";
1460
1461 resp.rc = EOK;
1462 resp.window_set_caption_called = false;
1463
1464 rc = display_window_set_caption(wnd, caption);
1465 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id);
1466 PCUT_ASSERT_TRUE(resp.window_set_caption_called);
1467 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1468 PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption));
1469
1470 //free(resp.set_caption_caption);
1471 display_window_destroy(wnd);
1472 display_close(disp);
1473 rc = loc_service_unregister(sid);
1474 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1475}
1476
1477/** display_window_get_gc with server returning failure */
1478PCUT_TEST(window_get_gc_failure)
1479{
1480 errno_t rc;
1481 service_id_t sid;
1482 display_t *disp = NULL;
1483 display_wnd_params_t params;
1484 display_window_t *wnd;
1485 test_response_t resp;
1486 gfx_context_t *gc;
1487
1488 async_set_fallback_port_handler(test_display_conn, &resp);
1489
1490 // FIXME This causes this test to be non-reentrant!
1491 rc = loc_server_register(test_display_server);
1492 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1493
1494 rc = loc_service_register(test_display_svc, &sid);
1495 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1496
1497 rc = display_open(test_display_svc, &disp);
1498 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1499 PCUT_ASSERT_NOT_NULL(disp);
1500
1501 wnd = NULL;
1502 resp.rc = EOK;
1503 display_wnd_params_init(&params);
1504 params.rect.p0.x = 0;
1505 params.rect.p0.y = 0;
1506 params.rect.p0.x = 100;
1507 params.rect.p0.y = 100;
1508
1509 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1510 (void *) &resp, &wnd);
1511 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1512 PCUT_ASSERT_NOT_NULL(wnd);
1513
1514 gc = NULL;
1515 resp.rc = ENOMEM;
1516 rc = display_window_get_gc(wnd, &gc);
1517 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1518 PCUT_ASSERT_NULL(gc);
1519
1520 resp.rc = EOK;
1521 rc = display_window_destroy(wnd);
1522 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1523
1524 display_close(disp);
1525 rc = loc_service_unregister(sid);
1526 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1527}
1528
1529/** display_window_get_gc with server returning success */
1530PCUT_TEST(window_get_gc_success)
1531{
1532 errno_t rc;
1533 service_id_t sid;
1534 display_t *disp = NULL;
1535 display_wnd_params_t params;
1536 display_window_t *wnd;
1537 test_response_t resp;
1538 gfx_context_t *gc;
1539 gfx_color_t *color;
1540
1541 async_set_fallback_port_handler(test_display_conn, &resp);
1542
1543 // FIXME This causes this test to be non-reentrant!
1544 rc = loc_server_register(test_display_server);
1545 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1546
1547 rc = loc_service_register(test_display_svc, &sid);
1548 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1549
1550 rc = display_open(test_display_svc, &disp);
1551 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1552 PCUT_ASSERT_NOT_NULL(disp);
1553
1554 wnd = NULL;
1555 resp.rc = EOK;
1556 display_wnd_params_init(&params);
1557 params.rect.p0.x = 0;
1558 params.rect.p0.y = 0;
1559 params.rect.p0.x = 100;
1560 params.rect.p0.y = 100;
1561
1562 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1563 (void *) &resp, &wnd);
1564 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1565 PCUT_ASSERT_NOT_NULL(wnd);
1566
1567 gc = NULL;
1568 rc = display_window_get_gc(wnd, &gc);
1569 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1570 PCUT_ASSERT_NOT_NULL(gc);
1571
1572 rc = gfx_color_new_rgb_i16(0, 0, 0, &color);
1573 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1574
1575 resp.set_color_called = false;
1576 rc = gfx_set_color(gc, color);
1577 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1578 PCUT_ASSERT_TRUE(resp.set_color_called);
1579
1580 gfx_color_delete(color);
1581
1582 rc = display_window_destroy(wnd);
1583 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1584
1585 display_close(disp);
1586 rc = loc_service_unregister(sid);
1587 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1588}
1589
1590/** Close event can be delivered from server to client callback function */
1591PCUT_TEST(close_event_deliver)
1592{
1593 errno_t rc;
1594 service_id_t sid;
1595 display_t *disp = NULL;
1596 display_wnd_params_t params;
1597 display_window_t *wnd;
1598 test_response_t resp;
1599
1600 async_set_fallback_port_handler(test_display_conn, &resp);
1601
1602 // FIXME This causes this test to be non-reentrant!
1603 rc = loc_server_register(test_display_server);
1604 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1605
1606 rc = loc_service_register(test_display_svc, &sid);
1607 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1608
1609 rc = display_open(test_display_svc, &disp);
1610 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1611 PCUT_ASSERT_NOT_NULL(disp);
1612 PCUT_ASSERT_NOT_NULL(resp.srv);
1613
1614 wnd = NULL;
1615 resp.rc = EOK;
1616 display_wnd_params_init(&params);
1617 params.rect.p0.x = 0;
1618 params.rect.p0.y = 0;
1619 params.rect.p0.x = 100;
1620 params.rect.p0.y = 100;
1621
1622 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1623 (void *) &resp, &wnd);
1624 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1625 PCUT_ASSERT_NOT_NULL(wnd);
1626
1627 resp.event_cnt = 1;
1628 resp.event.etype = wev_close;
1629 resp.wnd_id = wnd->id;
1630 resp.close_event_called = false;
1631 fibril_mutex_initialize(&resp.event_lock);
1632 fibril_condvar_initialize(&resp.event_cv);
1633 display_srv_ev_pending(resp.srv);
1634
1635 /* Wait for the event handler to be called. */
1636 fibril_mutex_lock(&resp.event_lock);
1637 while (!resp.close_event_called) {
1638 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
1639 }
1640 fibril_mutex_unlock(&resp.event_lock);
1641
1642 /* Verify that the event was delivered correctly */
1643 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
1644 resp.revent.etype);
1645
1646 rc = display_window_destroy(wnd);
1647 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1648
1649 display_close(disp);
1650
1651 rc = loc_service_unregister(sid);
1652 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1653}
1654
1655/** Focus event can be delivered from server to client callback function */
1656PCUT_TEST(focus_event_deliver)
1657{
1658 errno_t rc;
1659 service_id_t sid;
1660 display_t *disp = NULL;
1661 display_wnd_params_t params;
1662 display_window_t *wnd;
1663 test_response_t resp;
1664
1665 async_set_fallback_port_handler(test_display_conn, &resp);
1666
1667 // FIXME This causes this test to be non-reentrant!
1668 rc = loc_server_register(test_display_server);
1669 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1670
1671 rc = loc_service_register(test_display_svc, &sid);
1672 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1673
1674 rc = display_open(test_display_svc, &disp);
1675 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1676 PCUT_ASSERT_NOT_NULL(disp);
1677 PCUT_ASSERT_NOT_NULL(resp.srv);
1678
1679 wnd = NULL;
1680 resp.rc = EOK;
1681 display_wnd_params_init(&params);
1682 params.rect.p0.x = 0;
1683 params.rect.p0.y = 0;
1684 params.rect.p0.x = 100;
1685 params.rect.p0.y = 100;
1686
1687 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1688 (void *) &resp, &wnd);
1689 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1690 PCUT_ASSERT_NOT_NULL(wnd);
1691
1692 resp.event_cnt = 1;
1693 resp.event.etype = wev_focus;
1694 resp.event.ev.focus.nfocus = 42;
1695 resp.wnd_id = wnd->id;
1696 resp.focus_event_called = false;
1697 fibril_mutex_initialize(&resp.event_lock);
1698 fibril_condvar_initialize(&resp.event_cv);
1699 display_srv_ev_pending(resp.srv);
1700
1701 /* Wait for the event handler to be called. */
1702 fibril_mutex_lock(&resp.event_lock);
1703 while (!resp.focus_event_called) {
1704 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
1705 }
1706 fibril_mutex_unlock(&resp.event_lock);
1707
1708 /* Verify that the event was delivered correctly */
1709 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
1710 resp.revent.etype);
1711 PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
1712 resp.revent.ev.focus.nfocus);
1713
1714 rc = display_window_destroy(wnd);
1715 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1716
1717 display_close(disp);
1718
1719 rc = loc_service_unregister(sid);
1720 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1721}
1722
1723/** Keyboard event can be delivered from server to client callback function */
1724PCUT_TEST(kbd_event_deliver)
1725{
1726 errno_t rc;
1727 service_id_t sid;
1728 display_t *disp = NULL;
1729 display_wnd_params_t params;
1730 display_window_t *wnd;
1731 test_response_t resp;
1732
1733 async_set_fallback_port_handler(test_display_conn, &resp);
1734
1735 // FIXME This causes this test to be non-reentrant!
1736 rc = loc_server_register(test_display_server);
1737 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1738
1739 rc = loc_service_register(test_display_svc, &sid);
1740 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1741
1742 rc = display_open(test_display_svc, &disp);
1743 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1744 PCUT_ASSERT_NOT_NULL(disp);
1745 PCUT_ASSERT_NOT_NULL(resp.srv);
1746
1747 wnd = NULL;
1748 resp.rc = EOK;
1749 display_wnd_params_init(&params);
1750 params.rect.p0.x = 0;
1751 params.rect.p0.y = 0;
1752 params.rect.p0.x = 100;
1753 params.rect.p0.y = 100;
1754
1755 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1756 (void *) &resp, &wnd);
1757 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1758 PCUT_ASSERT_NOT_NULL(wnd);
1759
1760 resp.event_cnt = 1;
1761 resp.event.etype = wev_kbd;
1762 resp.event.ev.kbd.type = KEY_PRESS;
1763 resp.event.ev.kbd.key = KC_ENTER;
1764 resp.event.ev.kbd.mods = 0;
1765 resp.event.ev.kbd.c = L'\0';
1766 resp.wnd_id = wnd->id;
1767 resp.kbd_event_called = false;
1768 fibril_mutex_initialize(&resp.event_lock);
1769 fibril_condvar_initialize(&resp.event_cv);
1770 display_srv_ev_pending(resp.srv);
1771
1772 /* Wait for the event handler to be called. */
1773 fibril_mutex_lock(&resp.event_lock);
1774 while (!resp.kbd_event_called) {
1775 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
1776 }
1777 fibril_mutex_unlock(&resp.event_lock);
1778
1779 /* Verify that the event was delivered correctly */
1780 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
1781 resp.revent.etype);
1782 PCUT_ASSERT_INT_EQUALS(resp.event.ev.kbd.type,
1783 resp.revent.ev.kbd.type);
1784 PCUT_ASSERT_INT_EQUALS(resp.event.ev.kbd.key,
1785 resp.revent.ev.kbd.key);
1786 PCUT_ASSERT_INT_EQUALS(resp.event.ev.kbd.mods,
1787 resp.revent.ev.kbd.mods);
1788 PCUT_ASSERT_INT_EQUALS(resp.event.ev.kbd.c,
1789 resp.revent.ev.kbd.c);
1790
1791 rc = display_window_destroy(wnd);
1792 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1793
1794 display_close(disp);
1795
1796 rc = loc_service_unregister(sid);
1797 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1798}
1799
1800/** Position event can be delivered from server to client callback function */
1801PCUT_TEST(pos_event_deliver)
1802{
1803 errno_t rc;
1804 service_id_t sid;
1805 display_t *disp = NULL;
1806 display_wnd_params_t params;
1807 display_window_t *wnd;
1808 test_response_t resp;
1809
1810 async_set_fallback_port_handler(test_display_conn, &resp);
1811
1812 // FIXME This causes this test to be non-reentrant!
1813 rc = loc_server_register(test_display_server);
1814 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1815
1816 rc = loc_service_register(test_display_svc, &sid);
1817 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1818
1819 rc = display_open(test_display_svc, &disp);
1820 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1821 PCUT_ASSERT_NOT_NULL(disp);
1822 PCUT_ASSERT_NOT_NULL(resp.srv);
1823
1824 wnd = NULL;
1825 resp.rc = EOK;
1826 display_wnd_params_init(&params);
1827 params.rect.p0.x = 0;
1828 params.rect.p0.y = 0;
1829 params.rect.p0.x = 100;
1830 params.rect.p0.y = 100;
1831
1832 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1833 (void *) &resp, &wnd);
1834 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1835 PCUT_ASSERT_NOT_NULL(wnd);
1836
1837 resp.event_cnt = 1;
1838 resp.event.etype = wev_pos;
1839 resp.event.ev.pos.type = POS_PRESS;
1840 resp.event.ev.pos.btn_num = 1;
1841 resp.event.ev.pos.hpos = 2;
1842 resp.event.ev.pos.vpos = 3;
1843 resp.wnd_id = wnd->id;
1844 resp.pos_event_called = false;
1845 fibril_mutex_initialize(&resp.event_lock);
1846 fibril_condvar_initialize(&resp.event_cv);
1847 display_srv_ev_pending(resp.srv);
1848
1849 /* Wait for the event handler to be called. */
1850 fibril_mutex_lock(&resp.event_lock);
1851 while (!resp.pos_event_called) {
1852 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
1853 }
1854 fibril_mutex_unlock(&resp.event_lock);
1855
1856 /* Verify that the event was delivered correctly */
1857 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
1858 resp.revent.etype);
1859 PCUT_ASSERT_INT_EQUALS(resp.event.ev.pos.type,
1860 resp.revent.ev.pos.type);
1861 PCUT_ASSERT_INT_EQUALS(resp.event.ev.pos.btn_num,
1862 resp.revent.ev.pos.btn_num);
1863 PCUT_ASSERT_INT_EQUALS(resp.event.ev.pos.hpos,
1864 resp.revent.ev.pos.hpos);
1865 PCUT_ASSERT_INT_EQUALS(resp.event.ev.pos.vpos,
1866 resp.revent.ev.pos.vpos);
1867
1868 rc = display_window_destroy(wnd);
1869 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1870
1871 display_close(disp);
1872
1873 rc = loc_service_unregister(sid);
1874 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1875}
1876
1877/** Unfocus event can be delivered from server to client callback function */
1878PCUT_TEST(unfocus_event_deliver)
1879{
1880 errno_t rc;
1881 service_id_t sid;
1882 display_t *disp = NULL;
1883 display_wnd_params_t params;
1884 display_window_t *wnd;
1885 test_response_t resp;
1886
1887 async_set_fallback_port_handler(test_display_conn, &resp);
1888
1889 // FIXME This causes this test to be non-reentrant!
1890 rc = loc_server_register(test_display_server);
1891 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1892
1893 rc = loc_service_register(test_display_svc, &sid);
1894 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1895
1896 rc = display_open(test_display_svc, &disp);
1897 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1898 PCUT_ASSERT_NOT_NULL(disp);
1899 PCUT_ASSERT_NOT_NULL(resp.srv);
1900
1901 wnd = NULL;
1902 resp.rc = EOK;
1903 display_wnd_params_init(&params);
1904 params.rect.p0.x = 0;
1905 params.rect.p0.y = 0;
1906 params.rect.p0.x = 100;
1907 params.rect.p0.y = 100;
1908
1909 rc = display_window_create(disp, &params, &test_display_wnd_cb,
1910 (void *) &resp, &wnd);
1911 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1912 PCUT_ASSERT_NOT_NULL(wnd);
1913
1914 resp.event_cnt = 1;
1915 resp.event.etype = wev_unfocus;
1916 resp.event.ev.unfocus.nfocus = 42;
1917 resp.wnd_id = wnd->id;
1918 resp.unfocus_event_called = false;
1919 fibril_mutex_initialize(&resp.event_lock);
1920 fibril_condvar_initialize(&resp.event_cv);
1921 display_srv_ev_pending(resp.srv);
1922
1923 /* Wait for the event handler to be called. */
1924 fibril_mutex_lock(&resp.event_lock);
1925 while (!resp.unfocus_event_called) {
1926 fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
1927 }
1928 fibril_mutex_unlock(&resp.event_lock);
1929
1930 /* Verify that the event was delivered correctly */
1931 PCUT_ASSERT_INT_EQUALS(resp.event.etype,
1932 resp.revent.etype);
1933 PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus,
1934 resp.revent.ev.focus.nfocus);
1935
1936 rc = display_window_destroy(wnd);
1937 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1938
1939 display_close(disp);
1940
1941 rc = loc_service_unregister(sid);
1942 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1943}
1944
1945/** display_get_info() with server returning failure response works. */
1946PCUT_TEST(get_info_failure)
1947{
1948 errno_t rc;
1949 service_id_t sid;
1950 display_t *disp = NULL;
1951 display_info_t info;
1952 test_response_t resp;
1953
1954 async_set_fallback_port_handler(test_display_conn, &resp);
1955
1956 // FIXME This causes this test to be non-reentrant!
1957 rc = loc_server_register(test_display_server);
1958 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1959
1960 rc = loc_service_register(test_display_svc, &sid);
1961 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1962
1963 rc = display_open(test_display_svc, &disp);
1964 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1965 PCUT_ASSERT_NOT_NULL(disp);
1966
1967 resp.rc = ENOMEM;
1968 resp.get_info_called = false;
1969
1970 rc = display_get_info(disp, &info);
1971 PCUT_ASSERT_TRUE(resp.get_info_called);
1972 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
1973
1974 display_close(disp);
1975 rc = loc_service_unregister(sid);
1976 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1977}
1978
1979/** display_get_info() with server returning success response works. */
1980PCUT_TEST(get_info_success)
1981{
1982 errno_t rc;
1983 service_id_t sid;
1984 display_t *disp = NULL;
1985 display_info_t info;
1986 test_response_t resp;
1987
1988 async_set_fallback_port_handler(test_display_conn, &resp);
1989
1990 // FIXME This causes this test to be non-reentrant!
1991 rc = loc_server_register(test_display_server);
1992 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1993
1994 rc = loc_service_register(test_display_svc, &sid);
1995 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1996
1997 rc = display_open(test_display_svc, &disp);
1998 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1999 PCUT_ASSERT_NOT_NULL(disp);
2000
2001 resp.rc = EOK;
2002 resp.get_info_called = false;
2003 resp.get_info_rect.p0.x = 10;
2004 resp.get_info_rect.p0.y = 11;
2005 resp.get_info_rect.p1.x = 20;
2006 resp.get_info_rect.p1.y = 21;
2007
2008 rc = display_get_info(disp, &info);
2009 PCUT_ASSERT_TRUE(resp.get_info_called);
2010 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
2011 PCUT_ASSERT_INT_EQUALS(resp.get_info_rect.p0.x, info.rect.p0.x);
2012 PCUT_ASSERT_INT_EQUALS(resp.get_info_rect.p0.y, info.rect.p0.y);
2013 PCUT_ASSERT_INT_EQUALS(resp.get_info_rect.p1.x, info.rect.p1.x);
2014 PCUT_ASSERT_INT_EQUALS(resp.get_info_rect.p1.y, info.rect.p1.y);
2015
2016 display_close(disp);
2017 rc = loc_service_unregister(sid);
2018 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2019}
2020
2021/** Test display service connection.
2022 *
2023 * This is very similar to connection handler in the display server.
2024 * XXX This should be folded into display_srv, if possible
2025 */
2026static void test_display_conn(ipc_call_t *icall, void *arg)
2027{
2028 test_response_t *resp = (test_response_t *) arg;
2029 display_srv_t srv;
2030 sysarg_t wnd_id;
2031 sysarg_t svc_id;
2032 gfx_context_t *gc;
2033 errno_t rc;
2034
2035 svc_id = ipc_get_arg2(icall);
2036 wnd_id = ipc_get_arg3(icall);
2037
2038 if (svc_id != 0) {
2039 /* Set up protocol structure */
2040 display_srv_initialize(&srv);
2041 srv.ops = &test_display_srv_ops;
2042 srv.arg = arg;
2043 resp->srv = &srv;
2044
2045 /* Handle connection */
2046 display_conn(icall, &srv);
2047
2048 resp->srv = NULL;
2049 } else {
2050 (void) wnd_id;
2051
2052 if (resp->rc != EOK) {
2053 async_answer_0(icall, resp->rc);
2054 return;
2055 }
2056
2057 rc = gfx_context_new(&test_gc_ops, arg, &gc);
2058 if (rc != EOK) {
2059 async_answer_0(icall, ENOMEM);
2060 return;
2061 }
2062
2063 /* Window GC connection */
2064 gc_conn(icall, gc);
2065 }
2066}
2067
2068static void test_close_event(void *arg)
2069{
2070 test_response_t *resp = (test_response_t *) arg;
2071
2072 resp->revent.etype = wev_close;
2073
2074 fibril_mutex_lock(&resp->event_lock);
2075 resp->close_event_called = true;
2076 fibril_condvar_broadcast(&resp->event_cv);
2077 fibril_mutex_unlock(&resp->event_lock);
2078}
2079
2080static void test_focus_event(void *arg, unsigned nfocus)
2081{
2082 test_response_t *resp = (test_response_t *) arg;
2083
2084 resp->revent.etype = wev_focus;
2085 resp->revent.ev.focus.nfocus = nfocus;
2086
2087 fibril_mutex_lock(&resp->event_lock);
2088 resp->focus_event_called = true;
2089 fibril_condvar_broadcast(&resp->event_cv);
2090 fibril_mutex_unlock(&resp->event_lock);
2091}
2092
2093static void test_kbd_event(void *arg, kbd_event_t *event)
2094{
2095 test_response_t *resp = (test_response_t *) arg;
2096
2097 resp->revent.etype = wev_kbd;
2098 resp->revent.ev.kbd = *event;
2099
2100 fibril_mutex_lock(&resp->event_lock);
2101 resp->kbd_event_called = true;
2102 fibril_condvar_broadcast(&resp->event_cv);
2103 fibril_mutex_unlock(&resp->event_lock);
2104}
2105
2106static void test_pos_event(void *arg, pos_event_t *event)
2107{
2108 test_response_t *resp = (test_response_t *) arg;
2109
2110 resp->revent.etype = wev_pos;
2111 resp->revent.ev.pos = *event;
2112
2113 fibril_mutex_lock(&resp->event_lock);
2114 resp->pos_event_called = true;
2115 fibril_condvar_broadcast(&resp->event_cv);
2116 fibril_mutex_unlock(&resp->event_lock);
2117}
2118
2119static void test_unfocus_event(void *arg, unsigned nfocus)
2120{
2121 test_response_t *resp = (test_response_t *) arg;
2122
2123 resp->revent.etype = wev_unfocus;
2124 resp->revent.ev.unfocus.nfocus = nfocus;
2125
2126 fibril_mutex_lock(&resp->event_lock);
2127 resp->unfocus_event_called = true;
2128 fibril_condvar_broadcast(&resp->event_cv);
2129 fibril_mutex_unlock(&resp->event_lock);
2130}
2131
2132static errno_t test_window_create(void *arg, display_wnd_params_t *params,
2133 sysarg_t *rwnd_id)
2134{
2135 test_response_t *resp = (test_response_t *) arg;
2136
2137 resp->window_create_called = true;
2138 resp->create_rect = params->rect;
2139 resp->create_min_size = params->min_size;
2140 if (resp->rc == EOK)
2141 *rwnd_id = resp->wnd_id;
2142
2143 return resp->rc;
2144}
2145
2146static errno_t test_window_destroy(void *arg, sysarg_t wnd_id)
2147{
2148 test_response_t *resp = (test_response_t *) arg;
2149
2150 resp->window_destroy_called = true;
2151 resp->destroy_wnd_id = wnd_id;
2152 return resp->rc;
2153}
2154
2155static errno_t test_window_move_req(void *arg, sysarg_t wnd_id,
2156 gfx_coord2_t *pos, sysarg_t pos_id)
2157{
2158 test_response_t *resp = (test_response_t *) arg;
2159
2160 resp->window_move_req_called = true;
2161 resp->move_req_wnd_id = wnd_id;
2162 resp->move_req_pos = *pos;
2163 resp->move_req_pos_id = pos_id;
2164 return resp->rc;
2165}
2166
2167static errno_t test_window_move(void *arg, sysarg_t wnd_id, gfx_coord2_t *dpos)
2168{
2169 test_response_t *resp = (test_response_t *) arg;
2170
2171 resp->window_move_called = true;
2172 resp->move_wnd_id = wnd_id;
2173 resp->move_dpos = *dpos;
2174 return resp->rc;
2175}
2176
2177static errno_t test_window_get_pos(void *arg, sysarg_t wnd_id, gfx_coord2_t *dpos)
2178{
2179 test_response_t *resp = (test_response_t *) arg;
2180
2181 resp->window_get_pos_called = true;
2182 resp->get_pos_wnd_id = wnd_id;
2183
2184 if (resp->rc == EOK)
2185 *dpos = resp->get_pos_rpos;
2186
2187 return resp->rc;
2188}
2189
2190static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id,
2191 gfx_rect_t *rect)
2192{
2193 test_response_t *resp = (test_response_t *) arg;
2194
2195 resp->window_get_max_rect_called = true;
2196 resp->get_max_rect_wnd_id = wnd_id;
2197
2198 if (resp->rc == EOK)
2199 *rect = resp->get_max_rect_rrect;
2200
2201 return resp->rc;
2202}
2203
2204static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
2205 display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id)
2206{
2207 test_response_t *resp = (test_response_t *) arg;
2208
2209 resp->window_resize_req_called = true;
2210 resp->resize_req_rsztype = rsztype;
2211 resp->resize_req_wnd_id = wnd_id;
2212 resp->resize_req_pos = *pos;
2213 resp->resize_req_pos_id = pos_id;
2214 return resp->rc;
2215}
2216
2217static errno_t test_window_resize(void *arg, sysarg_t wnd_id,
2218 gfx_coord2_t *offs, gfx_rect_t *nrect)
2219{
2220 test_response_t *resp = (test_response_t *) arg;
2221
2222 resp->window_resize_called = true;
2223 resp->resize_wnd_id = wnd_id;
2224 resp->resize_offs = *offs;
2225 resp->resize_nbound = *nrect;
2226 return resp->rc;
2227}
2228
2229static errno_t test_window_minimize(void *arg, sysarg_t wnd_id)
2230{
2231 test_response_t *resp = (test_response_t *) arg;
2232
2233 resp->window_minimize_called = true;
2234 resp->resize_wnd_id = wnd_id;
2235 return resp->rc;
2236}
2237
2238static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
2239{
2240 test_response_t *resp = (test_response_t *) arg;
2241
2242 resp->window_maximize_called = true;
2243 resp->resize_wnd_id = wnd_id;
2244 return resp->rc;
2245}
2246
2247static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id)
2248{
2249 test_response_t *resp = (test_response_t *) arg;
2250
2251 resp->window_unmaximize_called = true;
2252 resp->resize_wnd_id = wnd_id;
2253 return resp->rc;
2254}
2255
2256static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id,
2257 display_stock_cursor_t cursor)
2258{
2259 test_response_t *resp = (test_response_t *) arg;
2260
2261 resp->window_set_cursor_called = true;
2262 resp->set_cursor_wnd_id = wnd_id;
2263 resp->set_cursor_cursor = cursor;
2264
2265 return resp->rc;
2266}
2267
2268static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id,
2269 const char *caption)
2270{
2271 test_response_t *resp = (test_response_t *) arg;
2272
2273 resp->window_set_caption_called = true;
2274 resp->set_caption_wnd_id = wnd_id;
2275 resp->set_caption_caption = str_dup(caption);
2276
2277 return resp->rc;
2278}
2279
2280static errno_t test_get_event(void *arg, sysarg_t *wnd_id,
2281 display_wnd_ev_t *event)
2282{
2283 test_response_t *resp = (test_response_t *) arg;
2284
2285 resp->get_event_called = true;
2286 if (resp->event_cnt > 0) {
2287 --resp->event_cnt;
2288 *wnd_id = resp->wnd_id;
2289 *event = resp->event;
2290 return EOK;
2291 }
2292
2293 return ENOENT;
2294}
2295
2296static errno_t test_get_info(void *arg, display_info_t *info)
2297{
2298 test_response_t *resp = (test_response_t *) arg;
2299
2300 resp->get_info_called = true;
2301 info->rect = resp->get_info_rect;
2302
2303 return resp->rc;
2304}
2305
2306static errno_t test_gc_set_color(void *arg, gfx_color_t *color)
2307{
2308 test_response_t *resp = (test_response_t *) arg;
2309
2310 resp->set_color_called = true;
2311 return resp->rc;
2312}
2313
2314PCUT_EXPORT(display);
Note: See TracBrowser for help on using the repository browser.