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

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

Scrollbar unit tests
  • Property mode set to 100644
File size: 24.0 KB
Line 
1/*
2 * Copyright (c) 2022 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 <mem.h>
32#include <pcut/pcut.h>
33#include <stdbool.h>
34#include <ui/control.h>
35#include <ui/scrollbar.h>
36#include <ui/resource.h>
37#include "../private/pbutton.h"
38#include "../private/scrollbar.h"
39
40PCUT_INIT;
41
42PCUT_TEST_SUITE(scrollbar);
43
44static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
45static errno_t testgc_set_color(void *, gfx_color_t *);
46static errno_t testgc_fill_rect(void *, gfx_rect_t *);
47static errno_t testgc_update(void *);
48static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
49 gfx_bitmap_alloc_t *, void **);
50static errno_t testgc_bitmap_destroy(void *);
51static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
52static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
53
54static gfx_context_ops_t ops = {
55 .set_clip_rect = testgc_set_clip_rect,
56 .set_color = testgc_set_color,
57 .fill_rect = testgc_fill_rect,
58 .update = testgc_update,
59 .bitmap_create = testgc_bitmap_create,
60 .bitmap_destroy = testgc_bitmap_destroy,
61 .bitmap_render = testgc_bitmap_render,
62 .bitmap_get_alloc = testgc_bitmap_get_alloc
63};
64
65static void test_scrollbar_up(ui_scrollbar_t *, void *);
66static void test_scrollbar_down(ui_scrollbar_t *, void *);
67static void test_scrollbar_moved(ui_scrollbar_t *, void *, gfx_coord_t);
68
69static ui_scrollbar_cb_t test_scrollbar_cb = {
70 .up = test_scrollbar_up,
71 .down = test_scrollbar_down,
72 .moved = test_scrollbar_moved
73};
74
75static ui_scrollbar_cb_t dummy_scrollbar_cb = {
76};
77
78typedef struct {
79 bool bm_created;
80 bool bm_destroyed;
81 gfx_bitmap_params_t bm_params;
82 void *bm_pixels;
83 gfx_rect_t bm_srect;
84 gfx_coord2_t bm_offs;
85 bool bm_rendered;
86 bool bm_got_alloc;
87} test_gc_t;
88
89typedef struct {
90 test_gc_t *tgc;
91 gfx_bitmap_alloc_t alloc;
92 bool myalloc;
93} testgc_bitmap_t;
94
95typedef struct {
96 bool up;
97 bool down;
98 bool moved;
99 gfx_coord_t pos;
100} test_cb_resp_t;
101
102/** Create and destroy scrollbar */
103PCUT_TEST(create_destroy)
104{
105 errno_t rc;
106 gfx_context_t *gc = NULL;
107 test_gc_t tgc;
108 ui_resource_t *resource = NULL;
109 ui_scrollbar_t *scrollbar = NULL;
110
111 memset(&tgc, 0, sizeof(tgc));
112 rc = gfx_context_new(&ops, &tgc, &gc);
113 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
114
115 rc = ui_resource_create(gc, false, &resource);
116 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
117 PCUT_ASSERT_NOT_NULL(resource);
118
119 rc = ui_scrollbar_create(resource, &scrollbar);
120 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
121 PCUT_ASSERT_NOT_NULL(scrollbar);
122
123 ui_scrollbar_destroy(scrollbar);
124 ui_resource_destroy(resource);
125
126 rc = gfx_context_delete(gc);
127 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
128}
129
130/** ui_scrollbar_destroy() can take NULL argument (no-op) */
131PCUT_TEST(destroy_null)
132{
133 ui_scrollbar_destroy(NULL);
134}
135
136/** ui_scrollbar_ctl() returns control that has a working virtual destructor */
137PCUT_TEST(ctl)
138{
139 errno_t rc;
140 gfx_context_t *gc = NULL;
141 test_gc_t tgc;
142 ui_resource_t *resource = NULL;
143 ui_scrollbar_t *scrollbar = NULL;
144 ui_control_t *control;
145
146 memset(&tgc, 0, sizeof(tgc));
147 rc = gfx_context_new(&ops, &tgc, &gc);
148 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
149
150 rc = ui_resource_create(gc, false, &resource);
151 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
152 PCUT_ASSERT_NOT_NULL(resource);
153
154 rc = ui_scrollbar_create(resource, &scrollbar);
155 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
156 PCUT_ASSERT_NOT_NULL(scrollbar);
157
158 control = ui_scrollbar_ctl(scrollbar);
159 PCUT_ASSERT_NOT_NULL(control);
160
161 ui_control_destroy(control);
162 ui_resource_destroy(resource);
163
164 rc = gfx_context_delete(gc);
165 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
166}
167
168/** Set scrollbar rectangle sets internal field */
169PCUT_TEST(set_rect)
170{
171 errno_t rc;
172 gfx_context_t *gc = NULL;
173 test_gc_t tgc;
174 ui_resource_t *resource = NULL;
175 ui_scrollbar_t *scrollbar = NULL;
176 gfx_rect_t rect;
177
178 memset(&tgc, 0, sizeof(tgc));
179 rc = gfx_context_new(&ops, &tgc, &gc);
180 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
181
182 rc = ui_resource_create(gc, false, &resource);
183 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
184 PCUT_ASSERT_NOT_NULL(resource);
185
186 rc = ui_scrollbar_create(resource, &scrollbar);
187 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
188 PCUT_ASSERT_NOT_NULL(scrollbar);
189
190 rect.p0.x = 1;
191 rect.p0.y = 2;
192 rect.p1.x = 3;
193 rect.p1.y = 4;
194
195 ui_scrollbar_set_rect(scrollbar, &rect);
196 PCUT_ASSERT_INT_EQUALS(rect.p0.x, scrollbar->rect.p0.x);
197 PCUT_ASSERT_INT_EQUALS(rect.p0.y, scrollbar->rect.p0.y);
198 PCUT_ASSERT_INT_EQUALS(rect.p1.x, scrollbar->rect.p1.x);
199 PCUT_ASSERT_INT_EQUALS(rect.p1.y, scrollbar->rect.p1.y);
200
201 ui_scrollbar_destroy(scrollbar);
202 ui_resource_destroy(resource);
203
204 rc = gfx_context_delete(gc);
205 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
206}
207
208/** Paint scrollbar in graphics mode */
209PCUT_TEST(paint_gfx)
210{
211 errno_t rc;
212 gfx_context_t *gc = NULL;
213 test_gc_t tgc;
214 ui_resource_t *resource = NULL;
215 ui_scrollbar_t *scrollbar;
216
217 memset(&tgc, 0, sizeof(tgc));
218 rc = gfx_context_new(&ops, &tgc, &gc);
219 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
220
221 rc = ui_resource_create(gc, false, &resource);
222 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
223 PCUT_ASSERT_NOT_NULL(resource);
224
225 rc = ui_scrollbar_create(resource, &scrollbar);
226 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
227
228 rc = ui_scrollbar_paint_gfx(scrollbar);
229 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
230
231 ui_scrollbar_destroy(scrollbar);
232 ui_resource_destroy(resource);
233
234 rc = gfx_context_delete(gc);
235 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
236}
237
238/** Paint scrollbar in text mode */
239PCUT_TEST(paint_text)
240{
241 errno_t rc;
242 gfx_context_t *gc = NULL;
243 test_gc_t tgc;
244 ui_resource_t *resource = NULL;
245 ui_scrollbar_t *scrollbar;
246 gfx_rect_t rect;
247
248 memset(&tgc, 0, sizeof(tgc));
249 rc = gfx_context_new(&ops, &tgc, &gc);
250 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
251
252 rc = ui_resource_create(gc, true, &resource);
253 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
254 PCUT_ASSERT_NOT_NULL(resource);
255
256 rc = ui_scrollbar_create(resource, &scrollbar);
257 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
258
259 rect.p0.x = 1;
260 rect.p0.y = 1;
261 rect.p1.x = 10;
262 rect.p1.y = 2;
263 ui_scrollbar_set_rect(scrollbar, &rect);
264
265 rc = ui_scrollbar_paint_text(scrollbar);
266 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
267
268 ui_scrollbar_destroy(scrollbar);
269 ui_resource_destroy(resource);
270
271 rc = gfx_context_delete(gc);
272 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
273}
274
275/** ui_scrollbar_through_length() gives correct scrollbar through length */
276PCUT_TEST(through_length)
277{
278 errno_t rc;
279 gfx_context_t *gc = NULL;
280 test_gc_t tgc;
281 ui_resource_t *resource = NULL;
282 ui_scrollbar_t *scrollbar;
283 gfx_coord_t length;
284 gfx_rect_t rect;
285
286 memset(&tgc, 0, sizeof(tgc));
287 rc = gfx_context_new(&ops, &tgc, &gc);
288 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
289
290 rc = ui_resource_create(gc, false, &resource);
291 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
292 PCUT_ASSERT_NOT_NULL(resource);
293
294 rc = ui_scrollbar_create(resource, &scrollbar);
295 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
296
297 PCUT_ASSERT_FALSE(scrollbar->held);
298
299 rect.p0.x = 10;
300 rect.p0.y = 20;
301 rect.p1.x = 110;
302 rect.p1.y = 120;
303 ui_scrollbar_set_rect(scrollbar, &rect);
304
305 length = ui_scrollbar_through_length(scrollbar);
306
307 /* Total length minus buttons */
308 PCUT_ASSERT_INT_EQUALS(110 - 10 - 2 * 20, length);
309
310 ui_scrollbar_destroy(scrollbar);
311 ui_resource_destroy(resource);
312
313 rc = gfx_context_delete(gc);
314 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
315}
316
317/** ui_scrollbar_move_length() gives correct scrollbar move length */
318PCUT_TEST(move_length)
319{
320 errno_t rc;
321 gfx_context_t *gc = NULL;
322 test_gc_t tgc;
323 ui_resource_t *resource = NULL;
324 ui_scrollbar_t *scrollbar;
325 gfx_coord_t length;
326 gfx_rect_t rect;
327
328 memset(&tgc, 0, sizeof(tgc));
329 rc = gfx_context_new(&ops, &tgc, &gc);
330 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
331
332 rc = ui_resource_create(gc, false, &resource);
333 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
334 PCUT_ASSERT_NOT_NULL(resource);
335
336 rc = ui_scrollbar_create(resource, &scrollbar);
337 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
338
339 PCUT_ASSERT_FALSE(scrollbar->held);
340
341 rect.p0.x = 10;
342 rect.p0.y = 20;
343 rect.p1.x = 110;
344 rect.p1.y = 120;
345 ui_scrollbar_set_rect(scrollbar, &rect);
346
347 length = ui_scrollbar_move_length(scrollbar);
348
349 /* Total length minus buttons minus default thumb length */
350 PCUT_ASSERT_INT_EQUALS(110 - 10 - 2 * 20 - 20, length);
351
352 ui_scrollbar_destroy(scrollbar);
353 ui_resource_destroy(resource);
354
355 rc = gfx_context_delete(gc);
356 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
357}
358
359/** ui_scrollbar_get_pos() returns scrollbar position */
360PCUT_TEST(get_pos)
361{
362 errno_t rc;
363 gfx_context_t *gc = NULL;
364 test_gc_t tgc;
365 ui_resource_t *resource = NULL;
366 ui_scrollbar_t *scrollbar;
367 gfx_coord_t pos;
368 gfx_rect_t rect;
369
370 memset(&tgc, 0, sizeof(tgc));
371 rc = gfx_context_new(&ops, &tgc, &gc);
372 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
373
374 rc = ui_resource_create(gc, false, &resource);
375 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
376 PCUT_ASSERT_NOT_NULL(resource);
377
378 rc = ui_scrollbar_create(resource, &scrollbar);
379 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
380
381 PCUT_ASSERT_FALSE(scrollbar->held);
382
383 rect.p0.x = 10;
384 rect.p0.y = 20;
385 rect.p1.x = 110;
386 rect.p1.y = 120;
387 ui_scrollbar_set_rect(scrollbar, &rect);
388
389 scrollbar->pos = 42;
390 pos = ui_scrollbar_get_pos(scrollbar);
391 PCUT_ASSERT_INT_EQUALS(42, pos);
392
393 ui_scrollbar_destroy(scrollbar);
394 ui_resource_destroy(resource);
395
396 rc = gfx_context_delete(gc);
397 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
398}
399
400/** ui_scrollbar_set_thumb_length() sets thumb length */
401PCUT_TEST(set_thumb_length)
402{
403 errno_t rc;
404 gfx_context_t *gc = NULL;
405 test_gc_t tgc;
406 ui_resource_t *resource = NULL;
407 ui_scrollbar_t *scrollbar;
408 gfx_rect_t rect;
409
410 memset(&tgc, 0, sizeof(tgc));
411 rc = gfx_context_new(&ops, &tgc, &gc);
412 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
413
414 rc = ui_resource_create(gc, false, &resource);
415 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
416 PCUT_ASSERT_NOT_NULL(resource);
417
418 rc = ui_scrollbar_create(resource, &scrollbar);
419 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
420
421 PCUT_ASSERT_FALSE(scrollbar->held);
422
423 rect.p0.x = 10;
424 rect.p0.y = 20;
425 rect.p1.x = 110;
426 rect.p1.y = 120;
427 ui_scrollbar_set_rect(scrollbar, &rect);
428
429 ui_scrollbar_set_thumb_length(scrollbar, 42);
430 PCUT_ASSERT_INT_EQUALS(42, scrollbar->thumb_len);
431
432 ui_scrollbar_destroy(scrollbar);
433 ui_resource_destroy(resource);
434
435 rc = gfx_context_delete(gc);
436 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
437}
438
439/** ui_scrollbar_set_pos() sets thumb position */
440PCUT_TEST(set_pos)
441{
442 errno_t rc;
443 gfx_context_t *gc = NULL;
444 test_gc_t tgc;
445 ui_resource_t *resource = NULL;
446 ui_scrollbar_t *scrollbar;
447 gfx_coord_t pos;
448 gfx_rect_t rect;
449
450 memset(&tgc, 0, sizeof(tgc));
451 rc = gfx_context_new(&ops, &tgc, &gc);
452 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
453
454 rc = ui_resource_create(gc, false, &resource);
455 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
456 PCUT_ASSERT_NOT_NULL(resource);
457
458 rc = ui_scrollbar_create(resource, &scrollbar);
459 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
460
461 PCUT_ASSERT_FALSE(scrollbar->held);
462
463 rect.p0.x = 10;
464 rect.p0.y = 20;
465 rect.p1.x = 110;
466 rect.p1.y = 120;
467 ui_scrollbar_set_rect(scrollbar, &rect);
468
469 ui_scrollbar_set_pos(scrollbar, -1);
470 pos = ui_scrollbar_get_pos(scrollbar);
471 /* The value is clipped to the minimum possible position (0) */
472 PCUT_ASSERT_INT_EQUALS(0, pos);
473
474 ui_scrollbar_set_pos(scrollbar, 12);
475 pos = ui_scrollbar_get_pos(scrollbar);
476 /* The value is set to the requested value */
477 PCUT_ASSERT_INT_EQUALS(12, pos);
478
479 ui_scrollbar_set_pos(scrollbar, 42);
480 pos = ui_scrollbar_get_pos(scrollbar);
481 /* The value is clipped to the maximum possible position (40) */
482 PCUT_ASSERT_INT_EQUALS(40, pos);
483
484 ui_scrollbar_destroy(scrollbar);
485 ui_resource_destroy(resource);
486
487 rc = gfx_context_delete(gc);
488 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
489}
490
491/** Press and release scrollbar */
492PCUT_TEST(press_release)
493{
494 errno_t rc;
495 gfx_context_t *gc = NULL;
496 test_gc_t tgc;
497 ui_resource_t *resource = NULL;
498 gfx_coord2_t pos;
499 gfx_rect_t rect;
500 ui_scrollbar_t *scrollbar;
501 test_cb_resp_t resp;
502
503 memset(&tgc, 0, sizeof(tgc));
504 rc = gfx_context_new(&ops, &tgc, &gc);
505 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
506
507 rc = ui_resource_create(gc, false, &resource);
508 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
509 PCUT_ASSERT_NOT_NULL(resource);
510
511 rc = ui_scrollbar_create(resource, &scrollbar);
512 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
513
514 rect.p0.x = 10;
515 rect.p0.y = 20;
516 rect.p1.x = 110;
517 rect.p1.y = 120;
518 ui_scrollbar_set_rect(scrollbar, &rect);
519
520 resp.moved = false;
521 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
522
523 PCUT_ASSERT_FALSE(scrollbar->held);
524
525 pos.x = 11;
526 pos.y = 22;
527
528 ui_scrollbar_press(scrollbar, &pos);
529 PCUT_ASSERT_TRUE(scrollbar->held);
530 PCUT_ASSERT_FALSE(resp.moved);
531
532 pos.x = 21;
533 pos.y = 32;
534
535 ui_scrollbar_release(scrollbar, &pos);
536 PCUT_ASSERT_FALSE(scrollbar->held);
537 PCUT_ASSERT_TRUE(resp.moved);
538 PCUT_ASSERT_INT_EQUALS(10, scrollbar->pos);
539
540 ui_scrollbar_destroy(scrollbar);
541 ui_resource_destroy(resource);
542
543 rc = gfx_context_delete(gc);
544 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
545}
546
547/** Press, update and release scrollbar */
548PCUT_TEST(press_uodate_release)
549{
550 errno_t rc;
551 gfx_context_t *gc = NULL;
552 test_gc_t tgc;
553 ui_resource_t *resource = NULL;
554 gfx_coord2_t pos;
555 gfx_rect_t rect;
556 ui_scrollbar_t *scrollbar;
557 test_cb_resp_t resp;
558
559 memset(&tgc, 0, sizeof(tgc));
560 rc = gfx_context_new(&ops, &tgc, &gc);
561 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
562
563 rc = ui_resource_create(gc, false, &resource);
564 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
565 PCUT_ASSERT_NOT_NULL(resource);
566
567 rc = ui_scrollbar_create(resource, &scrollbar);
568 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
569
570 rect.p0.x = 10;
571 rect.p0.y = 20;
572 rect.p1.x = 110;
573 rect.p1.y = 120;
574 ui_scrollbar_set_rect(scrollbar, &rect);
575
576 resp.moved = false;
577 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
578
579 PCUT_ASSERT_FALSE(scrollbar->held);
580
581 pos.x = 11;
582 pos.y = 22;
583
584 ui_scrollbar_press(scrollbar, &pos);
585 PCUT_ASSERT_TRUE(scrollbar->held);
586 PCUT_ASSERT_FALSE(resp.moved);
587
588 pos.x = 21;
589 pos.y = 32;
590
591 ui_scrollbar_update(scrollbar, &pos);
592 PCUT_ASSERT_TRUE(scrollbar->held);
593 PCUT_ASSERT_TRUE(resp.moved);
594 PCUT_ASSERT_INT_EQUALS(10, scrollbar->pos);
595
596 pos.x = 31;
597 pos.y = 42;
598
599 ui_scrollbar_release(scrollbar, &pos);
600 PCUT_ASSERT_FALSE(scrollbar->held);
601 PCUT_ASSERT_TRUE(resp.moved);
602 PCUT_ASSERT_INT_EQUALS(20, scrollbar->pos);
603
604 ui_scrollbar_destroy(scrollbar);
605 ui_resource_destroy(resource);
606
607 rc = gfx_context_delete(gc);
608 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
609}
610
611/** ui_scrollbar_up() delivers up event */
612PCUT_TEST(up)
613{
614 ui_scrollbar_t *scrollbar;
615 errno_t rc;
616 gfx_context_t *gc = NULL;
617 test_gc_t tgc;
618 ui_resource_t *resource = NULL;
619 test_cb_resp_t resp;
620
621 memset(&tgc, 0, sizeof(tgc));
622 rc = gfx_context_new(&ops, &tgc, &gc);
623 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
624
625 rc = ui_resource_create(gc, false, &resource);
626 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
627 PCUT_ASSERT_NOT_NULL(resource);
628
629 rc = ui_scrollbar_create(resource, &scrollbar);
630 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
631
632 /* Up with no callbacks set */
633 ui_scrollbar_up(scrollbar);
634
635 /* Up with callback not implementing up */
636 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
637 ui_scrollbar_up(scrollbar);
638
639 /* Up with real callback set */
640 resp.up = false;
641 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
642 ui_scrollbar_up(scrollbar);
643 PCUT_ASSERT_TRUE(resp.up);
644
645 ui_scrollbar_destroy(scrollbar);
646 ui_resource_destroy(resource);
647
648 rc = gfx_context_delete(gc);
649 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
650}
651
652/** ui_scrollbar_down() delivers down event */
653PCUT_TEST(down)
654{
655 ui_scrollbar_t *scrollbar;
656 errno_t rc;
657 gfx_context_t *gc = NULL;
658 test_gc_t tgc;
659 ui_resource_t *resource = NULL;
660 test_cb_resp_t resp;
661
662 memset(&tgc, 0, sizeof(tgc));
663 rc = gfx_context_new(&ops, &tgc, &gc);
664 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
665
666 rc = ui_resource_create(gc, false, &resource);
667 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
668 PCUT_ASSERT_NOT_NULL(resource);
669
670 rc = ui_scrollbar_create(resource, &scrollbar);
671 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
672
673 /* Down with no callbacks set */
674 ui_scrollbar_down(scrollbar);
675
676 /* Down with callback not implementing down */
677 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
678 ui_scrollbar_down(scrollbar);
679
680 /* Down with real callback set */
681 resp.down = false;
682 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
683 ui_scrollbar_down(scrollbar);
684 PCUT_ASSERT_TRUE(resp.down);
685
686 ui_scrollbar_destroy(scrollbar);
687 ui_resource_destroy(resource);
688
689 rc = gfx_context_delete(gc);
690 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
691}
692
693/** ui_scrollbar_moved() delivers moved event */
694PCUT_TEST(moved)
695{
696 ui_scrollbar_t *scrollbar;
697 errno_t rc;
698 gfx_context_t *gc = NULL;
699 test_gc_t tgc;
700 ui_resource_t *resource = NULL;
701 test_cb_resp_t resp;
702
703 memset(&tgc, 0, sizeof(tgc));
704 rc = gfx_context_new(&ops, &tgc, &gc);
705 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
706
707 rc = ui_resource_create(gc, false, &resource);
708 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
709 PCUT_ASSERT_NOT_NULL(resource);
710
711 rc = ui_scrollbar_create(resource, &scrollbar);
712 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
713
714 /* Moved with no callbacks set */
715 ui_scrollbar_moved(scrollbar, 42);
716
717 /* Moved with callback not implementing moved */
718 ui_scrollbar_set_cb(scrollbar, &dummy_scrollbar_cb, NULL);
719 ui_scrollbar_moved(scrollbar, 42);
720
721 /* Moved with real callback set */
722 resp.moved = false;
723 resp.pos = 0;
724 ui_scrollbar_set_cb(scrollbar, &test_scrollbar_cb, &resp);
725 ui_scrollbar_moved(scrollbar, 42);
726 PCUT_ASSERT_TRUE(resp.moved);
727 PCUT_ASSERT_INT_EQUALS(42, resp.pos);
728
729 ui_scrollbar_destroy(scrollbar);
730 ui_resource_destroy(resource);
731
732 rc = gfx_context_delete(gc);
733 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
734}
735
736/** ui_scrollbar_pos_event() detects thumb press/release */
737PCUT_TEST(pos_event_press_release_thumb)
738{
739 errno_t rc;
740 gfx_context_t *gc = NULL;
741 test_gc_t tgc;
742 ui_resource_t *resource = NULL;
743 ui_scrollbar_t *scrollbar;
744 ui_evclaim_t claim;
745 pos_event_t event;
746 gfx_rect_t rect;
747
748 memset(&tgc, 0, sizeof(tgc));
749 rc = gfx_context_new(&ops, &tgc, &gc);
750 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
751
752 rc = ui_resource_create(gc, false, &resource);
753 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
754 PCUT_ASSERT_NOT_NULL(resource);
755
756 rc = ui_scrollbar_create(resource, &scrollbar);
757 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
758
759 PCUT_ASSERT_FALSE(scrollbar->held);
760
761 rect.p0.x = 20;
762 rect.p0.y = 10;
763 rect.p1.x = 100;
764 rect.p1.y = 30;
765 ui_scrollbar_set_rect(scrollbar, &rect);
766
767 /* Press outside is not claimed and does nothing */
768 event.type = POS_PRESS;
769 event.hpos = 1;
770 event.vpos = 2;
771 claim = ui_scrollbar_pos_event(scrollbar, &event);
772 PCUT_ASSERT_FALSE(scrollbar->held);
773 PCUT_ASSERT_EQUALS(ui_unclaimed, claim);
774
775 /* Press inside thumb is claimed and depresses it */
776 event.type = POS_PRESS;
777 event.hpos = 50;
778 event.vpos = 20;
779 claim = ui_scrollbar_pos_event(scrollbar, &event);
780 PCUT_ASSERT_TRUE(scrollbar->held);
781 PCUT_ASSERT_EQUALS(ui_claimed, claim);
782
783 /* Release outside (or anywhere) is claimed and relases thumb */
784 event.type = POS_RELEASE;
785 event.hpos = 41;
786 event.vpos = 32;
787 claim = ui_scrollbar_pos_event(scrollbar, &event);
788 PCUT_ASSERT_FALSE(scrollbar->held);
789 PCUT_ASSERT_EQUALS(ui_claimed, claim);
790
791 ui_scrollbar_destroy(scrollbar);
792 ui_resource_destroy(resource);
793
794 rc = gfx_context_delete(gc);
795 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
796}
797
798/** ui_scrollbar_pos_event() detects up button press/release */
799PCUT_TEST(pos_event_press_release_up_btn)
800{
801 errno_t rc;
802 gfx_context_t *gc = NULL;
803 test_gc_t tgc;
804 ui_resource_t *resource = NULL;
805 ui_scrollbar_t *scrollbar;
806 ui_evclaim_t claim;
807 pos_event_t event;
808 gfx_rect_t rect;
809
810 memset(&tgc, 0, sizeof(tgc));
811 rc = gfx_context_new(&ops, &tgc, &gc);
812 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
813
814 rc = ui_resource_create(gc, false, &resource);
815 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
816 PCUT_ASSERT_NOT_NULL(resource);
817
818 rc = ui_scrollbar_create(resource, &scrollbar);
819 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
820
821 PCUT_ASSERT_FALSE(scrollbar->held);
822
823 rect.p0.x = 20;
824 rect.p0.y = 10;
825 rect.p1.x = 100;
826 rect.p1.y = 30;
827 ui_scrollbar_set_rect(scrollbar, &rect);
828
829 /* Press inside up button is claimed and depresses it */
830 event.type = POS_PRESS;
831 event.hpos = 30;
832 event.vpos = 20;
833 claim = ui_scrollbar_pos_event(scrollbar, &event);
834 PCUT_ASSERT_TRUE(scrollbar->btn_up->held);
835 PCUT_ASSERT_EQUALS(ui_claimed, claim);
836
837 ui_scrollbar_destroy(scrollbar);
838 ui_resource_destroy(resource);
839
840 rc = gfx_context_delete(gc);
841 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
842}
843
844/** ui_scrollbar_pos_event() detects down button press/release */
845PCUT_TEST(pos_event_press_relese_down_btn)
846{
847 errno_t rc;
848 gfx_context_t *gc = NULL;
849 test_gc_t tgc;
850 ui_resource_t *resource = NULL;
851 ui_scrollbar_t *scrollbar;
852 ui_evclaim_t claim;
853 pos_event_t event;
854 gfx_rect_t rect;
855
856 memset(&tgc, 0, sizeof(tgc));
857 rc = gfx_context_new(&ops, &tgc, &gc);
858 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
859
860 rc = ui_resource_create(gc, false, &resource);
861 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
862 PCUT_ASSERT_NOT_NULL(resource);
863
864 rc = ui_scrollbar_create(resource, &scrollbar);
865 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
866
867 PCUT_ASSERT_FALSE(scrollbar->held);
868
869 rect.p0.x = 20;
870 rect.p0.y = 10;
871 rect.p1.x = 100;
872 rect.p1.y = 30;
873 ui_scrollbar_set_rect(scrollbar, &rect);
874
875 /* Press inside down button is claimed and depresses it */
876 event.type = POS_PRESS;
877 event.hpos = 90;
878 event.vpos = 20;
879 claim = ui_scrollbar_pos_event(scrollbar, &event);
880 PCUT_ASSERT_TRUE(scrollbar->btn_down->held);
881 PCUT_ASSERT_EQUALS(ui_claimed, claim);
882
883 ui_scrollbar_destroy(scrollbar);
884 ui_resource_destroy(resource);
885
886 rc = gfx_context_delete(gc);
887 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
888}
889
890static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
891{
892 (void) arg;
893 (void) rect;
894 return EOK;
895}
896
897static errno_t testgc_set_color(void *arg, gfx_color_t *color)
898{
899 (void) arg;
900 (void) color;
901 return EOK;
902}
903
904static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
905{
906 (void) arg;
907 (void) rect;
908 return EOK;
909}
910
911static errno_t testgc_update(void *arg)
912{
913 (void) arg;
914 return EOK;
915}
916
917static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
918 gfx_bitmap_alloc_t *alloc, void **rbm)
919{
920 test_gc_t *tgc = (test_gc_t *) arg;
921 testgc_bitmap_t *tbm;
922
923 tbm = calloc(1, sizeof(testgc_bitmap_t));
924 if (tbm == NULL)
925 return ENOMEM;
926
927 if (alloc == NULL) {
928 tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
929 sizeof(uint32_t);
930 tbm->alloc.off0 = 0;
931 tbm->alloc.pixels = calloc(sizeof(uint32_t),
932 (params->rect.p1.x - params->rect.p0.x) *
933 (params->rect.p1.y - params->rect.p0.y));
934 tbm->myalloc = true;
935 if (tbm->alloc.pixels == NULL) {
936 free(tbm);
937 return ENOMEM;
938 }
939 } else {
940 tbm->alloc = *alloc;
941 }
942
943 tbm->tgc = tgc;
944 tgc->bm_created = true;
945 tgc->bm_params = *params;
946 tgc->bm_pixels = tbm->alloc.pixels;
947 *rbm = (void *)tbm;
948 return EOK;
949}
950
951static errno_t testgc_bitmap_destroy(void *bm)
952{
953 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
954 if (tbm->myalloc)
955 free(tbm->alloc.pixels);
956 tbm->tgc->bm_destroyed = true;
957 free(tbm);
958 return EOK;
959}
960
961static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
962 gfx_coord2_t *offs)
963{
964 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
965
966 tbm->tgc->bm_rendered = true;
967 if (srect != NULL)
968 tbm->tgc->bm_srect = *srect;
969 if (offs != NULL)
970 tbm->tgc->bm_offs = *offs;
971 return EOK;
972}
973
974static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
975{
976 testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
977 *alloc = tbm->alloc;
978 tbm->tgc->bm_got_alloc = true;
979 return EOK;
980}
981
982static void test_scrollbar_up(ui_scrollbar_t *scrollbar, void *arg)
983{
984 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
985
986 resp->up = true;
987}
988
989static void test_scrollbar_down(ui_scrollbar_t *scrollbar, void *arg)
990{
991 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
992
993 resp->down = true;
994}
995
996static void test_scrollbar_moved(ui_scrollbar_t *scrollbar, void *arg, gfx_coord_t pos)
997{
998 test_cb_resp_t *resp = (test_cb_resp_t *) arg;
999
1000 resp->moved = true;
1001 resp->pos = pos;
1002}
1003
1004PCUT_EXPORT(scrollbar);
Note: See TracBrowser for help on using the repository browser.