source: mainline/uspace/lib/ui/test/window.c@ 5ef85c0

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

Null display spec for the benefit of unit testing

When testing something that takes a display specification as argument,
it is useful to be able to be able to specify dummy output (so far,
only ui_create_disp() could create a UI with dummy output.
  • Property mode set to 100644
File size: 19.6 KB
Line 
1/*
2 * Copyright (c) 2021 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 <gfx/context.h>
30#include <gfx/coord.h>
31#include <gfx/render.h>
32#include <io/kbd_event.h>
33#include <io/pos_event.h>
34#include <mem.h>
35#include <pcut/pcut.h>
36#include <stdbool.h>
37#include <ui/control.h>
38#include <ui/resource.h>
39#include <ui/ui.h>
40#include <ui/window.h>
41#include "../private/window.h"
42
43PCUT_INIT;
44
45PCUT_TEST_SUITE(window);
46
47static void test_window_close(ui_window_t *, void *);
48static void test_window_focus(ui_window_t *, void *);
49static void test_window_kbd(ui_window_t *, void *, kbd_event_t *);
50static errno_t test_window_paint(ui_window_t *, void *);
51static void test_window_pos(ui_window_t *, void *, pos_event_t *);
52static void test_window_unfocus(ui_window_t *, void *);
53
54static ui_window_cb_t test_window_cb = {
55 .close = test_window_close,
56 .focus = test_window_focus,
57 .kbd = test_window_kbd,
58 .paint = test_window_paint,
59 .pos = test_window_pos,
60 .unfocus = test_window_unfocus
61};
62
63static ui_window_cb_t dummy_window_cb = {
64};
65
66static errno_t test_ctl_paint(void *);
67static ui_evclaim_t test_ctl_pos_event(void *, pos_event_t *);
68static void test_ctl_unfocus(void *);
69
70static ui_control_ops_t test_ctl_ops = {
71 .paint = test_ctl_paint,
72 .pos_event = test_ctl_pos_event,
73 .unfocus = test_ctl_unfocus
74};
75
76typedef struct {
77 errno_t rc;
78 bool close;
79 bool focus;
80 bool kbd;
81 kbd_event_t kbd_event;
82 bool paint;
83 bool pos;
84 pos_event_t pos_event;
85 bool unfocus;
86} test_cb_resp_t;
87
88typedef struct {
89 errno_t rc;
90 ui_evclaim_t claim;
91 bool paint;
92 bool pos;
93 pos_event_t pos_event;
94 bool unfocus;
95} test_ctl_resp_t;
96
97/** Create and destroy window */
98PCUT_TEST(create_destroy)
99{
100 errno_t rc;
101 ui_t *ui = NULL;
102 ui_wnd_params_t params;
103 ui_window_t *window = NULL;
104
105 rc = ui_create_disp(NULL, &ui);
106 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
107
108 ui_wnd_params_init(&params);
109 params.caption = "Hello";
110
111 rc = ui_window_create(ui, &params, &window);
112 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
113 PCUT_ASSERT_NOT_NULL(window);
114
115 ui_window_destroy(window);
116 ui_destroy(ui);
117}
118
119/** ui_window_destroy() can take NULL argument (no-op) */
120PCUT_TEST(destroy_null)
121{
122 ui_window_destroy(NULL);
123}
124
125/** ui_window_add()/ui_window_remove() ... */
126PCUT_TEST(add_remove)
127{
128 errno_t rc;
129 ui_t *ui = NULL;
130 ui_wnd_params_t params;
131 ui_window_t *window = NULL;
132 ui_control_t *control = NULL;
133 test_ctl_resp_t resp;
134
135 rc = ui_create_disp(NULL, &ui);
136 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
137
138 ui_wnd_params_init(&params);
139 params.caption = "Hello";
140
141 rc = ui_window_create(ui, &params, &window);
142 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
143 PCUT_ASSERT_NOT_NULL(window);
144
145 rc = ui_control_new(&test_ctl_ops, &resp, &control);
146 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
147
148 /* Control not called since it hasn't been added yet */
149 resp.rc = ENOMEM;
150 resp.paint = false;
151 rc = ui_window_def_paint(window);
152 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
153 PCUT_ASSERT_FALSE(resp.paint);
154
155 ui_window_add(window, control);
156
157 /* Now paint request should be delivered to control */
158 resp.rc = EOK;
159 resp.paint = false;
160 rc = ui_window_def_paint(window);
161 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
162 PCUT_ASSERT_TRUE(resp.paint);
163
164 ui_window_remove(window, control);
165
166 /*
167 * After having removed the control the request should no longer
168 * be delivered to it.
169 */
170 resp.rc = ENOMEM;
171 resp.paint = false;
172 rc = ui_window_def_paint(window);
173 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
174 PCUT_ASSERT_FALSE(resp.paint);
175
176 ui_window_destroy(window);
177 ui_destroy(ui);
178}
179
180/** ui_window_get_active */
181PCUT_TEST(get_active)
182{
183 errno_t rc;
184 ui_t *ui = NULL;
185 ui_wnd_params_t params;
186 ui_window_t *window1 = NULL;
187 ui_window_t *window2 = NULL;
188 ui_window_t *awnd;
189
190 rc = ui_create_cons(NULL, &ui);
191 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
192
193 awnd = ui_window_get_active(ui);
194 PCUT_ASSERT_NULL(awnd);
195
196 ui_wnd_params_init(&params);
197 params.caption = "Hello";
198
199 rc = ui_window_create(ui, &params, &window1);
200 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
201 PCUT_ASSERT_NOT_NULL(window1);
202
203 awnd = ui_window_get_active(ui);
204 PCUT_ASSERT_EQUALS(window1, awnd);
205
206 rc = ui_window_create(ui, &params, &window2);
207 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
208 PCUT_ASSERT_NOT_NULL(window2);
209
210 awnd = ui_window_get_active(ui);
211 PCUT_ASSERT_EQUALS(window2, awnd);
212
213 ui_window_destroy(window2);
214
215 awnd = ui_window_get_active(ui);
216 PCUT_ASSERT_EQUALS(window1, awnd);
217
218 ui_window_destroy(window1);
219
220 awnd = ui_window_get_active(ui);
221 PCUT_ASSERT_NULL(awnd);
222
223 ui_destroy(ui);
224}
225
226/** ui_window_resize */
227PCUT_TEST(resize)
228{
229 errno_t rc;
230 ui_t *ui = NULL;
231 ui_wnd_params_t params;
232 ui_window_t *window = NULL;
233 gfx_rect_t nrect;
234
235 rc = ui_create_disp(NULL, &ui);
236 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
237
238 ui_wnd_params_init(&params);
239 params.caption = "Hello";
240 params.rect.p0.x = 0;
241 params.rect.p0.y = 0;
242 params.rect.p1.x = 1;
243 params.rect.p1.y = 1;
244
245 rc = ui_window_create(ui, &params, &window);
246 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
247 PCUT_ASSERT_NOT_NULL(window);
248
249 nrect.p0.x = -1;
250 nrect.p0.y = -1;
251 nrect.p1.x = 2;
252 nrect.p1.y = 2;
253 rc = ui_window_resize(window, &nrect);
254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
255
256 ui_window_destroy(window);
257 ui_destroy(ui);
258}
259
260/** ui_window_get_ui() returns containing UI */
261PCUT_TEST(get_ui)
262{
263 errno_t rc;
264 ui_t *ui = NULL;
265 ui_t *rui;
266 ui_wnd_params_t params;
267 ui_window_t *window = NULL;
268
269 rc = ui_create_disp(NULL, &ui);
270 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
271
272 ui_wnd_params_init(&params);
273 params.caption = "Hello";
274
275 rc = ui_window_create(ui, &params, &window);
276 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
277 PCUT_ASSERT_NOT_NULL(window);
278
279 rui = ui_window_get_ui(window);
280 PCUT_ASSERT_EQUALS(ui, rui);
281
282 ui_window_destroy(window);
283 ui_destroy(ui);
284}
285
286/** ui_window_get_res/gc/rect() return valid objects */
287PCUT_TEST(get_res_gc_rect)
288{
289 errno_t rc;
290 ui_t *ui = NULL;
291 ui_wnd_params_t params;
292 ui_window_t *window = NULL;
293 ui_resource_t *res;
294 gfx_context_t *gc;
295 gfx_rect_t rect;
296
297 rc = ui_create_disp(NULL, &ui);
298 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
299
300 ui_wnd_params_init(&params);
301 params.caption = "Hello";
302
303 rc = ui_window_create(ui, &params, &window);
304 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
305 PCUT_ASSERT_NOT_NULL(window);
306
307 res = ui_window_get_res(window);
308 PCUT_ASSERT_NOT_NULL(res);
309
310 gc = ui_window_get_gc(window);
311 PCUT_ASSERT_NOT_NULL(gc);
312
313 ui_window_get_app_rect(window, &rect);
314
315 ui_window_destroy(window);
316 ui_destroy(ui);
317}
318
319/** ui_window_set_ctl_cursor() */
320PCUT_TEST(set_ctl_cursor)
321{
322 errno_t rc;
323 ui_t *ui = NULL;
324 ui_wnd_params_t params;
325 ui_window_t *window = NULL;
326
327 rc = ui_create_disp(NULL, &ui);
328 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
329
330 ui_wnd_params_init(&params);
331 params.caption = "Hello";
332
333 rc = ui_window_create(ui, &params, &window);
334 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
335 PCUT_ASSERT_NOT_NULL(window);
336
337 ui_window_set_ctl_cursor(window, ui_curs_ibeam);
338
339 ui_window_destroy(window);
340 ui_destroy(ui);
341}
342
343/** ui_window_get_app_gc() return valid GC */
344PCUT_TEST(get_app_gc)
345{
346 errno_t rc;
347 ui_t *ui = NULL;
348 ui_wnd_params_t params;
349 ui_window_t *window = NULL;
350 gfx_context_t *gc;
351
352 rc = ui_create_disp(NULL, &ui);
353 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
354
355 ui_wnd_params_init(&params);
356 params.caption = "Hello";
357 params.rect.p0.x = 0;
358 params.rect.p0.y = 0;
359 params.rect.p0.x = 100;
360 params.rect.p0.y = 100;
361
362 rc = ui_window_create(ui, &params, &window);
363 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
364 PCUT_ASSERT_NOT_NULL(window);
365
366 rc = ui_window_get_app_gc(window, &gc);
367 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
368 PCUT_ASSERT_NOT_NULL(gc);
369
370 rc = gfx_fill_rect(gc, &params.rect);
371 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
372
373 ui_window_destroy(window);
374 ui_destroy(ui);
375}
376
377/** Test ui_window_paint() */
378PCUT_TEST(paint)
379{
380 errno_t rc;
381 ui_t *ui = NULL;
382 ui_wnd_params_t params;
383 ui_window_t *window = NULL;
384
385 rc = ui_create_disp(NULL, &ui);
386 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
387
388 ui_wnd_params_init(&params);
389 params.caption = "Hello";
390
391 rc = ui_window_create(ui, &params, &window);
392 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
393 PCUT_ASSERT_NOT_NULL(window);
394
395 ui_window_paint(window);
396
397 ui_window_destroy(window);
398 ui_destroy(ui);
399}
400
401/** Test ui_window_def_paint() */
402PCUT_TEST(def_paint)
403{
404 errno_t rc;
405 ui_t *ui = NULL;
406 ui_wnd_params_t params;
407 ui_window_t *window = NULL;
408 ui_control_t *control = NULL;
409 test_ctl_resp_t resp;
410
411 rc = ui_create_disp(NULL, &ui);
412 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
413
414 ui_wnd_params_init(&params);
415 params.caption = "Hello";
416
417 rc = ui_window_create(ui, &params, &window);
418 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
419 PCUT_ASSERT_NOT_NULL(window);
420
421 rc = ui_control_new(&test_ctl_ops, &resp, &control);
422 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
423
424 ui_window_add(window, control);
425
426 resp.rc = EOK;
427 resp.paint = false;
428 rc = ui_window_def_paint(window);
429 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
430 PCUT_ASSERT_TRUE(resp.paint);
431
432 resp.rc = ENOMEM;
433 resp.paint = false;
434 rc = ui_window_def_paint(window);
435 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
436 PCUT_ASSERT_TRUE(resp.paint);
437
438 PCUT_ASSERT_TRUE(resp.paint);
439
440 /* Need to remove first because we didn't implement the destructor */
441 ui_window_remove(window, control);
442
443 ui_window_destroy(window);
444 ui_destroy(ui);
445}
446
447/** ui_window_def_pos() delivers position event to control in window */
448PCUT_TEST(def_pos)
449{
450 errno_t rc;
451 ui_t *ui = NULL;
452 ui_wnd_params_t params;
453 ui_window_t *window = NULL;
454 ui_control_t *control = NULL;
455 test_ctl_resp_t resp;
456 pos_event_t event;
457
458 rc = ui_create_disp(NULL, &ui);
459 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
460
461 ui_wnd_params_init(&params);
462 params.caption = "Hello";
463
464 rc = ui_window_create(ui, &params, &window);
465 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
466
467 rc = ui_control_new(&test_ctl_ops, &resp, &control);
468 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
469
470 ui_window_add(window, control);
471
472 event.pos_id = 1;
473 event.type = POS_PRESS;
474 event.btn_num = 2;
475 event.hpos = 3;
476 event.vpos = 4;
477
478 resp.pos = false;
479 resp.claim = ui_claimed;
480
481 ui_window_def_pos(window, &event);
482
483 PCUT_ASSERT_TRUE(resp.pos);
484 PCUT_ASSERT_INT_EQUALS(event.pos_id, resp.pos_event.pos_id);
485 PCUT_ASSERT_INT_EQUALS(event.type, resp.pos_event.type);
486 PCUT_ASSERT_INT_EQUALS(event.btn_num, resp.pos_event.btn_num);
487 PCUT_ASSERT_INT_EQUALS(event.hpos, resp.pos_event.hpos);
488 PCUT_ASSERT_INT_EQUALS(event.vpos, resp.pos_event.vpos);
489
490 /* Need to remove first because we didn't implement the destructor */
491 ui_window_remove(window, control);
492
493 ui_window_destroy(window);
494 ui_destroy(ui);
495}
496
497/** ui_window_def_unfocus() delivers unfocus event to control in window */
498PCUT_TEST(def_unfocus)
499{
500 errno_t rc;
501 ui_t *ui = NULL;
502 ui_wnd_params_t params;
503 ui_window_t *window = NULL;
504 ui_control_t *control = NULL;
505 test_ctl_resp_t resp;
506
507 rc = ui_create_disp(NULL, &ui);
508 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
509
510 ui_wnd_params_init(&params);
511 params.caption = "Hello";
512
513 rc = ui_window_create(ui, &params, &window);
514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
515
516 rc = ui_control_new(&test_ctl_ops, &resp, &control);
517 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
518
519 ui_window_add(window, control);
520
521 resp.unfocus = false;
522
523 ui_window_def_unfocus(window);
524 PCUT_ASSERT_TRUE(resp.unfocus);
525
526 /* Need to remove first because we didn't implement the destructor */
527 ui_window_remove(window, control);
528
529 ui_window_destroy(window);
530 ui_destroy(ui);
531}
532
533/** ui_window_send_close() calls close callback set via ui_window_set_cb() */
534PCUT_TEST(send_close)
535{
536 errno_t rc;
537 ui_t *ui = NULL;
538 ui_wnd_params_t params;
539 ui_window_t *window = NULL;
540 test_cb_resp_t resp;
541
542 rc = ui_create_disp(NULL, &ui);
543 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
544
545 ui_wnd_params_init(&params);
546 params.caption = "Hello";
547
548 rc = ui_window_create(ui, &params, &window);
549 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
550 PCUT_ASSERT_NOT_NULL(window);
551
552 /* Close callback with no callbacks set */
553 ui_window_send_close(window);
554
555 /* Close callback with close callback not implemented */
556 ui_window_set_cb(window, &dummy_window_cb, NULL);
557 ui_window_send_close(window);
558
559 /* Close callback with real callback set */
560 resp.close = false;
561 ui_window_set_cb(window, &test_window_cb, &resp);
562 ui_window_send_close(window);
563 PCUT_ASSERT_TRUE(resp.close);
564
565 ui_window_destroy(window);
566 ui_destroy(ui);
567}
568
569/** ui_window_send_focus() calls focus callback set via ui_window_set_cb() */
570PCUT_TEST(send_focus)
571{
572 errno_t rc;
573 ui_t *ui = NULL;
574 ui_wnd_params_t params;
575 ui_window_t *window = NULL;
576 test_cb_resp_t resp;
577
578 rc = ui_create_disp(NULL, &ui);
579 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
580
581 ui_wnd_params_init(&params);
582 params.caption = "Hello";
583
584 rc = ui_window_create(ui, &params, &window);
585 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
586 PCUT_ASSERT_NOT_NULL(window);
587
588 /* Focus callback with no callbacks set */
589 ui_window_send_focus(window);
590
591 /* Focus callback with focus callback not implemented */
592 ui_window_set_cb(window, &dummy_window_cb, NULL);
593 ui_window_send_focus(window);
594
595 /* Focus callback with real callback set */
596 resp.focus = false;
597 ui_window_set_cb(window, &test_window_cb, &resp);
598 ui_window_send_focus(window);
599 PCUT_ASSERT_TRUE(resp.focus);
600
601 ui_window_destroy(window);
602 ui_destroy(ui);
603}
604
605/** ui_window_send_kbd() calls kbd callback set via ui_window_set_cb() */
606PCUT_TEST(send_kbd)
607{
608 errno_t rc;
609 ui_t *ui = NULL;
610 ui_wnd_params_t params;
611 ui_window_t *window = NULL;
612 kbd_event_t kbd_event;
613 test_cb_resp_t resp;
614
615 rc = ui_create_disp(NULL, &ui);
616 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
617
618 ui_wnd_params_init(&params);
619 params.caption = "Hello";
620
621 rc = ui_window_create(ui, &params, &window);
622 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
623 PCUT_ASSERT_NOT_NULL(window);
624
625 kbd_event.type = POS_PRESS;
626 kbd_event.key = KC_X;
627 kbd_event.mods = 0;
628 kbd_event.c = 'x';
629
630 /* Kbd callback with no callbacks set */
631 ui_window_send_kbd(window, &kbd_event);
632
633 /* Kbd callback with kbd callback not implemented */
634 ui_window_set_cb(window, &dummy_window_cb, NULL);
635 ui_window_send_kbd(window, &kbd_event);
636
637 /* Kbd callback with real callback set */
638 resp.kbd = false;
639 ui_window_set_cb(window, &test_window_cb, &resp);
640 ui_window_send_kbd(window, &kbd_event);
641 PCUT_ASSERT_TRUE(resp.kbd);
642 PCUT_ASSERT_EQUALS(kbd_event.type, resp.kbd_event.type);
643 PCUT_ASSERT_INT_EQUALS(kbd_event.key, resp.kbd_event.key);
644 PCUT_ASSERT_INT_EQUALS(kbd_event.mods, resp.kbd_event.mods);
645 PCUT_ASSERT_INT_EQUALS(kbd_event.c, resp.kbd_event.c);
646
647 ui_window_destroy(window);
648 ui_destroy(ui);
649}
650
651/** ui_window_send_paint() calls paint callback set via ui_window_set_cb() */
652PCUT_TEST(send_paint)
653{
654 errno_t rc;
655 ui_t *ui = NULL;
656 ui_wnd_params_t params;
657 ui_window_t *window = NULL;
658 test_cb_resp_t resp;
659
660 rc = ui_create_disp(NULL, &ui);
661 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
662
663 ui_wnd_params_init(&params);
664 params.caption = "Hello";
665
666 rc = ui_window_create(ui, &params, &window);
667 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
668 PCUT_ASSERT_NOT_NULL(window);
669
670 /* Paint callback with no callbacks set */
671 ui_window_send_paint(window);
672
673 /* Paint callback with paint callback not implemented */
674 ui_window_set_cb(window, &dummy_window_cb, NULL);
675 ui_window_send_paint(window);
676
677 /* Paint callback with real callback set */
678 resp.paint = false;
679 resp.rc = EOK;
680 ui_window_set_cb(window, &test_window_cb, &resp);
681 rc = ui_window_send_paint(window);
682 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
683 PCUT_ASSERT_TRUE(resp.paint);
684
685 ui_window_destroy(window);
686 ui_destroy(ui);
687}
688
689/** ui_window_send_pos() calls pos callback set via ui_window_set_cb() */
690PCUT_TEST(send_pos)
691{
692 errno_t rc;
693 ui_t *ui = NULL;
694 ui_wnd_params_t params;
695 ui_window_t *window = NULL;
696 pos_event_t pos_event;
697 test_cb_resp_t resp;
698
699 rc = ui_create_disp(NULL, &ui);
700 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
701
702 ui_wnd_params_init(&params);
703 params.caption = "Hello";
704
705 rc = ui_window_create(ui, &params, &window);
706 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
707 PCUT_ASSERT_NOT_NULL(window);
708
709 pos_event.pos_id = 1;
710 pos_event.type = POS_PRESS;
711 pos_event.btn_num = 2;
712 pos_event.hpos = 3;
713 pos_event.vpos = 4;
714
715 /* Pos callback with no callbacks set */
716 ui_window_send_pos(window, &pos_event);
717
718 /* Pos callback with pos callback not implemented */
719 ui_window_set_cb(window, &dummy_window_cb, NULL);
720 ui_window_send_pos(window, &pos_event);
721
722 /* Pos callback with real callback set */
723 resp.pos = false;
724 ui_window_set_cb(window, &test_window_cb, &resp);
725 ui_window_send_pos(window, &pos_event);
726 PCUT_ASSERT_TRUE(resp.pos);
727 PCUT_ASSERT_INT_EQUALS(pos_event.pos_id, resp.pos_event.pos_id);
728 PCUT_ASSERT_EQUALS(pos_event.type, resp.pos_event.type);
729 PCUT_ASSERT_INT_EQUALS(pos_event.btn_num, resp.pos_event.btn_num);
730 PCUT_ASSERT_INT_EQUALS(pos_event.hpos, resp.pos_event.hpos);
731 PCUT_ASSERT_INT_EQUALS(pos_event.vpos, resp.pos_event.vpos);
732
733 ui_window_destroy(window);
734 ui_destroy(ui);
735}
736
737/** ui_window_send_unfocus() calls unfocus callback set via ui_window_set_cb() */
738PCUT_TEST(send_unfocus)
739{
740 errno_t rc;
741 ui_t *ui = NULL;
742 ui_wnd_params_t params;
743 ui_window_t *window = NULL;
744 test_cb_resp_t resp;
745
746 rc = ui_create_disp(NULL, &ui);
747 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
748
749 ui_wnd_params_init(&params);
750 params.caption = "Hello";
751
752 rc = ui_window_create(ui, &params, &window);
753 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
754 PCUT_ASSERT_NOT_NULL(window);
755
756 /* Unfocus callback with no callbacks set */
757 ui_window_send_unfocus(window);
758
759 /* Unfocus callback with unfocus callback not implemented */
760 ui_window_set_cb(window, &dummy_window_cb, NULL);
761 ui_window_send_unfocus(window);
762
763 /* Unfocus callback with real callback set */
764 resp.close = false;
765 ui_window_set_cb(window, &test_window_cb, &resp);
766 ui_window_send_unfocus(window);
767 PCUT_ASSERT_TRUE(resp.unfocus);
768
769 ui_window_destroy(window);
770 ui_destroy(ui);
771}
772
773static void test_window_close(ui_window_t *window, void *arg)
774{
775 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
776
777 resp->close = true;
778}
779
780static void test_window_focus(ui_window_t *window, void *arg)
781{
782 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
783
784 resp->focus = true;
785}
786
787static void test_window_kbd(ui_window_t *window, void *arg,
788 kbd_event_t *event)
789{
790 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
791
792 resp->kbd = true;
793 resp->kbd_event = *event;
794}
795
796static errno_t test_window_paint(ui_window_t *window, void *arg)
797{
798 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
799
800 resp->paint = true;
801 return resp->rc;
802}
803
804static void test_window_pos(ui_window_t *window, void *arg,
805 pos_event_t *event)
806{
807 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
808
809 resp->pos = true;
810 resp->pos_event = *event;
811}
812
813static void test_window_unfocus(ui_window_t *window, void *arg)
814{
815 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
816
817 resp->unfocus = true;
818}
819
820static errno_t test_ctl_paint(void *arg)
821{
822 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
823
824 resp->paint = true;
825 return resp->rc;
826}
827
828static ui_evclaim_t test_ctl_pos_event(void *arg, pos_event_t *event)
829{
830 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
831
832 resp->pos = true;
833 resp->pos_event = *event;
834
835 return resp->claim;
836}
837
838static void test_ctl_unfocus(void *arg)
839{
840 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
841
842 resp->unfocus = true;
843}
844
845PCUT_EXPORT(window);
Note: See TracBrowser for help on using the repository browser.