source: mainline/uspace/lib/display/test/display.c

Last change on this file was ca48672, checked in by Jiri Svoboda <jiri@…>, 8 days ago

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