source: mainline/uspace/lib/ui/test/list.c@ e8a6279f

topic/simplify-dev-export
Last change on this file since e8a6279f was 37087c8, checked in by Jiri Svoboda <jiri@…>, 2 years ago

Fill in unimplemented UI list tests
  • Property mode set to 100644
File size: 69.3 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 <errno.h>
30#include <io/kbd_event.h>
31#include <io/pos_event.h>
32#include <pcut/pcut.h>
33#include <stdio.h>
34#include <str.h>
35#include <ui/ui.h>
36#include <ui/list.h>
37#include <ui/scrollbar.h>
38#include <vfs/vfs.h>
39#include "../private/list.h"
40
41PCUT_INIT;
42
43PCUT_TEST_SUITE(list);
44
45/** Test response */
46typedef struct {
47 bool activate_req;
48 ui_list_t *activate_req_list;
49
50 bool selected;
51 ui_list_entry_t *selected_entry;
52} test_resp_t;
53
54static void test_list_activate_req(ui_list_t *, void *);
55static void test_list_selected(ui_list_entry_t *, void *);
56static int test_list_compare(ui_list_entry_t *, ui_list_entry_t *);
57
58static ui_list_cb_t test_cb = {
59 .activate_req = test_list_activate_req,
60 .selected = test_list_selected,
61 .compare = test_list_compare
62};
63
64/** Create and destroy file list. */
65PCUT_TEST(create_destroy)
66{
67 ui_t *ui;
68 ui_window_t *window;
69 ui_wnd_params_t params;
70 ui_list_t *list;
71 errno_t rc;
72
73 rc = ui_create_disp(NULL, &ui);
74 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
75
76 ui_wnd_params_init(&params);
77 params.caption = "Test";
78
79 rc = ui_window_create(ui, &params, &window);
80 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
81
82 rc = ui_list_create(window, true, &list);
83 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
84
85 ui_list_destroy(list);
86 ui_window_destroy(window);
87 ui_destroy(ui);
88}
89
90/** ui_list_set_cb() sets callback */
91PCUT_TEST(set_cb)
92{
93 ui_t *ui;
94 ui_window_t *window;
95 ui_wnd_params_t params;
96 ui_list_t *list;
97 errno_t rc;
98 test_resp_t resp;
99
100 rc = ui_create_disp(NULL, &ui);
101 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
102
103 ui_wnd_params_init(&params);
104 params.caption = "Test";
105
106 rc = ui_window_create(ui, &params, &window);
107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
108
109 rc = ui_list_create(window, true, &list);
110 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
111
112 ui_list_set_cb(list, &test_cb, &resp);
113 PCUT_ASSERT_EQUALS(&test_cb, list->cb);
114 PCUT_ASSERT_EQUALS(&resp, list->cb_arg);
115
116 ui_list_destroy(list);
117 ui_window_destroy(window);
118 ui_destroy(ui);
119}
120
121/** ui_list_get_cb_arg() returns the callback argument */
122PCUT_TEST(get_cb_arg)
123{
124 ui_t *ui;
125 ui_window_t *window;
126 ui_wnd_params_t params;
127 ui_list_t *list;
128 errno_t rc;
129 test_resp_t resp;
130 void *arg;
131
132 rc = ui_create_disp(NULL, &ui);
133 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
134
135 ui_wnd_params_init(&params);
136 params.caption = "Test";
137
138 rc = ui_window_create(ui, &params, &window);
139 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
140
141 rc = ui_list_create(window, true, &list);
142 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
143
144 ui_list_set_cb(list, &test_cb, &resp);
145 arg = ui_list_get_cb_arg(list);
146 PCUT_ASSERT_EQUALS((void *)&resp, arg);
147
148 ui_list_destroy(list);
149 ui_window_destroy(window);
150 ui_destroy(ui);
151}
152
153/** ui_list_entry_height() gives the correct height */
154PCUT_TEST(entry_height)
155{
156 ui_t *ui;
157 ui_window_t *window;
158 ui_wnd_params_t params;
159 ui_list_t *list;
160 errno_t rc;
161 gfx_coord_t height;
162
163 rc = ui_create_disp(NULL, &ui);
164 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
165
166 ui_wnd_params_init(&params);
167 params.caption = "Test";
168
169 rc = ui_window_create(ui, &params, &window);
170 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
171
172 rc = ui_list_create(window, true, &list);
173 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
174
175 /* Font height is 13, padding: 2 (top) + 2 (bottom) */
176 height = ui_list_entry_height(list);
177 PCUT_ASSERT_INT_EQUALS(17, height);
178
179 ui_list_destroy(list);
180 ui_window_destroy(window);
181 ui_destroy(ui);
182}
183
184/** Test ui_list_entry_paint() */
185PCUT_TEST(entry_paint)
186{
187 ui_t *ui;
188 ui_window_t *window;
189 ui_wnd_params_t params;
190 ui_list_t *list;
191 ui_list_entry_attr_t attr;
192 errno_t rc;
193
194 rc = ui_create_disp(NULL, &ui);
195 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
196
197 ui_wnd_params_init(&params);
198 params.caption = "Test";
199
200 rc = ui_window_create(ui, &params, &window);
201 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
202
203 rc = ui_list_create(window, true, &list);
204 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
205
206 ui_list_entry_attr_init(&attr);
207 attr.caption = "a";
208 attr.arg = (void *)1;
209
210 rc = ui_list_entry_append(list, &attr, NULL);
211 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
212
213 rc = ui_list_entry_paint(ui_list_first(list), 0);
214 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
215
216 ui_list_destroy(list);
217 ui_window_destroy(window);
218 ui_destroy(ui);
219}
220
221/** Test ui_list_paint() */
222PCUT_TEST(paint)
223{
224 ui_t *ui;
225 ui_window_t *window;
226 ui_wnd_params_t params;
227 ui_list_t *list;
228 errno_t rc;
229
230 rc = ui_create_disp(NULL, &ui);
231 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
232
233 ui_wnd_params_init(&params);
234 params.caption = "Test";
235
236 rc = ui_window_create(ui, &params, &window);
237 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
238
239 rc = ui_list_create(window, true, &list);
240 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
241
242 rc = ui_list_paint(list);
243 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
244
245 ui_list_destroy(list);
246 ui_window_destroy(window);
247 ui_destroy(ui);
248}
249
250/** ui_list_ctl() returns a valid UI control */
251PCUT_TEST(ctl)
252{
253 ui_t *ui;
254 ui_window_t *window;
255 ui_wnd_params_t params;
256 ui_list_t *list;
257 ui_control_t *control;
258 errno_t rc;
259
260 rc = ui_create_disp(NULL, &ui);
261 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
262
263 ui_wnd_params_init(&params);
264 params.caption = "Test";
265
266 rc = ui_window_create(ui, &params, &window);
267 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
268
269 rc = ui_list_create(window, true, &list);
270 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
271
272 control = ui_list_ctl(list);
273 PCUT_ASSERT_NOT_NULL(control);
274
275 ui_list_destroy(list);
276 ui_window_destroy(window);
277 ui_destroy(ui);
278}
279
280/** Test ui_list_kbd_event() */
281PCUT_TEST(kbd_event)
282{
283 ui_t *ui;
284 ui_window_t *window;
285 ui_wnd_params_t params;
286 ui_list_t *list;
287 ui_evclaim_t claimed;
288 kbd_event_t event;
289 errno_t rc;
290
291 /* Active list should claim events */
292
293 rc = ui_create_disp(NULL, &ui);
294 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
295
296 ui_wnd_params_init(&params);
297 params.caption = "Test";
298
299 rc = ui_window_create(ui, &params, &window);
300 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
301
302 rc = ui_list_create(window, true, &list);
303 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
304
305 event.type = KEY_PRESS;
306 event.key = KC_ESCAPE;
307 event.mods = 0;
308 event.c = '\0';
309
310 claimed = ui_list_kbd_event(list, &event);
311 PCUT_ASSERT_EQUALS(ui_claimed, claimed);
312
313 ui_list_destroy(list);
314
315 /* Inactive list should not claim events */
316
317 rc = ui_create_disp(NULL, &ui);
318 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
319
320 ui_wnd_params_init(&params);
321 params.caption = "Test";
322
323 rc = ui_window_create(ui, &params, &window);
324 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
325
326 rc = ui_list_create(window, false, &list);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328
329 event.type = KEY_PRESS;
330 event.key = KC_ESCAPE;
331 event.mods = 0;
332 event.c = '\0';
333
334 claimed = ui_list_kbd_event(list, &event);
335 PCUT_ASSERT_EQUALS(ui_unclaimed, claimed);
336
337 ui_list_destroy(list);
338 ui_window_destroy(window);
339 ui_destroy(ui);
340}
341
342/** Test ui_list_pos_event() */
343PCUT_TEST(pos_event)
344{
345 ui_t *ui;
346 ui_window_t *window;
347 ui_wnd_params_t params;
348 ui_list_t *list;
349 ui_evclaim_t claimed;
350 pos_event_t event;
351 gfx_rect_t rect;
352 ui_list_entry_attr_t attr;
353 errno_t rc;
354
355 rc = ui_create_disp(NULL, &ui);
356 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
357
358 ui_wnd_params_init(&params);
359 params.caption = "Test";
360
361 rc = ui_window_create(ui, &params, &window);
362 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
363
364 rc = ui_list_create(window, true, &list);
365 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
366
367 rect.p0.x = 10;
368 rect.p0.y = 20;
369 rect.p1.x = 50;
370 rect.p1.y = 220;
371
372 ui_list_set_rect(list, &rect);
373
374 ui_list_entry_attr_init(&attr);
375 attr.caption = "a";
376 attr.arg = (void *)1;
377 rc = ui_list_entry_append(list, &attr, NULL);
378 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
379
380 attr.caption = "b";
381 attr.arg = (void *)2;
382 rc = ui_list_entry_append(list, &attr, NULL);
383 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
384
385 attr.caption = "c";
386 attr.arg = (void *)3;
387 rc = ui_list_entry_append(list, &attr, NULL);
388 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
389
390 list->cursor = ui_list_first(list);
391 list->cursor_idx = 0;
392 list->page = ui_list_first(list);
393 list->page_idx = 0;
394
395 event.pos_id = 0;
396 event.type = POS_PRESS;
397 event.btn_num = 1;
398
399 /* Clicking on the middle entry should select it */
400 event.hpos = 20;
401 event.vpos = 40;
402
403 claimed = ui_list_pos_event(list, &event);
404 PCUT_ASSERT_EQUALS(ui_claimed, claimed);
405
406 PCUT_ASSERT_NOT_NULL(list->cursor);
407 PCUT_ASSERT_STR_EQUALS("b", list->cursor->caption);
408 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->cursor->arg);
409
410 /* Clicking on the top edge should do a page-up */
411 event.hpos = 20;
412 event.vpos = 20;
413 claimed = ui_list_pos_event(list, &event);
414 PCUT_ASSERT_EQUALS(ui_claimed, claimed);
415
416 PCUT_ASSERT_NOT_NULL(list->cursor);
417 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
418 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
419
420 ui_list_destroy(list);
421 ui_window_destroy(window);
422 ui_destroy(ui);
423}
424
425/** ui_list_set_rect() sets internal field */
426PCUT_TEST(set_rect)
427{
428 ui_t *ui;
429 ui_window_t *window;
430 ui_wnd_params_t params;
431 ui_list_t *list;
432 gfx_rect_t rect;
433 errno_t rc;
434
435 rc = ui_create_disp(NULL, &ui);
436 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
437
438 ui_wnd_params_init(&params);
439 params.caption = "Test";
440
441 rc = ui_window_create(ui, &params, &window);
442 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
443
444 rc = ui_list_create(window, true, &list);
445 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
446
447 rect.p0.x = 1;
448 rect.p0.y = 2;
449 rect.p1.x = 3;
450 rect.p1.y = 4;
451
452 ui_list_set_rect(list, &rect);
453 PCUT_ASSERT_INT_EQUALS(rect.p0.x, list->rect.p0.x);
454 PCUT_ASSERT_INT_EQUALS(rect.p0.y, list->rect.p0.y);
455 PCUT_ASSERT_INT_EQUALS(rect.p1.x, list->rect.p1.x);
456 PCUT_ASSERT_INT_EQUALS(rect.p1.y, list->rect.p1.y);
457
458 ui_list_destroy(list);
459 ui_window_destroy(window);
460 ui_destroy(ui);
461}
462
463/** ui_list_page_size() returns correct size */
464PCUT_TEST(page_size)
465{
466 ui_t *ui;
467 ui_window_t *window;
468 ui_wnd_params_t params;
469 ui_list_t *list;
470 gfx_rect_t rect;
471 errno_t rc;
472
473 rc = ui_create_disp(NULL, &ui);
474 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
475
476 ui_wnd_params_init(&params);
477 params.caption = "Test";
478
479 rc = ui_window_create(ui, &params, &window);
480 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
481
482 rc = ui_list_create(window, true, &list);
483 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
484
485 rect.p0.x = 10;
486 rect.p0.y = 20;
487 rect.p1.x = 50;
488 rect.p1.y = 220;
489
490 ui_list_set_rect(list, &rect);
491
492 /* NOTE If page size changes, we have problems elsewhere in the tests */
493 PCUT_ASSERT_INT_EQUALS(11, ui_list_page_size(list));
494
495 ui_list_destroy(list);
496 ui_window_destroy(window);
497 ui_destroy(ui);
498}
499
500/** ui_list_inside_rect() gives correct interior rectangle */
501PCUT_TEST(inside_rect)
502{
503 ui_t *ui;
504 ui_window_t *window;
505 ui_wnd_params_t params;
506 ui_list_t *list;
507 gfx_rect_t rect;
508 gfx_rect_t irect;
509 errno_t rc;
510
511 rc = ui_create_disp(NULL, &ui);
512 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
513
514 ui_wnd_params_init(&params);
515 params.caption = "Test";
516
517 rc = ui_window_create(ui, &params, &window);
518 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
519
520 rc = ui_list_create(window, true, &list);
521 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
522
523 rect.p0.x = 10;
524 rect.p0.y = 20;
525 rect.p1.x = 50;
526 rect.p1.y = 220;
527
528 ui_list_set_rect(list, &rect);
529
530 ui_list_inside_rect(list, &irect);
531 PCUT_ASSERT_INT_EQUALS(10 + 2, irect.p0.x);
532 PCUT_ASSERT_INT_EQUALS(20 + 2, irect.p0.y);
533 PCUT_ASSERT_INT_EQUALS(50 - 2 - 23, irect.p1.x);
534 PCUT_ASSERT_INT_EQUALS(220 - 2, irect.p1.y);
535
536 ui_list_destroy(list);
537 ui_window_destroy(window);
538 ui_destroy(ui);
539}
540
541/** ui_list_scrollbar_rect() gives correct scrollbar rectangle */
542PCUT_TEST(scrollbar_rect)
543{
544 ui_t *ui;
545 ui_window_t *window;
546 ui_wnd_params_t params;
547 ui_list_t *list;
548 gfx_rect_t rect;
549 gfx_rect_t srect;
550 errno_t rc;
551
552 rc = ui_create_disp(NULL, &ui);
553 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
554
555 ui_wnd_params_init(&params);
556 params.caption = "Test";
557
558 rc = ui_window_create(ui, &params, &window);
559 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
560
561 rc = ui_list_create(window, true, &list);
562 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
563
564 rect.p0.x = 10;
565 rect.p0.y = 20;
566 rect.p1.x = 50;
567 rect.p1.y = 220;
568
569 ui_list_set_rect(list, &rect);
570
571 ui_list_scrollbar_rect(list, &srect);
572 PCUT_ASSERT_INT_EQUALS(50 - 2 - 23, srect.p0.x);
573 PCUT_ASSERT_INT_EQUALS(20 + 2, srect.p0.y);
574 PCUT_ASSERT_INT_EQUALS(50 - 2, srect.p1.x);
575 PCUT_ASSERT_INT_EQUALS(220 - 2, srect.p1.y);
576
577 ui_list_destroy(list);
578 ui_window_destroy(window);
579 ui_destroy(ui);
580}
581
582/** ui_list_scrollbar_update() updates scrollbar position */
583PCUT_TEST(scrollbar_update)
584{
585 ui_t *ui;
586 ui_window_t *window;
587 ui_wnd_params_t params;
588 ui_list_t *list;
589 gfx_rect_t rect;
590 ui_list_entry_attr_t attr;
591 ui_list_entry_t *entry;
592 gfx_coord_t pos;
593 gfx_coord_t move_len;
594 errno_t rc;
595
596 rc = ui_create_disp(NULL, &ui);
597 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
598
599 ui_wnd_params_init(&params);
600 params.caption = "Test";
601
602 rc = ui_window_create(ui, &params, &window);
603 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
604
605 rc = ui_list_create(window, true, &list);
606 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
607
608 rect.p0.x = 0;
609 rect.p0.y = 0;
610 rect.p1.x = 50;
611 rect.p1.y = 38;
612
613 ui_list_set_rect(list, &rect);
614
615 ui_list_entry_attr_init(&attr);
616 attr.caption = "a";
617 attr.arg = (void *)1;
618 rc = ui_list_entry_append(list, &attr, NULL);
619 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
620
621 attr.caption = "b";
622 attr.arg = (void *)2;
623 rc = ui_list_entry_append(list, &attr, NULL);
624 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
625
626 attr.caption = "c";
627 attr.arg = (void *)3;
628 rc = ui_list_entry_append(list, &attr, NULL);
629 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
630
631 entry = ui_list_next(ui_list_first(list));
632
633 list->cursor = entry;
634 list->cursor_idx = 1;
635 list->page = entry;
636 list->page_idx = 1;
637
638 ui_list_scrollbar_update(list);
639
640 /* Now scrollbar thumb should be all the way down */
641 move_len = ui_scrollbar_move_length(list->scrollbar);
642 pos = ui_scrollbar_get_pos(list->scrollbar);
643 PCUT_ASSERT_INT_EQUALS(move_len, pos);
644
645 ui_list_destroy(list);
646 ui_window_destroy(window);
647 ui_destroy(ui);
648}
649
650/** ui_list_is_active() returns list activity state */
651PCUT_TEST(is_active)
652{
653 ui_t *ui;
654 ui_window_t *window;
655 ui_wnd_params_t params;
656 ui_list_t *list;
657 errno_t rc;
658
659 rc = ui_create_disp(NULL, &ui);
660 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
661
662 ui_wnd_params_init(&params);
663 params.caption = "Test";
664
665 rc = ui_window_create(ui, &params, &window);
666 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
667
668 rc = ui_list_create(window, true, &list);
669 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
670 PCUT_ASSERT_TRUE(ui_list_is_active(list));
671 ui_list_destroy(list);
672
673 rc = ui_list_create(window, false, &list);
674 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
675 PCUT_ASSERT_FALSE(ui_list_is_active(list));
676 ui_list_destroy(list);
677 ui_window_destroy(window);
678 ui_destroy(ui);
679}
680
681/** ui_list_activate() activates list */
682PCUT_TEST(activate)
683{
684 ui_t *ui;
685 ui_window_t *window;
686 ui_wnd_params_t params;
687 ui_list_t *list;
688 errno_t rc;
689
690 rc = ui_create_disp(NULL, &ui);
691 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
692
693 ui_wnd_params_init(&params);
694 params.caption = "Test";
695
696 rc = ui_window_create(ui, &params, &window);
697 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
698
699 rc = ui_list_create(window, false, &list);
700 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
701
702 PCUT_ASSERT_FALSE(ui_list_is_active(list));
703 rc = ui_list_activate(list);
704 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
705 PCUT_ASSERT_TRUE(ui_list_is_active(list));
706
707 ui_list_destroy(list);
708 ui_window_destroy(window);
709 ui_destroy(ui);
710}
711
712/** ui_list_deactivate() deactivates list */
713PCUT_TEST(deactivate)
714{
715 ui_t *ui;
716 ui_window_t *window;
717 ui_wnd_params_t params;
718 ui_list_t *list;
719 errno_t rc;
720
721 rc = ui_create_disp(NULL, &ui);
722 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
723
724 ui_wnd_params_init(&params);
725 params.caption = "Test";
726
727 rc = ui_window_create(ui, &params, &window);
728 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
729
730 rc = ui_list_create(window, true, &list);
731 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
732
733 PCUT_ASSERT_TRUE(ui_list_is_active(list));
734 ui_list_deactivate(list);
735 PCUT_ASSERT_FALSE(ui_list_is_active(list));
736
737 ui_list_destroy(list);
738 ui_window_destroy(window);
739 ui_destroy(ui);
740}
741
742/** ui_list_get_cursor() returns the current cursor position */
743PCUT_TEST(get_cursor)
744{
745 ui_t *ui;
746 ui_window_t *window;
747 ui_wnd_params_t params;
748 ui_list_t *list;
749 ui_list_entry_attr_t attr;
750 ui_list_entry_t *entry;
751 ui_list_entry_t *cursor;
752 errno_t rc;
753
754 rc = ui_create_disp(NULL, &ui);
755 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
756
757 ui_wnd_params_init(&params);
758 params.caption = "Test";
759
760 rc = ui_window_create(ui, &params, &window);
761 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
762
763 rc = ui_list_create(window, true, &list);
764 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
765
766 ui_list_entry_attr_init(&attr);
767
768 /* Append entry and get pointer to it */
769 attr.caption = "a";
770 attr.arg = (void *)1;
771 entry = NULL;
772 rc = ui_list_entry_append(list, &attr, &entry);
773 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
774 PCUT_ASSERT_NOT_NULL(entry);
775
776 /* Cursor should be at the only entry */
777 cursor = ui_list_get_cursor(list);
778 PCUT_ASSERT_EQUALS(entry, cursor);
779
780 ui_list_destroy(list);
781 ui_window_destroy(window);
782 ui_destroy(ui);
783}
784
785/** ui_list_set_cursor() sets list cursor position */
786PCUT_TEST(set_cursor)
787{
788 ui_t *ui;
789 ui_window_t *window;
790 ui_wnd_params_t params;
791 ui_list_t *list;
792 ui_list_entry_attr_t attr;
793 ui_list_entry_t *e1;
794 ui_list_entry_t *e2;
795 errno_t rc;
796
797 rc = ui_create_disp(NULL, &ui);
798 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
799
800 ui_wnd_params_init(&params);
801 params.caption = "Test";
802
803 rc = ui_window_create(ui, &params, &window);
804 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
805
806 rc = ui_list_create(window, true, &list);
807 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
808
809 ui_list_entry_attr_init(&attr);
810
811 /* Append entry and get pointer to it */
812 attr.caption = "a";
813 attr.arg = (void *)1;
814 rc = ui_list_entry_append(list, &attr, &e1);
815 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
816 PCUT_ASSERT_NOT_NULL(e1);
817
818 /* Append entry and get pointer to it */
819 attr.caption = "b";
820 attr.arg = (void *)2;
821 rc = ui_list_entry_append(list, &attr, &e2);
822 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
823 PCUT_ASSERT_NOT_NULL(e2);
824
825 /* Append entry */
826 attr.caption = "c";
827 attr.arg = (void *)3;
828 rc = ui_list_entry_append(list, &attr, NULL);
829 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
830
831 /* Cursor should be at the first entry */
832 PCUT_ASSERT_EQUALS(e1, list->cursor);
833 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
834
835 /* Set cursor to the second entry */
836 ui_list_set_cursor(list, e2);
837 PCUT_ASSERT_EQUALS(e2, list->cursor);
838 PCUT_ASSERT_INT_EQUALS(1, list->cursor_idx);
839
840 ui_list_destroy(list);
841 ui_window_destroy(window);
842 ui_destroy(ui);
843}
844
845/** ui_list_entry_attr_init() initializes entry attribute structure */
846PCUT_TEST(entry_attr_init)
847{
848 ui_list_entry_attr_t attr;
849
850 ui_list_entry_attr_init(&attr);
851 PCUT_ASSERT_NULL(attr.caption);
852 PCUT_ASSERT_NULL(attr.arg);
853 PCUT_ASSERT_NULL(attr.color);
854 PCUT_ASSERT_NULL(attr.bgcolor);
855}
856
857/** ui_list_entry_append() appends new entry */
858PCUT_TEST(entry_append)
859{
860 ui_t *ui;
861 ui_window_t *window;
862 ui_wnd_params_t params;
863 ui_list_t *list;
864 ui_list_entry_attr_t attr;
865 ui_list_entry_t *entry;
866 errno_t rc;
867
868 rc = ui_create_disp(NULL, &ui);
869 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
870
871 ui_wnd_params_init(&params);
872 params.caption = "Test";
873
874 rc = ui_window_create(ui, &params, &window);
875 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
876
877 rc = ui_list_create(window, true, &list);
878 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
879
880 ui_list_entry_attr_init(&attr);
881
882 /* Append entry without retrieving pointer to it */
883 attr.caption = "a";
884 attr.arg = (void *)1;
885 rc = ui_list_entry_append(list, &attr, NULL);
886 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
887
888 PCUT_ASSERT_INT_EQUALS(1, list_count(&list->entries));
889
890 /* Append entry and get pointer to it */
891 attr.caption = "b";
892 attr.arg = (void *)2;
893 entry = NULL;
894 rc = ui_list_entry_append(list, &attr, &entry);
895 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
896 PCUT_ASSERT_NOT_NULL(entry);
897 PCUT_ASSERT_EQUALS(attr.arg, entry->arg);
898
899 PCUT_ASSERT_INT_EQUALS(2, list_count(&list->entries));
900
901 ui_list_destroy(list);
902 ui_window_destroy(window);
903 ui_destroy(ui);
904}
905
906/** ui_list_entry_delete() deletes entry */
907PCUT_TEST(entry_delete)
908{
909 ui_t *ui;
910 ui_window_t *window;
911 ui_wnd_params_t params;
912 ui_list_t *list;
913 ui_list_entry_t *entry;
914 ui_list_entry_attr_t attr;
915 errno_t rc;
916
917 rc = ui_create_disp(NULL, &ui);
918 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
919
920 ui_wnd_params_init(&params);
921 params.caption = "Test";
922
923 rc = ui_window_create(ui, &params, &window);
924 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
925
926 rc = ui_list_create(window, true, &list);
927 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
928
929 attr.caption = "a";
930 attr.arg = (void *)1;
931 rc = ui_list_entry_append(list, &attr, NULL);
932 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
933
934 attr.caption = "b";
935 attr.arg = (void *)2;
936 rc = ui_list_entry_append(list, &attr, NULL);
937 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
938
939 PCUT_ASSERT_INT_EQUALS(2, list_count(&list->entries));
940
941 entry = ui_list_first(list);
942 ui_list_entry_delete(entry);
943
944 PCUT_ASSERT_INT_EQUALS(1, list_count(&list->entries));
945
946 entry = ui_list_first(list);
947 ui_list_entry_delete(entry);
948
949 PCUT_ASSERT_INT_EQUALS(0, list_count(&list->entries));
950
951 ui_list_destroy(list);
952 ui_window_destroy(window);
953 ui_destroy(ui);
954}
955
956/** ui_list_entry_get_arg() gets entry argument */
957PCUT_TEST(entry_get_arg)
958{
959 ui_t *ui;
960 ui_window_t *window;
961 ui_wnd_params_t params;
962 ui_list_t *list;
963 ui_list_entry_attr_t attr;
964 ui_list_entry_t *entry;
965 void *arg;
966 errno_t rc;
967
968 rc = ui_create_disp(NULL, &ui);
969 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
970
971 ui_wnd_params_init(&params);
972 params.caption = "Test";
973
974 rc = ui_window_create(ui, &params, &window);
975 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
976
977 rc = ui_list_create(window, true, &list);
978 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
979
980 ui_list_entry_attr_init(&attr);
981
982 /* Append entry and get pointer to it */
983 attr.caption = "a";
984 attr.arg = (void *)1;
985 entry = NULL;
986 rc = ui_list_entry_append(list, &attr, &entry);
987 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
988 PCUT_ASSERT_NOT_NULL(entry);
989
990 arg = ui_list_entry_get_arg(entry);
991 PCUT_ASSERT_EQUALS(attr.arg, arg);
992
993 ui_list_destroy(list);
994 ui_window_destroy(window);
995 ui_destroy(ui);
996}
997
998/** ui_list_entry_get_list() returns the containing list */
999PCUT_TEST(entry_get_list)
1000{
1001 ui_t *ui;
1002 ui_window_t *window;
1003 ui_wnd_params_t params;
1004 ui_list_t *list;
1005 ui_list_t *elist;
1006 ui_list_entry_attr_t attr;
1007 ui_list_entry_t *entry;
1008 errno_t rc;
1009
1010 rc = ui_create_disp(NULL, &ui);
1011 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1012
1013 ui_wnd_params_init(&params);
1014 params.caption = "Test";
1015
1016 rc = ui_window_create(ui, &params, &window);
1017 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1018
1019 rc = ui_list_create(window, true, &list);
1020 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1021
1022 ui_list_entry_attr_init(&attr);
1023
1024 /* Append entry and get pointer to it */
1025 attr.caption = "a";
1026 attr.arg = (void *)1;
1027 entry = NULL;
1028 rc = ui_list_entry_append(list, &attr, &entry);
1029 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1030 PCUT_ASSERT_NOT_NULL(entry);
1031
1032 /* Get the containing list */
1033 elist = ui_list_entry_get_list(entry);
1034 PCUT_ASSERT_EQUALS(list, elist);
1035
1036 ui_list_destroy(list);
1037 ui_window_destroy(window);
1038 ui_destroy(ui);
1039}
1040
1041/** ui_list_entries_cnt() returns the number of entries */
1042PCUT_TEST(entries_cnt)
1043{
1044 ui_t *ui;
1045 ui_window_t *window;
1046 ui_wnd_params_t params;
1047 ui_list_t *list;
1048 ui_list_entry_attr_t attr;
1049 errno_t rc;
1050
1051 rc = ui_create_disp(NULL, &ui);
1052 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1053
1054 ui_wnd_params_init(&params);
1055 params.caption = "Test";
1056
1057 rc = ui_window_create(ui, &params, &window);
1058 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1059
1060 rc = ui_list_create(window, true, &list);
1061 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1062
1063 PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(list));
1064
1065 ui_list_entry_attr_init(&attr);
1066
1067 /* Append entry */
1068 attr.caption = "a";
1069 attr.arg = (void *)1;
1070 rc = ui_list_entry_append(list, &attr, NULL);
1071 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1072
1073 PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(list));
1074
1075 /* Append another entry */
1076 attr.caption = "b";
1077 attr.arg = (void *)2;
1078 rc = ui_list_entry_append(list, &attr, NULL);
1079 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1080
1081 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(list));
1082
1083 ui_list_destroy(list);
1084 ui_window_destroy(window);
1085 ui_destroy(ui);
1086}
1087
1088/** ui_list_sort() sorts UI list entries */
1089PCUT_TEST(sort)
1090{
1091 ui_t *ui;
1092 ui_window_t *window;
1093 ui_wnd_params_t params;
1094 ui_list_t *list;
1095 ui_list_entry_t *entry;
1096 ui_list_entry_attr_t attr;
1097 test_resp_t resp;
1098 errno_t rc;
1099
1100 rc = ui_create_disp(NULL, &ui);
1101 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1102
1103 ui_wnd_params_init(&params);
1104 params.caption = "Test";
1105
1106 rc = ui_window_create(ui, &params, &window);
1107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1108
1109 rc = ui_list_create(window, true, &list);
1110 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1111
1112 ui_list_set_cb(list, &test_cb, &resp);
1113
1114 ui_list_entry_attr_init(&attr);
1115
1116 attr.caption = "b";
1117 attr.arg = (void *)1;
1118 rc = ui_list_entry_append(list, &attr, NULL);
1119 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1120
1121 attr.caption = "c";
1122 attr.arg = (void *)3;
1123 rc = ui_list_entry_append(list, &attr, NULL);
1124 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1125
1126 attr.caption = "a";
1127 attr.arg = (void *)2;
1128 rc = ui_list_entry_append(list, &attr, NULL);
1129 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1130
1131 rc = ui_list_sort(list);
1132 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1133
1134 entry = ui_list_first(list);
1135 PCUT_ASSERT_STR_EQUALS("a", entry->caption);
1136 PCUT_ASSERT_EQUALS((void *)2, entry->arg);
1137
1138 entry = ui_list_next(entry);
1139 PCUT_ASSERT_STR_EQUALS("b", entry->caption);
1140 PCUT_ASSERT_EQUALS((void *)1, entry->arg);
1141
1142 entry = ui_list_next(entry);
1143 PCUT_ASSERT_STR_EQUALS("c", entry->caption);
1144 PCUT_ASSERT_EQUALS((void *)3, entry->arg);
1145
1146 ui_list_destroy(list);
1147 ui_window_destroy(window);
1148 ui_destroy(ui);
1149}
1150
1151/** ui_list_cursor_center()...XXX */
1152PCUT_TEST(cursor_center)
1153{
1154 ui_t *ui;
1155 ui_window_t *window;
1156 ui_wnd_params_t params;
1157 ui_list_t *list;
1158 ui_list_entry_t *a, *b, *c, *d, *e;
1159 ui_list_entry_attr_t attr;
1160 gfx_rect_t rect;
1161 test_resp_t resp;
1162 errno_t rc;
1163
1164 rc = ui_create_disp(NULL, &ui);
1165 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1166
1167 ui_wnd_params_init(&params);
1168 params.caption = "Test";
1169
1170 rc = ui_window_create(ui, &params, &window);
1171 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1172
1173 rc = ui_list_create(window, true, &list);
1174 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1175
1176 ui_list_set_cb(list, &test_cb, &resp);
1177
1178 rect.p0.x = 10;
1179 rect.p0.y = 20;
1180 rect.p1.x = 50;
1181 rect.p1.y = 80;
1182
1183 ui_list_set_rect(list, &rect);
1184
1185 PCUT_ASSERT_INT_EQUALS(3, ui_list_page_size(list));
1186
1187 ui_list_entry_attr_init(&attr);
1188
1189 attr.caption = "a";
1190 attr.arg = (void *)1;
1191 rc = ui_list_entry_append(list, &attr, &a);
1192 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1193
1194 attr.caption = "b";
1195 attr.arg = (void *)2;
1196 rc = ui_list_entry_append(list, &attr, &b);
1197 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1198
1199 /* We only have two entries, but three fit onto the page */
1200 ui_list_cursor_center(list, b);
1201 PCUT_ASSERT_EQUALS(b, list->cursor);
1202 /* Page should start at the beginning */
1203 PCUT_ASSERT_EQUALS(a, list->page);
1204 PCUT_ASSERT_EQUALS(0, list->page_idx);
1205
1206 /* Add more entries */
1207
1208 attr.caption = "c";
1209 attr.arg = (void *)3;
1210 rc = ui_list_entry_append(list, &attr, &c);
1211 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1212
1213 attr.caption = "d";
1214 attr.arg = (void *)4;
1215 rc = ui_list_entry_append(list, &attr, &d);
1216 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1217
1218 attr.caption = "e";
1219 attr.arg = (void *)5;
1220 rc = ui_list_entry_append(list, &attr, &e);
1221 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1222
1223 ui_list_cursor_center(list, c);
1224 PCUT_ASSERT_EQUALS(c, list->cursor);
1225 /*
1226 * We have enough entries, c should be in the middle of the three
1227 * entries on the page, i.e., page should start on 'b'.
1228 */
1229 PCUT_ASSERT_EQUALS(b, list->page);
1230 PCUT_ASSERT_EQUALS(1, list->page_idx);
1231
1232 ui_list_destroy(list);
1233 ui_window_destroy(window);
1234 ui_destroy(ui);
1235}
1236
1237/** ui_list_clear_entries() removes all entries from list */
1238PCUT_TEST(clear_entries)
1239{
1240 ui_t *ui;
1241 ui_window_t *window;
1242 ui_wnd_params_t params;
1243 ui_list_t *list;
1244 ui_list_entry_attr_t attr;
1245 errno_t rc;
1246
1247 rc = ui_create_disp(NULL, &ui);
1248 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1249
1250 ui_wnd_params_init(&params);
1251 params.caption = "Test";
1252
1253 rc = ui_window_create(ui, &params, &window);
1254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1255
1256 rc = ui_list_create(window, true, &list);
1257 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1258
1259 ui_list_entry_attr_init(&attr);
1260 attr.caption = "a";
1261 attr.arg = (void *)1;
1262 rc = ui_list_entry_append(list, &attr, NULL);
1263 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1264
1265 attr.caption = "a";
1266 attr.arg = (void *)2;
1267 rc = ui_list_entry_append(list, &attr, NULL);
1268 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1269
1270 PCUT_ASSERT_INT_EQUALS(2, list_count(&list->entries));
1271
1272 ui_list_clear_entries(list);
1273 PCUT_ASSERT_INT_EQUALS(0, list_count(&list->entries));
1274
1275 ui_list_destroy(list);
1276 ui_window_destroy(window);
1277 ui_destroy(ui);
1278}
1279
1280/** ui_list_first() returns valid entry or @c NULL as appropriate */
1281PCUT_TEST(first)
1282{
1283 ui_t *ui;
1284 ui_window_t *window;
1285 ui_wnd_params_t params;
1286 ui_list_t *list;
1287 ui_list_entry_t *entry;
1288 ui_list_entry_attr_t attr;
1289 errno_t rc;
1290
1291 rc = ui_create_disp(NULL, &ui);
1292 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1293
1294 ui_wnd_params_init(&params);
1295 params.caption = "Test";
1296
1297 rc = ui_window_create(ui, &params, &window);
1298 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1299
1300 rc = ui_list_create(window, true, &list);
1301 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1302
1303 ui_list_entry_attr_init(&attr);
1304
1305 entry = ui_list_first(list);
1306 PCUT_ASSERT_NULL(entry);
1307
1308 /* Add one entry */
1309 attr.caption = "a";
1310 attr.arg = (void *)1;
1311 rc = ui_list_entry_append(list, &attr, NULL);
1312 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1313
1314 /* Now try getting it */
1315 entry = ui_list_first(list);
1316 PCUT_ASSERT_NOT_NULL(entry);
1317 PCUT_ASSERT_STR_EQUALS("a", entry->caption);
1318 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)entry->arg);
1319
1320 /* Add another entry */
1321 attr.caption = "b";
1322 attr.arg = (void *)2;
1323 rc = ui_list_entry_append(list, &attr, NULL);
1324 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1325
1326 /* We should still get the first entry */
1327 entry = ui_list_first(list);
1328 PCUT_ASSERT_NOT_NULL(entry);
1329 PCUT_ASSERT_STR_EQUALS("a", entry->caption);
1330 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)entry->arg);
1331
1332 ui_list_destroy(list);
1333 ui_window_destroy(window);
1334 ui_destroy(ui);
1335}
1336
1337/** ui_list_last() returns valid entry or @c NULL as appropriate */
1338PCUT_TEST(last)
1339{
1340 ui_t *ui;
1341 ui_window_t *window;
1342 ui_wnd_params_t params;
1343 ui_list_t *list;
1344 ui_list_entry_t *entry;
1345 ui_list_entry_attr_t attr;
1346 errno_t rc;
1347
1348 rc = ui_create_disp(NULL, &ui);
1349 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1350
1351 ui_wnd_params_init(&params);
1352 params.caption = "Test";
1353
1354 rc = ui_window_create(ui, &params, &window);
1355 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1356
1357 rc = ui_list_create(window, true, &list);
1358 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1359
1360 ui_list_entry_attr_init(&attr);
1361
1362 entry = ui_list_last(list);
1363 PCUT_ASSERT_NULL(entry);
1364
1365 /* Add one entry */
1366 attr.caption = "a";
1367 attr.arg = (void *)1;
1368 rc = ui_list_entry_append(list, &attr, NULL);
1369 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1370
1371 /* Now try getting it */
1372 entry = ui_list_last(list);
1373 PCUT_ASSERT_NOT_NULL(entry);
1374 PCUT_ASSERT_STR_EQUALS("a", entry->caption);
1375 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)entry->arg);
1376
1377 /* Add another entry */
1378 attr.caption = "b";
1379 attr.arg = (void *)2;
1380 rc = ui_list_entry_append(list, &attr, NULL);
1381 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1382
1383 /* We should get new entry now */
1384 entry = ui_list_last(list);
1385 PCUT_ASSERT_NOT_NULL(entry);
1386 attr.caption = "b";
1387 attr.arg = (void *)2;
1388 PCUT_ASSERT_STR_EQUALS("b", entry->caption);
1389 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)entry->arg);
1390
1391 ui_list_destroy(list);
1392 ui_window_destroy(window);
1393 ui_destroy(ui);
1394}
1395
1396/** ui_list_next() returns the next entry or @c NULL as appropriate */
1397PCUT_TEST(next)
1398{
1399 ui_t *ui;
1400 ui_window_t *window;
1401 ui_wnd_params_t params;
1402 ui_list_t *list;
1403 ui_list_entry_t *entry;
1404 ui_list_entry_attr_t attr;
1405 errno_t rc;
1406
1407 rc = ui_create_disp(NULL, &ui);
1408 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1409
1410 ui_wnd_params_init(&params);
1411 params.caption = "Test";
1412
1413 rc = ui_window_create(ui, &params, &window);
1414 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1415
1416 rc = ui_list_create(window, true, &list);
1417 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1418
1419 ui_list_entry_attr_init(&attr);
1420
1421 /* Add one entry */
1422 attr.caption = "a";
1423 attr.arg = (void *)1;
1424 rc = ui_list_entry_append(list, &attr, NULL);
1425 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1426
1427 /* Now try getting its successor */
1428 entry = ui_list_first(list);
1429 PCUT_ASSERT_NOT_NULL(entry);
1430
1431 entry = ui_list_next(entry);
1432 PCUT_ASSERT_NULL(entry);
1433
1434 /* Add another entry */
1435 attr.caption = "b";
1436 attr.arg = (void *)2;
1437 rc = ui_list_entry_append(list, &attr, NULL);
1438 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1439
1440 /* Try getting the successor of first entry again */
1441 entry = ui_list_first(list);
1442 PCUT_ASSERT_NOT_NULL(entry);
1443
1444 entry = ui_list_next(entry);
1445 PCUT_ASSERT_NOT_NULL(entry);
1446 PCUT_ASSERT_STR_EQUALS("b", entry->caption);
1447 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)entry->arg);
1448
1449 ui_list_destroy(list);
1450 ui_window_destroy(window);
1451 ui_destroy(ui);
1452}
1453
1454/** ui_list_prev() returns the previous entry or @c NULL as appropriate */
1455PCUT_TEST(prev)
1456{
1457 ui_t *ui;
1458 ui_window_t *window;
1459 ui_wnd_params_t params;
1460 ui_list_t *list;
1461 ui_list_entry_t *entry;
1462 ui_list_entry_attr_t attr;
1463 errno_t rc;
1464
1465 rc = ui_create_disp(NULL, &ui);
1466 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1467
1468 ui_wnd_params_init(&params);
1469 params.caption = "Test";
1470
1471 rc = ui_window_create(ui, &params, &window);
1472 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1473
1474 rc = ui_list_create(window, true, &list);
1475 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1476
1477 ui_list_entry_attr_init(&attr);
1478
1479 /* Add one entry */
1480 attr.caption = "a";
1481 attr.arg = (void *)1;
1482 rc = ui_list_entry_append(list, &attr, NULL);
1483 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1484
1485 /* Now try getting its predecessor */
1486 entry = ui_list_last(list);
1487 PCUT_ASSERT_NOT_NULL(entry);
1488
1489 entry = ui_list_prev(entry);
1490 PCUT_ASSERT_NULL(entry);
1491
1492 /* Add another entry */
1493 attr.caption = "b";
1494 attr.arg = (void *)2;
1495 rc = ui_list_entry_append(list, &attr, NULL);
1496 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1497
1498 /* Try getting the predecessor of the new entry */
1499 entry = ui_list_last(list);
1500 PCUT_ASSERT_NOT_NULL(entry);
1501
1502 entry = ui_list_prev(entry);
1503 PCUT_ASSERT_NOT_NULL(entry);
1504 PCUT_ASSERT_STR_EQUALS("a", entry->caption);
1505 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)entry->arg);
1506
1507 ui_list_destroy(list);
1508 ui_window_destroy(window);
1509 ui_destroy(ui);
1510}
1511
1512/** ui_list_page_nth_entry() .. */
1513PCUT_TEST(page_nth_entry)
1514{
1515 ui_t *ui;
1516 ui_window_t *window;
1517 ui_wnd_params_t params;
1518 ui_list_t *list;
1519 ui_list_entry_t *entry;
1520 ui_list_entry_attr_t attr;
1521 gfx_rect_t rect;
1522 size_t idx;
1523 errno_t rc;
1524
1525 rc = ui_create_disp(NULL, &ui);
1526 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1527
1528 ui_wnd_params_init(&params);
1529 params.caption = "Test";
1530
1531 rc = ui_window_create(ui, &params, &window);
1532 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1533
1534 rc = ui_list_create(window, true, &list);
1535 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1536
1537 ui_list_entry_attr_init(&attr);
1538
1539 /* Add some entries */
1540 attr.caption = "a";
1541 attr.arg = (void *)1;
1542 rc = ui_list_entry_append(list, &attr, NULL);
1543 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1544
1545 attr.caption = "b";
1546 attr.arg = (void *)2;
1547 rc = ui_list_entry_append(list, &attr, NULL);
1548 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1549
1550 attr.caption = "c";
1551 attr.arg = (void *)3;
1552 rc = ui_list_entry_append(list, &attr, NULL);
1553 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1554
1555 list->page = ui_list_next(ui_list_first(list));
1556 list->page_idx = 1;
1557
1558 rect.p0.x = 0;
1559 rect.p0.y = 0;
1560 rect.p1.x = 100;
1561 rect.p1.y = 100;
1562 ui_list_set_rect(list, &rect);
1563
1564 entry = ui_list_page_nth_entry(list, 0, &idx);
1565 PCUT_ASSERT_NOT_NULL(entry);
1566 PCUT_ASSERT_STR_EQUALS("b", entry->caption);
1567 PCUT_ASSERT_INT_EQUALS(1, idx);
1568
1569 entry = ui_list_page_nth_entry(list, 1, &idx);
1570 PCUT_ASSERT_NOT_NULL(entry);
1571 PCUT_ASSERT_STR_EQUALS("c", entry->caption);
1572 PCUT_ASSERT_INT_EQUALS(2, idx);
1573
1574 entry = ui_list_page_nth_entry(list, 2, &idx);
1575 PCUT_ASSERT_NULL(entry);
1576
1577 ui_list_destroy(list);
1578 ui_window_destroy(window);
1579 ui_destroy(ui);
1580}
1581
1582/** ui_list_cursor_move() moves cursor and scrolls */
1583PCUT_TEST(cursor_move)
1584{
1585 ui_t *ui;
1586 ui_window_t *window;
1587 ui_wnd_params_t params;
1588 ui_list_t *list;
1589 ui_list_entry_attr_t attr;
1590 gfx_rect_t rect;
1591 errno_t rc;
1592 rc = ui_create_disp(NULL, &ui);
1593 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1594
1595 ui_wnd_params_init(&params);
1596 params.caption = "Test";
1597
1598 rc = ui_window_create(ui, &params, &window);
1599 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1600
1601 rc = ui_list_create(window, true, &list);
1602 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1603
1604 rect.p0.x = 0;
1605 rect.p0.y = 0;
1606 rect.p1.x = 10;
1607 rect.p1.y = 38; /* Assuming this makes page size 2 */
1608 ui_list_set_rect(list, &rect);
1609
1610 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
1611
1612 /* Add tree entries (more than page size, which is 2) */
1613
1614 ui_list_entry_attr_init(&attr);
1615
1616 attr.caption = "a";
1617 attr.arg = (void *)1;
1618 rc = ui_list_entry_append(list, &attr, NULL);
1619 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1620
1621 attr.caption = "b";
1622 attr.arg = (void *)2;
1623 rc = ui_list_entry_append(list, &attr, NULL);
1624 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1625
1626 attr.caption = "c";
1627 attr.arg = (void *)3;
1628 rc = ui_list_entry_append(list, &attr, NULL);
1629 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1630
1631 /* Cursor to the last entry and page start to the next-to-last entry */
1632 list->cursor = ui_list_last(list);
1633 list->cursor_idx = 2;
1634 list->page = ui_list_prev(list->cursor);
1635 list->page_idx = 1;
1636
1637 /* Move cursor one entry up */
1638 ui_list_cursor_move(list, ui_list_prev(list->cursor),
1639 list->cursor_idx - 1);
1640
1641 /* Cursor and page start should now both be at the second entry */
1642 PCUT_ASSERT_STR_EQUALS("b", list->cursor->caption);
1643 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->cursor->arg);
1644 PCUT_ASSERT_INT_EQUALS(1, list->cursor_idx);
1645 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1646 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1647
1648 /* Move cursor to the first entry. This should scroll up. */
1649 ui_list_cursor_move(list, ui_list_first(list), 0);
1650
1651 /* Cursor and page start should now both be at the first entry */
1652 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
1653 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
1654 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
1655 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1656 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
1657
1658 /* Move cursor to the last entry. */
1659 ui_list_cursor_move(list, ui_list_last(list), 2);
1660
1661 /* Cursor should be on the last entry and page on the next to last */
1662 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
1663 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
1664 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
1665 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
1666 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
1667 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1668
1669 ui_list_destroy(list);
1670 ui_window_destroy(window);
1671 ui_destroy(ui);
1672}
1673
1674/** ui_list_cursor_up() moves cursor one entry up */
1675PCUT_TEST(cursor_up)
1676{
1677 ui_t *ui;
1678 ui_window_t *window;
1679 ui_wnd_params_t params;
1680 ui_list_t *list;
1681 ui_list_entry_attr_t attr;
1682 gfx_rect_t rect;
1683 errno_t rc;
1684 rc = ui_create_disp(NULL, &ui);
1685 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1686
1687 ui_wnd_params_init(&params);
1688 params.caption = "Test";
1689
1690 rc = ui_window_create(ui, &params, &window);
1691 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1692
1693 rc = ui_list_create(window, true, &list);
1694 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1695
1696 rect.p0.x = 0;
1697 rect.p0.y = 0;
1698 rect.p1.x = 10;
1699 rect.p1.y = 38; /* Assuming this makes page size 2 */
1700 ui_list_set_rect(list, &rect);
1701
1702 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
1703
1704 /* Add tree entries (more than page size, which is 2) */
1705
1706 ui_list_entry_attr_init(&attr);
1707
1708 attr.caption = "a";
1709 attr.arg = (void *)1;
1710 rc = ui_list_entry_append(list, &attr, NULL);
1711 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1712
1713 attr.caption = "b";
1714 attr.arg = (void *)2;
1715 rc = ui_list_entry_append(list, &attr, NULL);
1716 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1717
1718 attr.caption = "c";
1719 attr.arg = (void *)3;
1720 rc = ui_list_entry_append(list, &attr, NULL);
1721 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1722
1723 /* Cursor to the last entry and page start to the next-to-last entry */
1724 list->cursor = ui_list_last(list);
1725 list->cursor_idx = 2;
1726 list->page = ui_list_prev(list->cursor);
1727 list->page_idx = 1;
1728
1729 /* Move cursor one entry up */
1730 ui_list_cursor_up(list);
1731
1732 /* Cursor and page start should now both be at the second entry */
1733 PCUT_ASSERT_STR_EQUALS("b", list->cursor->caption);
1734 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->cursor->arg);
1735 PCUT_ASSERT_INT_EQUALS(1, list->cursor_idx);
1736 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1737 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1738
1739 /* Move cursor one entry up. This should scroll up. */
1740 ui_list_cursor_up(list);
1741
1742 /* Cursor and page start should now both be at the first entry */
1743 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
1744 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
1745 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
1746 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1747 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
1748
1749 /* Moving further up should do nothing (we are at the top). */
1750 ui_list_cursor_up(list);
1751
1752 /* Cursor and page start should still be at the first entry */
1753 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
1754 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
1755 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
1756 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1757 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
1758
1759 ui_list_destroy(list);
1760 ui_window_destroy(window);
1761 ui_destroy(ui);
1762}
1763
1764/** ui_list_cursor_down() moves cursor one entry down */
1765PCUT_TEST(cursor_down)
1766{
1767 ui_t *ui;
1768 ui_window_t *window;
1769 ui_wnd_params_t params;
1770 ui_list_t *list;
1771 ui_list_entry_attr_t attr;
1772 gfx_rect_t rect;
1773 errno_t rc;
1774
1775 rc = ui_create_disp(NULL, &ui);
1776 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1777
1778 ui_wnd_params_init(&params);
1779 params.caption = "Test";
1780
1781 rc = ui_window_create(ui, &params, &window);
1782 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1783
1784 rc = ui_list_create(window, true, &list);
1785 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1786
1787 rect.p0.x = 0;
1788 rect.p0.y = 0;
1789 rect.p1.x = 10;
1790 rect.p1.y = 38; /* Assuming this makes page size 2 */
1791 ui_list_set_rect(list, &rect);
1792
1793 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
1794
1795 /* Add tree entries (more than page size, which is 2) */
1796
1797 ui_list_entry_attr_init(&attr);
1798
1799 attr.caption = "a";
1800 attr.arg = (void *)1;
1801 rc = ui_list_entry_append(list, &attr, NULL);
1802 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1803
1804 attr.caption = "b";
1805 attr.arg = (void *)2;
1806 rc = ui_list_entry_append(list, &attr, NULL);
1807 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1808
1809 attr.caption = "c";
1810 attr.arg = (void *)3;
1811 rc = ui_list_entry_append(list, &attr, NULL);
1812 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1813
1814 /* Cursor and page start to the first entry */
1815 list->cursor = ui_list_first(list);
1816 list->cursor_idx = 0;
1817 list->page = list->cursor;
1818 list->page_idx = 0;
1819
1820 /* Move cursor one entry down */
1821 ui_list_cursor_down(list);
1822
1823 /* Cursor should now be at the second entry, page stays the same */
1824 PCUT_ASSERT_STR_EQUALS("b", list->cursor->caption);
1825 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->cursor->arg);
1826 PCUT_ASSERT_INT_EQUALS(1, list->cursor_idx);
1827 PCUT_ASSERT_EQUALS(ui_list_first(list), list->page);
1828 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
1829
1830 /* Move cursor one entry down. This should scroll down. */
1831 ui_list_cursor_down(list);
1832
1833 /* Cursor should now be at the third and page at the second entry. */
1834 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
1835 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
1836 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
1837 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
1838 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
1839 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1840
1841 /* Moving further down should do nothing (we are at the bottom). */
1842 ui_list_cursor_down(list);
1843
1844 /* Cursor should still be at the third and page at the second entry. */
1845 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
1846 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
1847 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
1848 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
1849 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
1850 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1851
1852 ui_list_destroy(list);
1853 ui_window_destroy(window);
1854 ui_destroy(ui);
1855}
1856
1857/** ui_list_cursor_top() moves cursor to the first entry */
1858PCUT_TEST(cursor_top)
1859{
1860 ui_t *ui;
1861 ui_window_t *window;
1862 ui_wnd_params_t params;
1863 ui_list_t *list;
1864 ui_list_entry_attr_t attr;
1865 gfx_rect_t rect;
1866 errno_t rc;
1867
1868 rc = ui_create_disp(NULL, &ui);
1869 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1870
1871 ui_wnd_params_init(&params);
1872 params.caption = "Test";
1873
1874 rc = ui_window_create(ui, &params, &window);
1875 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1876
1877 rc = ui_list_create(window, true, &list);
1878 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1879
1880 rect.p0.x = 0;
1881 rect.p0.y = 0;
1882 rect.p1.x = 10;
1883 rect.p1.y = 38; /* Assuming this makes page size 2 */
1884 ui_list_set_rect(list, &rect);
1885
1886 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
1887
1888 /* Add tree entries (more than page size, which is 2) */
1889
1890 ui_list_entry_attr_init(&attr);
1891
1892 attr.caption = "a";
1893 attr.arg = (void *)1;
1894 rc = ui_list_entry_append(list, &attr, NULL);
1895 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1896
1897 attr.caption = "b";
1898 attr.arg = (void *)2;
1899 rc = ui_list_entry_append(list, &attr, NULL);
1900 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1901
1902 attr.caption = "c";
1903 attr.arg = (void *)3;
1904 rc = ui_list_entry_append(list, &attr, NULL);
1905 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1906
1907 /* Cursor to the last entry and page start to the next-to-last entry */
1908 list->cursor = ui_list_last(list);
1909 list->cursor_idx = 2;
1910 list->page = ui_list_prev(list->cursor);
1911 list->page_idx = 1;
1912
1913 /* Move cursor to the top. This should scroll up. */
1914 ui_list_cursor_top(list);
1915
1916 /* Cursor and page start should now both be at the first entry */
1917 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
1918 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
1919 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
1920 PCUT_ASSERT_EQUALS(list->cursor, list->page);
1921 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
1922
1923 ui_list_destroy(list);
1924 ui_window_destroy(window);
1925 ui_destroy(ui);
1926}
1927
1928/** ui_list_cursor_bottom() moves cursor to the last entry */
1929PCUT_TEST(cursor_bottom)
1930{
1931 ui_t *ui;
1932 ui_window_t *window;
1933 ui_wnd_params_t params;
1934 ui_list_t *list;
1935 ui_list_entry_attr_t attr;
1936 gfx_rect_t rect;
1937 errno_t rc;
1938
1939 rc = ui_create_disp(NULL, &ui);
1940 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1941
1942 ui_wnd_params_init(&params);
1943 params.caption = "Test";
1944
1945 rc = ui_window_create(ui, &params, &window);
1946 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1947
1948 rc = ui_list_create(window, true, &list);
1949 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1950
1951 rect.p0.x = 0;
1952 rect.p0.y = 0;
1953 rect.p1.x = 10;
1954 rect.p1.y = 38; /* Assuming this makes page size 2 */
1955 ui_list_set_rect(list, &rect);
1956
1957 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
1958
1959 /* Add tree entries (more than page size, which is 2) */
1960
1961 ui_list_entry_attr_init(&attr);
1962
1963 attr.caption = "a";
1964 attr.arg = (void *)1;
1965 rc = ui_list_entry_append(list, &attr, NULL);
1966 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1967
1968 attr.caption = "b";
1969 attr.arg = (void *)2;
1970 rc = ui_list_entry_append(list, &attr, NULL);
1971 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1972
1973 attr.caption = "c";
1974 attr.arg = (void *)3;
1975 rc = ui_list_entry_append(list, &attr, NULL);
1976 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1977
1978 /* Cursor and page start to the first entry */
1979 list->cursor = ui_list_first(list);
1980 list->cursor_idx = 0;
1981 list->page = list->cursor;
1982 list->page_idx = 0;
1983
1984 /* Move cursor to the bottom. This should scroll down. */
1985 ui_list_cursor_bottom(list);
1986
1987 /* Cursor should now be at the third and page at the second entry. */
1988 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
1989 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
1990 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
1991 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
1992 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
1993 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
1994
1995 ui_list_destroy(list);
1996 ui_window_destroy(window);
1997 ui_destroy(ui);
1998}
1999
2000/** ui_list_page_up() moves one page up */
2001PCUT_TEST(page_up)
2002{
2003 ui_t *ui;
2004 ui_window_t *window;
2005 ui_wnd_params_t params;
2006 ui_list_t *list;
2007 ui_list_entry_attr_t attr;
2008 gfx_rect_t rect;
2009 errno_t rc;
2010
2011 rc = ui_create_disp(NULL, &ui);
2012 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2013
2014 ui_wnd_params_init(&params);
2015 params.caption = "Test";
2016
2017 rc = ui_window_create(ui, &params, &window);
2018 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2019
2020 rc = ui_list_create(window, true, &list);
2021 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2022
2023 rect.p0.x = 0;
2024 rect.p0.y = 0;
2025 rect.p1.x = 10;
2026 rect.p1.y = 38; /* Assuming this makes page size 2 */
2027 ui_list_set_rect(list, &rect);
2028
2029 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2030
2031 /* Add five entries (2 full pages, one partial) */
2032
2033 ui_list_entry_attr_init(&attr);
2034
2035 attr.caption = "a";
2036 attr.arg = (void *)1;
2037 rc = ui_list_entry_append(list, &attr, NULL);
2038 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2039
2040 attr.caption = "b";
2041 attr.arg = (void *)2;
2042 rc = ui_list_entry_append(list, &attr, NULL);
2043 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2044
2045 attr.caption = "c";
2046 attr.arg = (void *)3;
2047 rc = ui_list_entry_append(list, &attr, NULL);
2048 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2049
2050 attr.caption = "d";
2051 attr.arg = (void *)4;
2052 rc = ui_list_entry_append(list, &attr, NULL);
2053 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2054
2055 attr.caption = "e";
2056 attr.arg = (void *)5;
2057 rc = ui_list_entry_append(list, &attr, NULL);
2058 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2059
2060 /* Cursor to the last entry and page start to the next-to-last entry */
2061 list->cursor = ui_list_last(list);
2062 list->cursor_idx = 4;
2063 list->page = ui_list_prev(list->cursor);
2064 list->page_idx = 3;
2065
2066 /* Move one page up */
2067 ui_list_page_up(list);
2068
2069 /* Page should now start at second entry and cursor at third */
2070 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
2071 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
2072 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
2073 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
2074 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
2075 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
2076
2077 /* Move one page up again. */
2078 ui_list_page_up(list);
2079
2080 /* Cursor and page start should now both be at the first entry */
2081 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2082 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2083 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2084 PCUT_ASSERT_EQUALS(list->cursor, list->page);
2085 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2086
2087 /* Moving further up should do nothing (we are at the top). */
2088 ui_list_page_up(list);
2089
2090 /* Cursor and page start should still be at the first entry */
2091 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2092 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2093 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2094 PCUT_ASSERT_EQUALS(list->cursor, list->page);
2095 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2096
2097 ui_list_destroy(list);
2098 ui_window_destroy(window);
2099 ui_destroy(ui);
2100}
2101
2102/** ui_list_page_up() moves one page down */
2103PCUT_TEST(page_down)
2104{
2105 ui_t *ui;
2106 ui_window_t *window;
2107 ui_wnd_params_t params;
2108 ui_list_t *list;
2109 ui_list_entry_attr_t attr;
2110 gfx_rect_t rect;
2111 errno_t rc;
2112
2113 rc = ui_create_disp(NULL, &ui);
2114 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2115
2116 ui_wnd_params_init(&params);
2117 params.caption = "Test";
2118
2119 rc = ui_window_create(ui, &params, &window);
2120 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2121
2122 rc = ui_list_create(window, true, &list);
2123 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2124
2125 rect.p0.x = 0;
2126 rect.p0.y = 0;
2127 rect.p1.x = 10;
2128 rect.p1.y = 38; /* Assuming this makes page size 2 */
2129 ui_list_set_rect(list, &rect);
2130
2131 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2132
2133 /* Add five entries (2 full pages, one partial) */
2134
2135 ui_list_entry_attr_init(&attr);
2136
2137 attr.caption = "a";
2138 attr.arg = (void *)1;
2139 rc = ui_list_entry_append(list, &attr, NULL);
2140 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2141
2142 attr.caption = "b";
2143 attr.arg = (void *)2;
2144 rc = ui_list_entry_append(list, &attr, NULL);
2145 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2146
2147 attr.caption = "c";
2148 attr.arg = (void *)3;
2149 rc = ui_list_entry_append(list, &attr, NULL);
2150 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2151
2152 attr.caption = "d";
2153 attr.arg = (void *)4;
2154 rc = ui_list_entry_append(list, &attr, NULL);
2155 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2156
2157 attr.caption = "e";
2158 attr.arg = (void *)5;
2159 rc = ui_list_entry_append(list, &attr, NULL);
2160 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2161
2162 /* Cursor and page to the first entry */
2163 list->cursor = ui_list_first(list);
2164 list->cursor_idx = 0;
2165 list->page = list->cursor;
2166 list->page_idx = 0;
2167
2168 /* Move one page down */
2169 ui_list_page_down(list);
2170
2171 /* Page and cursor should point to the third entry */
2172 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
2173 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
2174 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
2175 PCUT_ASSERT_STR_EQUALS("c", list->page->caption);
2176 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->page->arg);
2177 PCUT_ASSERT_INT_EQUALS(2, list->page_idx);
2178
2179 /* Move one page down again. */
2180 ui_list_page_down(list);
2181
2182 /* Cursor should point to last and page to next-to-last entry */
2183 PCUT_ASSERT_STR_EQUALS("e", list->cursor->caption);
2184 PCUT_ASSERT_INT_EQUALS(5, (intptr_t)list->cursor->arg);
2185 PCUT_ASSERT_INT_EQUALS(4, list->cursor_idx);
2186 PCUT_ASSERT_STR_EQUALS("d", list->page->caption);
2187 PCUT_ASSERT_INT_EQUALS(4, (intptr_t)list->page->arg);
2188 PCUT_ASSERT_INT_EQUALS(3, list->page_idx);
2189
2190 /* Moving further down should do nothing (we are at the bottom). */
2191 ui_list_page_down(list);
2192
2193 /* Cursor should still point to last and page to next-to-last entry */
2194 PCUT_ASSERT_STR_EQUALS("e", list->cursor->caption);
2195 PCUT_ASSERT_INT_EQUALS(5, (intptr_t)list->cursor->arg);
2196 PCUT_ASSERT_INT_EQUALS(4, list->cursor_idx);
2197 PCUT_ASSERT_STR_EQUALS("d", list->page->caption);
2198 PCUT_ASSERT_INT_EQUALS(4, (intptr_t)list->page->arg);
2199 PCUT_ASSERT_INT_EQUALS(3, list->page_idx);
2200
2201 ui_list_destroy(list);
2202 ui_window_destroy(window);
2203 ui_destroy(ui);
2204}
2205
2206/** ui_list_scroll_up() scrolls up by one row */
2207PCUT_TEST(scroll_up)
2208{
2209 ui_t *ui;
2210 ui_window_t *window;
2211 ui_wnd_params_t params;
2212 ui_list_t *list;
2213 ui_list_entry_attr_t attr;
2214 gfx_rect_t rect;
2215 errno_t rc;
2216
2217 rc = ui_create_disp(NULL, &ui);
2218 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2219
2220 ui_wnd_params_init(&params);
2221 params.caption = "Test";
2222
2223 rc = ui_window_create(ui, &params, &window);
2224 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2225
2226 rc = ui_list_create(window, true, &list);
2227 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2228
2229 rect.p0.x = 0;
2230 rect.p0.y = 0;
2231 rect.p1.x = 10;
2232 rect.p1.y = 38; /* Assuming this makes page size 2 */
2233 ui_list_set_rect(list, &rect);
2234
2235 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2236
2237 /* Add tree entries (more than page size, which is 2) */
2238
2239 ui_list_entry_attr_init(&attr);
2240
2241 attr.caption = "a";
2242 attr.arg = (void *)1;
2243 rc = ui_list_entry_append(list, &attr, NULL);
2244 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2245
2246 attr.caption = "b";
2247 attr.arg = (void *)2;
2248 rc = ui_list_entry_append(list, &attr, NULL);
2249 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2250
2251 attr.caption = "c";
2252 attr.arg = (void *)3;
2253 rc = ui_list_entry_append(list, &attr, NULL);
2254 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2255
2256 /* Cursor to the last entry, page to the second */
2257 list->cursor = ui_list_last(list);
2258 list->cursor_idx = 2;
2259 list->page = ui_list_prev(list->cursor);
2260 list->page_idx = 1;
2261
2262 /* Scroll one entry up */
2263 ui_list_scroll_up(list);
2264
2265 /* Page should start on the first entry, cursor unchanged */
2266 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
2267 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
2268 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
2269 PCUT_ASSERT_STR_EQUALS("a", list->page->caption);
2270 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->page->arg);
2271 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2272
2273 /* Try scrolling one more entry up */
2274 ui_list_scroll_up(list);
2275
2276 /* We were at the beginning, so nothing should have changed */
2277 PCUT_ASSERT_STR_EQUALS("c", list->cursor->caption);
2278 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->cursor->arg);
2279 PCUT_ASSERT_INT_EQUALS(2, list->cursor_idx);
2280 PCUT_ASSERT_STR_EQUALS("a", list->page->caption);
2281 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->page->arg);
2282 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2283
2284 ui_list_destroy(list);
2285 ui_window_destroy(window);
2286 ui_destroy(ui);
2287}
2288
2289/** ui_list_scroll_down() scrolls down by one row */
2290PCUT_TEST(scroll_down)
2291{
2292 ui_t *ui;
2293 ui_window_t *window;
2294 ui_wnd_params_t params;
2295 ui_list_t *list;
2296 ui_list_entry_attr_t attr;
2297 gfx_rect_t rect;
2298 errno_t rc;
2299
2300 rc = ui_create_disp(NULL, &ui);
2301 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2302
2303 ui_wnd_params_init(&params);
2304 params.caption = "Test";
2305
2306 rc = ui_window_create(ui, &params, &window);
2307 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2308
2309 rc = ui_list_create(window, true, &list);
2310 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2311
2312 rect.p0.x = 0;
2313 rect.p0.y = 0;
2314 rect.p1.x = 10;
2315 rect.p1.y = 38; /* Assuming this makes page size 2 */
2316 ui_list_set_rect(list, &rect);
2317
2318 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2319
2320 /* Add tree entries (more than page size, which is 2) */
2321
2322 ui_list_entry_attr_init(&attr);
2323
2324 attr.caption = "a";
2325 attr.arg = (void *)1;
2326 rc = ui_list_entry_append(list, &attr, NULL);
2327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2328
2329 attr.caption = "b";
2330 attr.arg = (void *)2;
2331 rc = ui_list_entry_append(list, &attr, NULL);
2332 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2333
2334 attr.caption = "c";
2335 attr.arg = (void *)3;
2336 rc = ui_list_entry_append(list, &attr, NULL);
2337 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2338
2339 /* Cursor and page start to the first entry */
2340 list->cursor = ui_list_first(list);
2341 list->cursor_idx = 0;
2342 list->page = list->cursor;
2343 list->page_idx = 0;
2344
2345 /* Scroll one entry down */
2346 ui_list_scroll_down(list);
2347
2348 /* Page should start on the second entry, cursor unchanged */
2349 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2350 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2351 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2352 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
2353 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
2354 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
2355
2356 /* Try scrolling one more entry down */
2357 ui_list_scroll_down(list);
2358
2359 /* We were at the end, so nothing should have changed */
2360 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2361 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2362 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2363 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
2364 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
2365 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
2366
2367 ui_list_destroy(list);
2368 ui_window_destroy(window);
2369 ui_destroy(ui);
2370}
2371
2372/** ui_list_scroll_page_up() scrolls up by one page */
2373PCUT_TEST(scroll_page_up)
2374{
2375 ui_t *ui;
2376 ui_window_t *window;
2377 ui_wnd_params_t params;
2378 ui_list_t *list;
2379 ui_list_entry_attr_t attr;
2380 gfx_rect_t rect;
2381 errno_t rc;
2382
2383 rc = ui_create_disp(NULL, &ui);
2384 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2385
2386 ui_wnd_params_init(&params);
2387 params.caption = "Test";
2388
2389 rc = ui_window_create(ui, &params, &window);
2390 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2391
2392 rc = ui_list_create(window, true, &list);
2393 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2394
2395 rect.p0.x = 0;
2396 rect.p0.y = 0;
2397 rect.p1.x = 10;
2398 rect.p1.y = 38; /* Assuming this makes page size 2 */
2399 ui_list_set_rect(list, &rect);
2400
2401 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2402
2403 /* Add five entries (more than twice the page size, which is 2) */
2404
2405 ui_list_entry_attr_init(&attr);
2406
2407 attr.caption = "a";
2408 attr.arg = (void *)1;
2409 rc = ui_list_entry_append(list, &attr, NULL);
2410 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2411
2412 attr.caption = "b";
2413 attr.arg = (void *)2;
2414 rc = ui_list_entry_append(list, &attr, NULL);
2415 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2416
2417 attr.caption = "c";
2418 attr.arg = (void *)3;
2419 rc = ui_list_entry_append(list, &attr, NULL);
2420 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2421
2422 attr.caption = "d";
2423 attr.arg = (void *)4;
2424 rc = ui_list_entry_append(list, &attr, NULL);
2425 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2426
2427 attr.caption = "e";
2428 attr.arg = (void *)5;
2429 rc = ui_list_entry_append(list, &attr, NULL);
2430 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2431
2432 /* Cursor to the last entry, page to the second last */
2433 list->cursor = ui_list_last(list);
2434 list->cursor_idx = 4;
2435 list->page = ui_list_prev(list->cursor);
2436 list->page_idx = 3;
2437
2438 /* Scroll one page up */
2439 ui_list_scroll_page_up(list);
2440
2441 /* Page should start on 'b', cursor unchanged */
2442 PCUT_ASSERT_STR_EQUALS("e", list->cursor->caption);
2443 PCUT_ASSERT_INT_EQUALS(5, (intptr_t)list->cursor->arg);
2444 PCUT_ASSERT_INT_EQUALS(4, list->cursor_idx);
2445 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
2446 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
2447 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
2448
2449 /* Page up again */
2450 ui_list_scroll_page_up(list);
2451
2452 /* Page should now be at the beginning, cursor unchanged */
2453 PCUT_ASSERT_STR_EQUALS("e", list->cursor->caption);
2454 PCUT_ASSERT_INT_EQUALS(5, (intptr_t)list->cursor->arg);
2455 PCUT_ASSERT_INT_EQUALS(4, list->cursor_idx);
2456 PCUT_ASSERT_STR_EQUALS("a", list->page->caption);
2457 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->page->arg);
2458 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2459
2460 /* Page up again */
2461 ui_list_scroll_page_up(list);
2462
2463 /* We were at the beginning, nothing should have changed */
2464 PCUT_ASSERT_STR_EQUALS("e", list->cursor->caption);
2465 PCUT_ASSERT_INT_EQUALS(5, (intptr_t)list->cursor->arg);
2466 PCUT_ASSERT_INT_EQUALS(4, list->cursor_idx);
2467 PCUT_ASSERT_STR_EQUALS("a", list->page->caption);
2468 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->page->arg);
2469 PCUT_ASSERT_INT_EQUALS(0, list->page_idx);
2470
2471 ui_list_destroy(list);
2472 ui_window_destroy(window);
2473 ui_destroy(ui);
2474}
2475
2476/** ui_list_scroll_page_up() scrolls down by one page */
2477PCUT_TEST(scroll_page_down)
2478{
2479 ui_t *ui;
2480 ui_window_t *window;
2481 ui_wnd_params_t params;
2482 ui_list_t *list;
2483 ui_list_entry_attr_t attr;
2484 gfx_rect_t rect;
2485 errno_t rc;
2486
2487 rc = ui_create_disp(NULL, &ui);
2488 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2489
2490 ui_wnd_params_init(&params);
2491 params.caption = "Test";
2492
2493 rc = ui_window_create(ui, &params, &window);
2494 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2495
2496 rc = ui_list_create(window, true, &list);
2497 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2498
2499 rect.p0.x = 0;
2500 rect.p0.y = 0;
2501 rect.p1.x = 10;
2502 rect.p1.y = 38; /* Assuming this makes page size 2 */
2503 ui_list_set_rect(list, &rect);
2504
2505 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2506
2507 /* Add five entries (more than twice the page size, which is 2) */
2508
2509 ui_list_entry_attr_init(&attr);
2510
2511 attr.caption = "a";
2512 attr.arg = (void *)1;
2513 rc = ui_list_entry_append(list, &attr, NULL);
2514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2515
2516 attr.caption = "b";
2517 attr.arg = (void *)2;
2518 rc = ui_list_entry_append(list, &attr, NULL);
2519 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2520
2521 attr.caption = "c";
2522 attr.arg = (void *)3;
2523 rc = ui_list_entry_append(list, &attr, NULL);
2524 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2525
2526 attr.caption = "d";
2527 attr.arg = (void *)4;
2528 rc = ui_list_entry_append(list, &attr, NULL);
2529 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2530
2531 attr.caption = "e";
2532 attr.arg = (void *)5;
2533 rc = ui_list_entry_append(list, &attr, NULL);
2534 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2535
2536 /* Cursor and page to the first entry */
2537 list->cursor = ui_list_first(list);
2538 list->cursor_idx = 0;
2539 list->page = ui_list_first(list);
2540 list->page_idx = 0;
2541
2542 /* Scroll one page down */
2543 ui_list_scroll_page_down(list);
2544
2545 /* Page should start on 'c', cursor unchanged */
2546 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2547 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2548 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2549 PCUT_ASSERT_STR_EQUALS("c", list->page->caption);
2550 PCUT_ASSERT_INT_EQUALS(3, (intptr_t)list->page->arg);
2551 PCUT_ASSERT_INT_EQUALS(2, list->page_idx);
2552
2553 /* Page down again */
2554 ui_list_scroll_page_down(list);
2555
2556 /* Page should now start at 'd', cursor unchanged */
2557 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2558 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2559 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2560 PCUT_ASSERT_STR_EQUALS("d", list->page->caption);
2561 PCUT_ASSERT_INT_EQUALS(4, (intptr_t)list->page->arg);
2562 PCUT_ASSERT_INT_EQUALS(3, list->page_idx);
2563
2564 /* Page down again */
2565 ui_list_scroll_page_down(list);
2566
2567 /* We were at the end, nothing should have changed */
2568 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2569 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2570 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2571 PCUT_ASSERT_STR_EQUALS("d", list->page->caption);
2572 PCUT_ASSERT_INT_EQUALS(4, (intptr_t)list->page->arg);
2573 PCUT_ASSERT_INT_EQUALS(3, list->page_idx);
2574
2575 ui_list_destroy(list);
2576 ui_window_destroy(window);
2577 ui_destroy(ui);
2578}
2579
2580/** ui_list_scroll_pos() scrolls to a particular entry */
2581PCUT_TEST(scroll_pos)
2582{
2583 ui_t *ui;
2584 ui_window_t *window;
2585 ui_wnd_params_t params;
2586 ui_list_t *list;
2587 ui_list_entry_attr_t attr;
2588 gfx_rect_t rect;
2589 errno_t rc;
2590
2591 rc = ui_create_disp(NULL, &ui);
2592 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2593
2594 ui_wnd_params_init(&params);
2595 params.caption = "Test";
2596
2597 rc = ui_window_create(ui, &params, &window);
2598 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2599
2600 rc = ui_list_create(window, true, &list);
2601 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2602
2603 rect.p0.x = 0;
2604 rect.p0.y = 0;
2605 rect.p1.x = 10;
2606 rect.p1.y = 38; /* Assuming this makes page size 2 */
2607 ui_list_set_rect(list, &rect);
2608
2609 PCUT_ASSERT_INT_EQUALS(2, ui_list_page_size(list));
2610
2611 /* Add five entries (more than twice the page size, which is 2) */
2612
2613 ui_list_entry_attr_init(&attr);
2614
2615 attr.caption = "a";
2616 attr.arg = (void *)1;
2617 rc = ui_list_entry_append(list, &attr, NULL);
2618 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2619
2620 attr.caption = "b";
2621 attr.arg = (void *)2;
2622 rc = ui_list_entry_append(list, &attr, NULL);
2623 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2624
2625 attr.caption = "c";
2626 attr.arg = (void *)3;
2627 rc = ui_list_entry_append(list, &attr, NULL);
2628 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2629
2630 attr.caption = "d";
2631 attr.arg = (void *)4;
2632 rc = ui_list_entry_append(list, &attr, NULL);
2633 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2634
2635 attr.caption = "e";
2636 attr.arg = (void *)5;
2637 rc = ui_list_entry_append(list, &attr, NULL);
2638 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2639
2640 /* Cursor and page to the first entry */
2641 list->cursor = ui_list_first(list);
2642 list->cursor_idx = 0;
2643 list->page = ui_list_first(list);
2644 list->page_idx = 0;
2645
2646 /* Scroll to entry 1 (one down) */
2647 ui_list_scroll_pos(list, 1);
2648
2649 /* Page should start on 'b', cursor unchanged */
2650 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2651 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2652 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2653 PCUT_ASSERT_STR_EQUALS("b", list->page->caption);
2654 PCUT_ASSERT_INT_EQUALS(2, (intptr_t)list->page->arg);
2655 PCUT_ASSERT_INT_EQUALS(1, list->page_idx);
2656
2657 /* Scroll to entry 3 (i.e. the end) */
2658 ui_list_scroll_pos(list, 3);
2659
2660 /* Page should now start at 'd', cursor unchanged */
2661 PCUT_ASSERT_STR_EQUALS("a", list->cursor->caption);
2662 PCUT_ASSERT_INT_EQUALS(1, (intptr_t)list->cursor->arg);
2663 PCUT_ASSERT_INT_EQUALS(0, list->cursor_idx);
2664 PCUT_ASSERT_STR_EQUALS("d", list->page->caption);
2665 PCUT_ASSERT_INT_EQUALS(4, (intptr_t)list->page->arg);
2666 PCUT_ASSERT_INT_EQUALS(3, list->page_idx);
2667
2668 ui_list_destroy(list);
2669 ui_window_destroy(window);
2670 ui_destroy(ui);
2671}
2672
2673/** ui_list_activate_req() sends activation request */
2674PCUT_TEST(activate_req)
2675{
2676 ui_t *ui;
2677 ui_window_t *window;
2678 ui_wnd_params_t params;
2679 ui_list_t *list;
2680 errno_t rc;
2681 test_resp_t resp;
2682
2683 rc = ui_create_disp(NULL, &ui);
2684 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2685
2686 ui_wnd_params_init(&params);
2687 params.caption = "Test";
2688
2689 rc = ui_window_create(ui, &params, &window);
2690 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2691
2692 rc = ui_list_create(window, true, &list);
2693 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2694
2695 ui_list_set_cb(list, &test_cb, &resp);
2696
2697 resp.activate_req = false;
2698 resp.activate_req_list = NULL;
2699
2700 ui_list_activate_req(list);
2701 PCUT_ASSERT_TRUE(resp.activate_req);
2702 PCUT_ASSERT_EQUALS(list, resp.activate_req_list);
2703
2704 ui_list_destroy(list);
2705 ui_window_destroy(window);
2706 ui_destroy(ui);
2707}
2708
2709/** ui_list_selected() runs selected callback */
2710PCUT_TEST(selected)
2711{
2712 ui_t *ui;
2713 ui_window_t *window;
2714 ui_wnd_params_t params;
2715 ui_list_t *list;
2716 ui_list_entry_attr_t attr;
2717 ui_list_entry_t *entry;
2718 errno_t rc;
2719 test_resp_t resp;
2720
2721 rc = ui_create_disp(NULL, &ui);
2722 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2723
2724 ui_wnd_params_init(&params);
2725 params.caption = "Test";
2726
2727 rc = ui_window_create(ui, &params, &window);
2728 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2729
2730 rc = ui_list_create(window, true, &list);
2731 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2732
2733 ui_list_set_cb(list, &test_cb, &resp);
2734
2735 ui_list_entry_attr_init(&attr);
2736 attr.caption = "Hello";
2737 attr.arg = &resp;
2738
2739 rc = ui_list_entry_append(list, &attr, &entry);
2740 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2741
2742 resp.selected = false;
2743 resp.selected_entry = NULL;
2744
2745 ui_list_selected(entry);
2746 PCUT_ASSERT_TRUE(resp.selected);
2747 PCUT_ASSERT_EQUALS(entry, resp.selected_entry);
2748
2749 ui_list_destroy(list);
2750 ui_window_destroy(window);
2751 ui_destroy(ui);
2752}
2753
2754/** ui_list_entry_ptr_cmp compares two indirectly referenced entries */
2755PCUT_TEST(entry_ptr_cmp)
2756{
2757 ui_t *ui;
2758 ui_window_t *window;
2759 ui_wnd_params_t params;
2760 ui_list_t *list;
2761 ui_list_entry_t *a, *b;
2762 ui_list_entry_attr_t attr;
2763 test_resp_t resp;
2764 int rel;
2765 errno_t rc;
2766
2767 rc = ui_create_disp(NULL, &ui);
2768 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2769
2770 ui_wnd_params_init(&params);
2771 params.caption = "Test";
2772
2773 rc = ui_window_create(ui, &params, &window);
2774 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2775
2776 rc = ui_list_create(window, true, &list);
2777 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2778
2779 ui_list_set_cb(list, &test_cb, &resp);
2780
2781 ui_list_entry_attr_init(&attr);
2782
2783 attr.caption = "a";
2784 attr.arg = (void *)2;
2785 rc = ui_list_entry_append(list, &attr, NULL);
2786 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2787
2788 attr.caption = "b";
2789 attr.arg = (void *)1;
2790 rc = ui_list_entry_append(list, &attr, NULL);
2791 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2792
2793 a = ui_list_first(list);
2794 PCUT_ASSERT_NOT_NULL(a);
2795 b = ui_list_next(a);
2796 PCUT_ASSERT_NOT_NULL(b);
2797
2798 /* a < b */
2799 rel = ui_list_entry_ptr_cmp(&a, &b);
2800 PCUT_ASSERT_TRUE(rel < 0);
2801
2802 /* b > a */
2803 rel = ui_list_entry_ptr_cmp(&b, &a);
2804 PCUT_ASSERT_TRUE(rel > 0);
2805
2806 /* a == a */
2807 rel = ui_list_entry_ptr_cmp(&a, &a);
2808 PCUT_ASSERT_INT_EQUALS(0, rel);
2809
2810 ui_list_destroy(list);
2811 ui_window_destroy(window);
2812 ui_destroy(ui);
2813}
2814
2815/** ui_list_entry_get_idx() returns entry index */
2816PCUT_TEST(entry_get_idx)
2817{
2818 ui_t *ui;
2819 ui_window_t *window;
2820 ui_wnd_params_t params;
2821 ui_list_t *list;
2822 ui_list_entry_t *a, *b;
2823 ui_list_entry_attr_t attr;
2824 test_resp_t resp;
2825 errno_t rc;
2826
2827 rc = ui_create_disp(NULL, &ui);
2828 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2829
2830 ui_wnd_params_init(&params);
2831 params.caption = "Test";
2832
2833 rc = ui_window_create(ui, &params, &window);
2834 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2835
2836 rc = ui_list_create(window, true, &list);
2837 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2838
2839 ui_list_set_cb(list, &test_cb, &resp);
2840
2841 ui_list_entry_attr_init(&attr);
2842
2843 attr.caption = "a";
2844 attr.arg = (void *)2;
2845 rc = ui_list_entry_append(list, &attr, &a);
2846 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2847
2848 attr.caption = "b";
2849 attr.arg = (void *)1;
2850 rc = ui_list_entry_append(list, &attr, &b);
2851 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
2852
2853 PCUT_ASSERT_INT_EQUALS(0, ui_list_entry_get_idx(a));
2854 PCUT_ASSERT_INT_EQUALS(1, ui_list_entry_get_idx(b));
2855
2856 ui_list_destroy(list);
2857 ui_window_destroy(window);
2858 ui_destroy(ui);
2859}
2860
2861static void test_list_activate_req(ui_list_t *list, void *arg)
2862{
2863 test_resp_t *resp = (test_resp_t *)arg;
2864
2865 resp->activate_req = true;
2866 resp->activate_req_list = list;
2867}
2868
2869static void test_list_selected(ui_list_entry_t *entry, void *arg)
2870{
2871 test_resp_t *resp = (test_resp_t *)arg;
2872
2873 resp->selected = true;
2874 resp->selected_entry = entry;
2875}
2876
2877static int test_list_compare(ui_list_entry_t *a, ui_list_entry_t *b)
2878{
2879 return str_cmp(a->caption, b->caption);
2880}
2881
2882PCUT_EXPORT(list);
Note: See TracBrowser for help on using the repository browser.