source: mainline/uspace/lib/display/test/display.c@ 1c6c3e1d

ticket/834-toolchain-update
Last change on this file since 1c6c3e1d was 4c6fd56, checked in by Jiri Svoboda <jiri@…>, 22 months ago

loc_server_register() should be callable more than once (API only)

Now loc_server_register() returns a pointer to a loc_srv_t object,
that is then passed to loc_service_register() and
loc_service_add_to_cat().

Added loc_server_unregister() that unregisters the server
and frees the loc_srv_t object.

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