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

topic/simplify-dev-export
Last change on this file since ef4d684 was 09b01ed0, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 2 years ago

Use keyboard, not mouse enum
  • Property mode set to 100644
File size: 24.8 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 <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_sysmenu(ui_window_t *, void *, sysarg_t);
48static void test_window_minimize(ui_window_t *, void *);
49static void test_window_maximize(ui_window_t *, void *);
50static void test_window_unmaximize(ui_window_t *, void *);
51static void test_window_close(ui_window_t *, void *);
52static void test_window_focus(ui_window_t *, void *, unsigned);
53static void test_window_kbd(ui_window_t *, void *, kbd_event_t *);
54static errno_t test_window_paint(ui_window_t *, void *);
55static void test_window_pos(ui_window_t *, void *, pos_event_t *);
56static void test_window_unfocus(ui_window_t *, void *, unsigned);
57
58static ui_window_cb_t test_window_cb = {
59 .sysmenu = test_window_sysmenu,
60 .minimize = test_window_minimize,
61 .maximize = test_window_maximize,
62 .unmaximize = test_window_unmaximize,
63 .close = test_window_close,
64 .focus = test_window_focus,
65 .kbd = test_window_kbd,
66 .paint = test_window_paint,
67 .pos = test_window_pos,
68 .unfocus = test_window_unfocus
69};
70
71static ui_window_cb_t dummy_window_cb = {
72};
73
74static errno_t test_ctl_paint(void *);
75static ui_evclaim_t test_ctl_pos_event(void *, pos_event_t *);
76static void test_ctl_unfocus(void *, unsigned);
77
78static ui_control_ops_t test_ctl_ops = {
79 .paint = test_ctl_paint,
80 .pos_event = test_ctl_pos_event,
81 .unfocus = test_ctl_unfocus
82};
83
84typedef struct {
85 errno_t rc;
86 bool sysmenu;
87 sysarg_t sysmenu_idev_id;
88 bool minimize;
89 bool maximize;
90 bool unmaximize;
91 bool close;
92 bool focus;
93 unsigned focus_nfocus;
94 bool kbd;
95 kbd_event_t kbd_event;
96 bool paint;
97 bool pos;
98 pos_event_t pos_event;
99 bool unfocus;
100 unsigned unfocus_nfocus;
101} test_cb_resp_t;
102
103typedef struct {
104 errno_t rc;
105 ui_evclaim_t claim;
106 bool paint;
107 bool pos;
108 pos_event_t pos_event;
109 bool unfocus;
110 unsigned unfocus_nfocus;
111} test_ctl_resp_t;
112
113/** Create and destroy window */
114PCUT_TEST(create_destroy)
115{
116 errno_t rc;
117 ui_t *ui = NULL;
118 ui_wnd_params_t params;
119 ui_window_t *window = NULL;
120
121 rc = ui_create_disp(NULL, &ui);
122 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
123
124 ui_wnd_params_init(&params);
125 params.caption = "Hello";
126
127 rc = ui_window_create(ui, &params, &window);
128 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
129 PCUT_ASSERT_NOT_NULL(window);
130
131 ui_window_destroy(window);
132 ui_destroy(ui);
133}
134
135/** ui_window_destroy() can take NULL argument (no-op) */
136PCUT_TEST(destroy_null)
137{
138 ui_window_destroy(NULL);
139}
140
141/** ui_window_add()/ui_window_remove() ... */
142PCUT_TEST(add_remove)
143{
144 errno_t rc;
145 ui_t *ui = NULL;
146 ui_wnd_params_t params;
147 ui_window_t *window = NULL;
148 ui_control_t *control = NULL;
149 test_ctl_resp_t resp;
150
151 rc = ui_create_disp(NULL, &ui);
152 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
153
154 ui_wnd_params_init(&params);
155 params.caption = "Hello";
156
157 rc = ui_window_create(ui, &params, &window);
158 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
159 PCUT_ASSERT_NOT_NULL(window);
160
161 rc = ui_control_new(&test_ctl_ops, &resp, &control);
162 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
163
164 /* Control not called since it hasn't been added yet */
165 resp.rc = ENOMEM;
166 resp.paint = false;
167 rc = ui_window_def_paint(window);
168 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
169 PCUT_ASSERT_FALSE(resp.paint);
170
171 ui_window_add(window, control);
172
173 /* Now paint request should be delivered to control */
174 resp.rc = EOK;
175 resp.paint = false;
176 rc = ui_window_def_paint(window);
177 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
178 PCUT_ASSERT_TRUE(resp.paint);
179
180 ui_window_remove(window, control);
181
182 /*
183 * After having removed the control the request should no longer
184 * be delivered to it.
185 */
186 resp.rc = ENOMEM;
187 resp.paint = false;
188 rc = ui_window_def_paint(window);
189 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
190 PCUT_ASSERT_FALSE(resp.paint);
191
192 ui_window_destroy(window);
193 ui_destroy(ui);
194}
195
196/** ui_window_get_active */
197PCUT_TEST(get_active)
198{
199 errno_t rc;
200 ui_t *ui = NULL;
201 ui_wnd_params_t params;
202 ui_window_t *window1 = NULL;
203 ui_window_t *window2 = NULL;
204 ui_window_t *awnd;
205
206 rc = ui_create_cons(NULL, &ui);
207 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
208
209 awnd = ui_window_get_active(ui);
210 PCUT_ASSERT_NULL(awnd);
211
212 ui_wnd_params_init(&params);
213 params.caption = "Hello";
214
215 rc = ui_window_create(ui, &params, &window1);
216 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
217 PCUT_ASSERT_NOT_NULL(window1);
218
219 awnd = ui_window_get_active(ui);
220 PCUT_ASSERT_EQUALS(window1, awnd);
221
222 rc = ui_window_create(ui, &params, &window2);
223 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
224 PCUT_ASSERT_NOT_NULL(window2);
225
226 awnd = ui_window_get_active(ui);
227 PCUT_ASSERT_EQUALS(window2, awnd);
228
229 ui_window_destroy(window2);
230
231 awnd = ui_window_get_active(ui);
232 PCUT_ASSERT_EQUALS(window1, awnd);
233
234 ui_window_destroy(window1);
235
236 awnd = ui_window_get_active(ui);
237 PCUT_ASSERT_NULL(awnd);
238
239 ui_destroy(ui);
240}
241
242/** ui_window_resize */
243PCUT_TEST(resize)
244{
245 errno_t rc;
246 ui_t *ui = NULL;
247 ui_wnd_params_t params;
248 ui_window_t *window = NULL;
249 gfx_rect_t nrect;
250
251 rc = ui_create_disp(NULL, &ui);
252 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
253
254 ui_wnd_params_init(&params);
255 params.caption = "Hello";
256 params.rect.p0.x = 0;
257 params.rect.p0.y = 0;
258 params.rect.p1.x = 1;
259 params.rect.p1.y = 1;
260
261 rc = ui_window_create(ui, &params, &window);
262 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
263 PCUT_ASSERT_NOT_NULL(window);
264
265 nrect.p0.x = -1;
266 nrect.p0.y = -1;
267 nrect.p1.x = 2;
268 nrect.p1.y = 2;
269 rc = ui_window_resize(window, &nrect);
270 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
271
272 ui_window_destroy(window);
273 ui_destroy(ui);
274}
275
276/** ui_window_get_ui() returns containing UI */
277PCUT_TEST(get_ui)
278{
279 errno_t rc;
280 ui_t *ui = NULL;
281 ui_t *rui;
282 ui_wnd_params_t params;
283 ui_window_t *window = NULL;
284
285 rc = ui_create_disp(NULL, &ui);
286 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
287
288 ui_wnd_params_init(&params);
289 params.caption = "Hello";
290
291 rc = ui_window_create(ui, &params, &window);
292 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
293 PCUT_ASSERT_NOT_NULL(window);
294
295 rui = ui_window_get_ui(window);
296 PCUT_ASSERT_EQUALS(ui, rui);
297
298 ui_window_destroy(window);
299 ui_destroy(ui);
300}
301
302/** ui_window_get_res/gc/rect() return valid objects */
303PCUT_TEST(get_res_gc_rect)
304{
305 errno_t rc;
306 ui_t *ui = NULL;
307 ui_wnd_params_t params;
308 ui_window_t *window = NULL;
309 ui_resource_t *res;
310 gfx_context_t *gc;
311 gfx_rect_t rect;
312
313 rc = ui_create_disp(NULL, &ui);
314 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
315
316 ui_wnd_params_init(&params);
317 params.caption = "Hello";
318
319 rc = ui_window_create(ui, &params, &window);
320 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
321 PCUT_ASSERT_NOT_NULL(window);
322
323 res = ui_window_get_res(window);
324 PCUT_ASSERT_NOT_NULL(res);
325
326 gc = ui_window_get_gc(window);
327 PCUT_ASSERT_NOT_NULL(gc);
328
329 ui_window_get_app_rect(window, &rect);
330
331 ui_window_destroy(window);
332 ui_destroy(ui);
333}
334
335/** ui_window_set_ctl_cursor() */
336PCUT_TEST(set_ctl_cursor)
337{
338 errno_t rc;
339 ui_t *ui = NULL;
340 ui_wnd_params_t params;
341 ui_window_t *window = NULL;
342
343 rc = ui_create_disp(NULL, &ui);
344 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
345
346 ui_wnd_params_init(&params);
347 params.caption = "Hello";
348
349 rc = ui_window_create(ui, &params, &window);
350 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
351 PCUT_ASSERT_NOT_NULL(window);
352
353 ui_window_set_ctl_cursor(window, ui_curs_ibeam);
354
355 ui_window_destroy(window);
356 ui_destroy(ui);
357}
358
359/** ui_window_get_app_gc() return valid GC */
360PCUT_TEST(get_app_gc)
361{
362 errno_t rc;
363 ui_t *ui = NULL;
364 ui_wnd_params_t params;
365 ui_window_t *window = NULL;
366 gfx_context_t *gc;
367
368 rc = ui_create_disp(NULL, &ui);
369 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
370
371 ui_wnd_params_init(&params);
372 params.caption = "Hello";
373 params.rect.p0.x = 0;
374 params.rect.p0.y = 0;
375 params.rect.p0.x = 100;
376 params.rect.p0.y = 100;
377
378 rc = ui_window_create(ui, &params, &window);
379 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
380 PCUT_ASSERT_NOT_NULL(window);
381
382 rc = ui_window_get_app_gc(window, &gc);
383 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
384 PCUT_ASSERT_NOT_NULL(gc);
385
386 rc = gfx_fill_rect(gc, &params.rect);
387 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
388
389 ui_window_destroy(window);
390 ui_destroy(ui);
391}
392
393/** Test ui_window_paint() */
394PCUT_TEST(paint)
395{
396 errno_t rc;
397 ui_t *ui = NULL;
398 ui_wnd_params_t params;
399 ui_window_t *window = NULL;
400
401 rc = ui_create_disp(NULL, &ui);
402 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
403
404 ui_wnd_params_init(&params);
405 params.caption = "Hello";
406
407 rc = ui_window_create(ui, &params, &window);
408 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
409 PCUT_ASSERT_NOT_NULL(window);
410
411 ui_window_paint(window);
412
413 ui_window_destroy(window);
414 ui_destroy(ui);
415}
416
417/** Test ui_window_def_paint() */
418PCUT_TEST(def_paint)
419{
420 errno_t rc;
421 ui_t *ui = NULL;
422 ui_wnd_params_t params;
423 ui_window_t *window = NULL;
424 ui_control_t *control = NULL;
425 test_ctl_resp_t resp;
426
427 rc = ui_create_disp(NULL, &ui);
428 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
429
430 ui_wnd_params_init(&params);
431 params.caption = "Hello";
432
433 rc = ui_window_create(ui, &params, &window);
434 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
435 PCUT_ASSERT_NOT_NULL(window);
436
437 rc = ui_control_new(&test_ctl_ops, &resp, &control);
438 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
439
440 ui_window_add(window, control);
441
442 resp.rc = EOK;
443 resp.paint = false;
444 rc = ui_window_def_paint(window);
445 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
446 PCUT_ASSERT_TRUE(resp.paint);
447
448 resp.rc = ENOMEM;
449 resp.paint = false;
450 rc = ui_window_def_paint(window);
451 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
452 PCUT_ASSERT_TRUE(resp.paint);
453
454 PCUT_ASSERT_TRUE(resp.paint);
455
456 /* Need to remove first because we didn't implement the destructor */
457 ui_window_remove(window, control);
458
459 ui_window_destroy(window);
460 ui_destroy(ui);
461}
462
463/** ui_window_def_pos() delivers position event to control in window */
464PCUT_TEST(def_pos)
465{
466 errno_t rc;
467 ui_t *ui = NULL;
468 ui_wnd_params_t params;
469 ui_window_t *window = NULL;
470 ui_control_t *control = NULL;
471 test_ctl_resp_t resp;
472 pos_event_t event;
473
474 rc = ui_create_disp(NULL, &ui);
475 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
476
477 ui_wnd_params_init(&params);
478 params.caption = "Hello";
479
480 rc = ui_window_create(ui, &params, &window);
481 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
482
483 rc = ui_control_new(&test_ctl_ops, &resp, &control);
484 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
485
486 ui_window_add(window, control);
487
488 event.pos_id = 1;
489 event.type = POS_PRESS;
490 event.btn_num = 2;
491 event.hpos = 3;
492 event.vpos = 4;
493
494 resp.pos = false;
495 resp.claim = ui_claimed;
496
497 ui_window_def_pos(window, &event);
498
499 PCUT_ASSERT_TRUE(resp.pos);
500 PCUT_ASSERT_INT_EQUALS(event.pos_id, resp.pos_event.pos_id);
501 PCUT_ASSERT_INT_EQUALS(event.type, resp.pos_event.type);
502 PCUT_ASSERT_INT_EQUALS(event.btn_num, resp.pos_event.btn_num);
503 PCUT_ASSERT_INT_EQUALS(event.hpos, resp.pos_event.hpos);
504 PCUT_ASSERT_INT_EQUALS(event.vpos, resp.pos_event.vpos);
505
506 /* Need to remove first because we didn't implement the destructor */
507 ui_window_remove(window, control);
508
509 ui_window_destroy(window);
510 ui_destroy(ui);
511}
512
513/** ui_window_def_unfocus() delivers unfocus event to control in window */
514PCUT_TEST(def_unfocus)
515{
516 errno_t rc;
517 ui_t *ui = NULL;
518 ui_wnd_params_t params;
519 ui_window_t *window = NULL;
520 ui_control_t *control = NULL;
521 test_ctl_resp_t resp;
522
523 rc = ui_create_disp(NULL, &ui);
524 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
525
526 ui_wnd_params_init(&params);
527 params.caption = "Hello";
528
529 rc = ui_window_create(ui, &params, &window);
530 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
531
532 rc = ui_control_new(&test_ctl_ops, &resp, &control);
533 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
534
535 ui_window_add(window, control);
536
537 resp.unfocus = false;
538
539 ui_window_def_unfocus(window, 42);
540 PCUT_ASSERT_TRUE(resp.unfocus);
541 PCUT_ASSERT_INT_EQUALS(42, resp.unfocus_nfocus);
542
543 /* Need to remove first because we didn't implement the destructor */
544 ui_window_remove(window, control);
545
546 ui_window_destroy(window);
547 ui_destroy(ui);
548}
549
550/** ui_window_send_sysmenu() calls sysmenu callback set via ui_window_set_cb() */
551PCUT_TEST(send_sysmenu)
552{
553 errno_t rc;
554 ui_t *ui = NULL;
555 ui_wnd_params_t params;
556 ui_window_t *window = NULL;
557 test_cb_resp_t resp;
558
559 rc = ui_create_disp(NULL, &ui);
560 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
561
562 ui_wnd_params_init(&params);
563 params.caption = "Hello";
564
565 rc = ui_window_create(ui, &params, &window);
566 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
567 PCUT_ASSERT_NOT_NULL(window);
568
569 /* Sysmenu callback with no callbacks set */
570 ui_window_send_sysmenu(window, 42);
571
572 /* Sysmenu callback with sysmenu callback not implemented */
573 ui_window_set_cb(window, &dummy_window_cb, NULL);
574 ui_window_send_sysmenu(window, 42);
575
576 /* Sysmenu callback with real callback set */
577 resp.sysmenu = false;
578 resp.sysmenu_idev_id = 0;
579 ui_window_set_cb(window, &test_window_cb, &resp);
580 ui_window_send_sysmenu(window, 42);
581 PCUT_ASSERT_TRUE(resp.sysmenu);
582 PCUT_ASSERT_INT_EQUALS(42, resp.sysmenu_idev_id);
583
584 ui_window_destroy(window);
585 ui_destroy(ui);
586}
587
588/** ui_window_send_minimize() calls minimize callback set via ui_window_set_cb() */
589PCUT_TEST(send_minimize)
590{
591 errno_t rc;
592 ui_t *ui = NULL;
593 ui_wnd_params_t params;
594 ui_window_t *window = NULL;
595 test_cb_resp_t resp;
596
597 rc = ui_create_disp(NULL, &ui);
598 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
599
600 ui_wnd_params_init(&params);
601 params.caption = "Hello";
602
603 rc = ui_window_create(ui, &params, &window);
604 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
605 PCUT_ASSERT_NOT_NULL(window);
606
607 /* Minimize callback with no callbacks set */
608 ui_window_send_minimize(window);
609
610 /* Minimize callback with minimize callback not implemented */
611 ui_window_set_cb(window, &dummy_window_cb, NULL);
612 ui_window_send_minimize(window);
613
614 /* Minimize callback with real callback set */
615 resp.minimize = false;
616 ui_window_set_cb(window, &test_window_cb, &resp);
617 ui_window_send_minimize(window);
618 PCUT_ASSERT_TRUE(resp.minimize);
619
620 ui_window_destroy(window);
621 ui_destroy(ui);
622}
623
624/** ui_window_send_maximize() calls maximize callback set via ui_window_set_cb() */
625PCUT_TEST(send_maximize)
626{
627 errno_t rc;
628 ui_t *ui = NULL;
629 ui_wnd_params_t params;
630 ui_window_t *window = NULL;
631 test_cb_resp_t resp;
632
633 rc = ui_create_disp(NULL, &ui);
634 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
635
636 ui_wnd_params_init(&params);
637 params.caption = "Hello";
638
639 rc = ui_window_create(ui, &params, &window);
640 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
641 PCUT_ASSERT_NOT_NULL(window);
642
643 /* Maximize callback with no callbacks set */
644 ui_window_send_maximize(window);
645
646 /* Maximize callback with maximize callback not implemented */
647 ui_window_set_cb(window, &dummy_window_cb, NULL);
648 ui_window_send_maximize(window);
649
650 /* Maximize callback with real callback set */
651 resp.maximize = false;
652 ui_window_set_cb(window, &test_window_cb, &resp);
653 ui_window_send_maximize(window);
654 PCUT_ASSERT_TRUE(resp.maximize);
655
656 ui_window_destroy(window);
657 ui_destroy(ui);
658}
659
660/** ui_window_send_unmaximize() calls unmaximize callback set via ui_window_set_cb() */
661PCUT_TEST(send_unmaximize)
662{
663 errno_t rc;
664 ui_t *ui = NULL;
665 ui_wnd_params_t params;
666 ui_window_t *window = NULL;
667 test_cb_resp_t resp;
668
669 rc = ui_create_disp(NULL, &ui);
670 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
671
672 ui_wnd_params_init(&params);
673 params.caption = "Hello";
674
675 rc = ui_window_create(ui, &params, &window);
676 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
677 PCUT_ASSERT_NOT_NULL(window);
678
679 /* Unmaximize callback with no callbacks set */
680 ui_window_send_unmaximize(window);
681
682 /* Unmaximize callback with unmaximize callback not implemented */
683 ui_window_set_cb(window, &dummy_window_cb, NULL);
684 ui_window_send_unmaximize(window);
685
686 /* Unmaximize callback with real callback set */
687 resp.unmaximize = false;
688 ui_window_set_cb(window, &test_window_cb, &resp);
689 ui_window_send_unmaximize(window);
690 PCUT_ASSERT_TRUE(resp.unmaximize);
691
692 ui_window_destroy(window);
693 ui_destroy(ui);
694}
695
696/** ui_window_send_close() calls close callback set via ui_window_set_cb() */
697PCUT_TEST(send_close)
698{
699 errno_t rc;
700 ui_t *ui = NULL;
701 ui_wnd_params_t params;
702 ui_window_t *window = NULL;
703 test_cb_resp_t resp;
704
705 rc = ui_create_disp(NULL, &ui);
706 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
707
708 ui_wnd_params_init(&params);
709 params.caption = "Hello";
710
711 rc = ui_window_create(ui, &params, &window);
712 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
713 PCUT_ASSERT_NOT_NULL(window);
714
715 /* Close callback with no callbacks set */
716 ui_window_send_close(window);
717
718 /* Close callback with close callback not implemented */
719 ui_window_set_cb(window, &dummy_window_cb, NULL);
720 ui_window_send_close(window);
721
722 /* Close callback with real callback set */
723 resp.close = false;
724 ui_window_set_cb(window, &test_window_cb, &resp);
725 ui_window_send_close(window);
726 PCUT_ASSERT_TRUE(resp.close);
727
728 ui_window_destroy(window);
729 ui_destroy(ui);
730}
731
732/** ui_window_send_focus() calls focus callback set via ui_window_set_cb() */
733PCUT_TEST(send_focus)
734{
735 errno_t rc;
736 ui_t *ui = NULL;
737 ui_wnd_params_t params;
738 ui_window_t *window = NULL;
739 test_cb_resp_t resp;
740
741 rc = ui_create_disp(NULL, &ui);
742 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
743
744 ui_wnd_params_init(&params);
745 params.caption = "Hello";
746
747 rc = ui_window_create(ui, &params, &window);
748 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
749 PCUT_ASSERT_NOT_NULL(window);
750
751 /* Focus callback with no callbacks set */
752 ui_window_send_focus(window, 42);
753
754 /* Focus callback with focus callback not implemented */
755 ui_window_set_cb(window, &dummy_window_cb, NULL);
756 ui_window_send_focus(window, 42);
757
758 /* Focus callback with real callback set */
759 resp.focus = false;
760 ui_window_set_cb(window, &test_window_cb, &resp);
761 ui_window_send_focus(window, 42);
762 PCUT_ASSERT_TRUE(resp.focus);
763 PCUT_ASSERT_INT_EQUALS(42, resp.focus_nfocus);
764
765 ui_window_destroy(window);
766 ui_destroy(ui);
767}
768
769/** ui_window_send_kbd() calls kbd callback set via ui_window_set_cb() */
770PCUT_TEST(send_kbd)
771{
772 errno_t rc;
773 ui_t *ui = NULL;
774 ui_wnd_params_t params;
775 ui_window_t *window = NULL;
776 kbd_event_t kbd_event;
777 test_cb_resp_t resp;
778
779 rc = ui_create_disp(NULL, &ui);
780 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
781
782 ui_wnd_params_init(&params);
783 params.caption = "Hello";
784
785 rc = ui_window_create(ui, &params, &window);
786 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
787 PCUT_ASSERT_NOT_NULL(window);
788
789 kbd_event.type = KEY_PRESS;
790 kbd_event.key = KC_X;
791 kbd_event.mods = 0;
792 kbd_event.c = 'x';
793
794 /* Kbd callback with no callbacks set */
795 ui_window_send_kbd(window, &kbd_event);
796
797 /* Kbd callback with kbd callback not implemented */
798 ui_window_set_cb(window, &dummy_window_cb, NULL);
799 ui_window_send_kbd(window, &kbd_event);
800
801 /* Kbd callback with real callback set */
802 resp.kbd = false;
803 ui_window_set_cb(window, &test_window_cb, &resp);
804 ui_window_send_kbd(window, &kbd_event);
805 PCUT_ASSERT_TRUE(resp.kbd);
806 PCUT_ASSERT_EQUALS(kbd_event.type, resp.kbd_event.type);
807 PCUT_ASSERT_INT_EQUALS(kbd_event.key, resp.kbd_event.key);
808 PCUT_ASSERT_INT_EQUALS(kbd_event.mods, resp.kbd_event.mods);
809 PCUT_ASSERT_INT_EQUALS(kbd_event.c, resp.kbd_event.c);
810
811 ui_window_destroy(window);
812 ui_destroy(ui);
813}
814
815/** ui_window_send_paint() calls paint callback set via ui_window_set_cb() */
816PCUT_TEST(send_paint)
817{
818 errno_t rc;
819 ui_t *ui = NULL;
820 ui_wnd_params_t params;
821 ui_window_t *window = NULL;
822 test_cb_resp_t resp;
823
824 rc = ui_create_disp(NULL, &ui);
825 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
826
827 ui_wnd_params_init(&params);
828 params.caption = "Hello";
829
830 rc = ui_window_create(ui, &params, &window);
831 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
832 PCUT_ASSERT_NOT_NULL(window);
833
834 /* Paint callback with no callbacks set */
835 ui_window_send_paint(window);
836
837 /* Paint callback with paint callback not implemented */
838 ui_window_set_cb(window, &dummy_window_cb, NULL);
839 ui_window_send_paint(window);
840
841 /* Paint callback with real callback set */
842 resp.paint = false;
843 resp.rc = EOK;
844 ui_window_set_cb(window, &test_window_cb, &resp);
845 rc = ui_window_send_paint(window);
846 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
847 PCUT_ASSERT_TRUE(resp.paint);
848
849 ui_window_destroy(window);
850 ui_destroy(ui);
851}
852
853/** ui_window_send_pos() calls pos callback set via ui_window_set_cb() */
854PCUT_TEST(send_pos)
855{
856 errno_t rc;
857 ui_t *ui = NULL;
858 ui_wnd_params_t params;
859 ui_window_t *window = NULL;
860 pos_event_t pos_event;
861 test_cb_resp_t resp;
862
863 rc = ui_create_disp(NULL, &ui);
864 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
865
866 ui_wnd_params_init(&params);
867 params.caption = "Hello";
868
869 rc = ui_window_create(ui, &params, &window);
870 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
871 PCUT_ASSERT_NOT_NULL(window);
872
873 pos_event.pos_id = 1;
874 pos_event.type = POS_PRESS;
875 pos_event.btn_num = 2;
876 pos_event.hpos = 3;
877 pos_event.vpos = 4;
878
879 /* Pos callback with no callbacks set */
880 ui_window_send_pos(window, &pos_event);
881
882 /* Pos callback with pos callback not implemented */
883 ui_window_set_cb(window, &dummy_window_cb, NULL);
884 ui_window_send_pos(window, &pos_event);
885
886 /* Pos callback with real callback set */
887 resp.pos = false;
888 ui_window_set_cb(window, &test_window_cb, &resp);
889 ui_window_send_pos(window, &pos_event);
890 PCUT_ASSERT_TRUE(resp.pos);
891 PCUT_ASSERT_INT_EQUALS(pos_event.pos_id, resp.pos_event.pos_id);
892 PCUT_ASSERT_EQUALS(pos_event.type, resp.pos_event.type);
893 PCUT_ASSERT_INT_EQUALS(pos_event.btn_num, resp.pos_event.btn_num);
894 PCUT_ASSERT_INT_EQUALS(pos_event.hpos, resp.pos_event.hpos);
895 PCUT_ASSERT_INT_EQUALS(pos_event.vpos, resp.pos_event.vpos);
896
897 ui_window_destroy(window);
898 ui_destroy(ui);
899}
900
901/** ui_window_send_unfocus() calls unfocus callback set via ui_window_set_cb() */
902PCUT_TEST(send_unfocus)
903{
904 errno_t rc;
905 ui_t *ui = NULL;
906 ui_wnd_params_t params;
907 ui_window_t *window = NULL;
908 test_cb_resp_t resp;
909
910 rc = ui_create_disp(NULL, &ui);
911 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
912
913 ui_wnd_params_init(&params);
914 params.caption = "Hello";
915
916 rc = ui_window_create(ui, &params, &window);
917 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
918 PCUT_ASSERT_NOT_NULL(window);
919
920 /* Unfocus callback with no callbacks set */
921 ui_window_send_unfocus(window, 42);
922
923 /* Unfocus callback with unfocus callback not implemented */
924 ui_window_set_cb(window, &dummy_window_cb, NULL);
925 ui_window_send_unfocus(window, 42);
926
927 /* Unfocus callback with real callback set */
928 resp.close = false;
929 ui_window_set_cb(window, &test_window_cb, &resp);
930 ui_window_send_unfocus(window, 42);
931 PCUT_ASSERT_TRUE(resp.unfocus);
932 PCUT_ASSERT_INT_EQUALS(42, resp.unfocus_nfocus);
933
934 ui_window_destroy(window);
935 ui_destroy(ui);
936}
937
938static void test_window_sysmenu(ui_window_t *window, void *arg, sysarg_t idev_id)
939{
940 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
941
942 resp->sysmenu = true;
943 resp->sysmenu_idev_id = idev_id;
944}
945
946static void test_window_minimize(ui_window_t *window, void *arg)
947{
948 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
949
950 resp->minimize = true;
951}
952
953static void test_window_maximize(ui_window_t *window, void *arg)
954{
955 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
956
957 resp->maximize = true;
958}
959
960static void test_window_unmaximize(ui_window_t *window, void *arg)
961{
962 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
963
964 resp->unmaximize = true;
965}
966
967static void test_window_close(ui_window_t *window, void *arg)
968{
969 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
970
971 resp->close = true;
972}
973
974static void test_window_focus(ui_window_t *window, void *arg, unsigned nfocus)
975{
976 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
977
978 resp->focus = true;
979 resp->focus_nfocus = nfocus;
980}
981
982static void test_window_kbd(ui_window_t *window, void *arg,
983 kbd_event_t *event)
984{
985 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
986
987 resp->kbd = true;
988 resp->kbd_event = *event;
989}
990
991static errno_t test_window_paint(ui_window_t *window, void *arg)
992{
993 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
994
995 resp->paint = true;
996 return resp->rc;
997}
998
999static void test_window_pos(ui_window_t *window, void *arg,
1000 pos_event_t *event)
1001{
1002 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1003
1004 resp->pos = true;
1005 resp->pos_event = *event;
1006}
1007
1008static void test_window_unfocus(ui_window_t *window, void *arg, unsigned nfocus)
1009{
1010 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
1011
1012 resp->unfocus = true;
1013 resp->unfocus_nfocus = nfocus;
1014}
1015
1016static errno_t test_ctl_paint(void *arg)
1017{
1018 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
1019
1020 resp->paint = true;
1021 return resp->rc;
1022}
1023
1024static ui_evclaim_t test_ctl_pos_event(void *arg, pos_event_t *event)
1025{
1026 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
1027
1028 resp->pos = true;
1029 resp->pos_event = *event;
1030
1031 return resp->claim;
1032}
1033
1034static void test_ctl_unfocus(void *arg, unsigned nfocus)
1035{
1036 test_ctl_resp_t *resp = (test_ctl_resp_t *) arg;
1037
1038 resp->unfocus = true;
1039 resp->unfocus_nfocus = nfocus;
1040}
1041
1042PCUT_EXPORT(window);
Note: See TracBrowser for help on using the repository browser.