Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/memgfx/test/memgfx.c

    rf8375f7 r1215db9  
    11/*
    2  * Copyright (c) 2020 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3232#include <gfx/coord.h>
    3333#include <gfx/context.h>
     34#include <gfx/cursor.h>
    3435#include <gfx/render.h>
    3536#include <io/pixelmap.h>
    … …  
    4243PCUT_TEST_SUITE(memgfx);
    4344
    44 static void test_update_rect(void *arg, gfx_rect_t *rect);
     45static void test_invalidate_rect(void *arg, gfx_rect_t *rect);
     46static void test_update(void *arg);
     47static errno_t test_cursor_get_pos(void *arg, gfx_coord2_t *);
     48static errno_t test_cursor_set_pos(void *arg, gfx_coord2_t *);
     49static errno_t test_cursor_set_visible(void *arg, bool);
     50
     51static mem_gc_cb_t test_mem_gc_cb = {
     52        .invalidate = test_invalidate_rect,
     53        .update = test_update,
     54        .cursor_get_pos = test_cursor_get_pos,
     55        .cursor_set_pos = test_cursor_set_pos,
     56        .cursor_set_visible = test_cursor_set_visible
     57};
    4558
    4659typedef struct {
     60        /** Return code to return */
     61        errno_t rc;
     62        /** True if invalidate was called */
     63        bool invalidate_called;
     64        /** Invalidate rectangle */
     65        gfx_rect_t inv_rect;
    4766        /** True if update was called */
    4867        bool update_called;
    49         /** Update rectangle */
    50         gfx_rect_t rect;
    51 } test_update_t;
     68        /** True if cursor_get_pos was called */
     69        bool cursor_get_pos_called;
     70        /** Position to return from cursor_get_pos */
     71        gfx_coord2_t get_pos_pos;
     72        /** True if cursor_set_pos was called */
     73        bool cursor_set_pos_called;
     74        /** Position passed to cursor_set_pos */
     75        gfx_coord2_t set_pos_pos;
     76        /** True if cursor_set_visible was called */
     77        bool cursor_set_visible_called;
     78        /** Value passed to cursor_set_visible */
     79        bool set_visible_vis;
     80} test_resp_t;
    5281
    5382/** Test creating and deleting a memory GC */
    … …  
    89118        pixel_t pixel;
    90119        pixel_t expected;
    91         test_update_t update;
    92         errno_t rc;
    93 
    94         /* Bounding rectangle for memory GC */
    95         rect.p0.x = 0;
    96         rect.p0.y = 0;
    97         rect.p1.x = 10;
    98         rect.p1.y = 10;
    99 
    100         alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
    101         alloc.off0 = 0;
    102         alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
    103         PCUT_ASSERT_NOT_NULL(alloc.pixels);
    104 
    105         rc = mem_gc_create(&rect, &alloc, test_update_rect, &update, &mgc);
     120        test_resp_t resp;
     121        errno_t rc;
     122
     123        /* Bounding rectangle for memory GC */
     124        rect.p0.x = 0;
     125        rect.p0.y = 0;
     126        rect.p1.x = 10;
     127        rect.p1.y = 10;
     128
     129        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     130        alloc.off0 = 0;
     131        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     132        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     133
     134        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
    106135        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    107136
    … …  
    122151        frect.p1.y = 5;
    123152
    124         memset(&update, 0, sizeof(update));
     153        memset(&resp, 0, sizeof(resp));
    125154
    126155        rc = gfx_fill_rect(gc, &frect);
    … …  
    141170        }
    142171
    143         /* Check that the update rect is equal to the filled rect */
    144         PCUT_ASSERT_TRUE(update.update_called);
    145         PCUT_ASSERT_INT_EQUALS(frect.p0.x, update.rect.p0.x);
    146         PCUT_ASSERT_INT_EQUALS(frect.p0.y, update.rect.p0.y);
    147         PCUT_ASSERT_INT_EQUALS(frect.p1.x, update.rect.p1.x);
    148         PCUT_ASSERT_INT_EQUALS(frect.p1.y, update.rect.p1.y);
     172        /* Check that the invalidate rect is equal to the filled rect */
     173        PCUT_ASSERT_TRUE(resp.invalidate_called);
     174        PCUT_ASSERT_INT_EQUALS(frect.p0.x, resp.inv_rect.p0.x);
     175        PCUT_ASSERT_INT_EQUALS(frect.p0.y, resp.inv_rect.p0.y);
     176        PCUT_ASSERT_INT_EQUALS(frect.p1.x, resp.inv_rect.p1.x);
     177        PCUT_ASSERT_INT_EQUALS(frect.p1.y, resp.inv_rect.p1.y);
    149178
    150179        /* TODO: Check clipping once memgc can support pitch != width etc. */
    … …  
    169198        pixel_t pixel;
    170199        pixel_t expected;
    171         test_update_t update;
    172         errno_t rc;
    173 
    174         /* Bounding rectangle for memory GC */
    175         rect.p0.x = 0;
    176         rect.p0.y = 0;
    177         rect.p1.x = 10;
    178         rect.p1.y = 10;
    179 
    180         alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
    181         alloc.off0 = 0;
    182         alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
    183         PCUT_ASSERT_NOT_NULL(alloc.pixels);
    184 
    185         rc = mem_gc_create(&rect, &alloc, test_update_rect, &update, &mgc);
     200        test_resp_t resp;
     201        errno_t rc;
     202
     203        /* Bounding rectangle for memory GC */
     204        rect.p0.x = 0;
     205        rect.p0.y = 0;
     206        rect.p1.x = 10;
     207        rect.p1.y = 10;
     208
     209        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     210        alloc.off0 = 0;
     211        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     212        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     213
     214        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
    186215        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    187216
    … …  
    191220        /* Create bitmap */
    192221
     222        gfx_bitmap_params_init(&params);
    193223        params.rect.p0.x = 0;
    194224        params.rect.p0.y = 0;
    … …  
    219249        dpmap.data = alloc.pixels;
    220250
    221         memset(&update, 0, sizeof(update));
     251        memset(&resp, 0, sizeof(resp));
    222252
    223253        /* Render the bitmap */
    … …  
    237267        }
    238268
    239         /* Check that the update rect is equal to the filled rect */
    240         PCUT_ASSERT_TRUE(update.update_called);
    241         PCUT_ASSERT_INT_EQUALS(params.rect.p0.x, update.rect.p0.x);
    242         PCUT_ASSERT_INT_EQUALS(params.rect.p0.y, update.rect.p0.y);
    243         PCUT_ASSERT_INT_EQUALS(params.rect.p1.x, update.rect.p1.x);
    244         PCUT_ASSERT_INT_EQUALS(params.rect.p1.y, update.rect.p1.y);
     269        /* Check that the invalidate rect is equal to the filled rect */
     270        PCUT_ASSERT_TRUE(resp.invalidate_called);
     271        PCUT_ASSERT_INT_EQUALS(params.rect.p0.x, resp.inv_rect.p0.x);
     272        PCUT_ASSERT_INT_EQUALS(params.rect.p0.y, resp.inv_rect.p0.y);
     273        PCUT_ASSERT_INT_EQUALS(params.rect.p1.x, resp.inv_rect.p1.x);
     274        PCUT_ASSERT_INT_EQUALS(params.rect.p1.y, resp.inv_rect.p1.y);
    245275
    246276        /* TODO: Check clipping once memgc can support pitch != width etc. */
    … …  
    250280}
    251281
    252 /** Called by memory GC when a rectangle is updated. */
    253 static void test_update_rect(void *arg, gfx_rect_t *rect)
    254 {
    255         test_update_t *update = (test_update_t *)arg;
    256 
    257         update->update_called = true;
    258         update->rect = *rect;
     282/** Test gfx_update() on a memory GC */
     283PCUT_TEST(gfx_update)
     284{
     285        mem_gc_t *mgc;
     286        gfx_rect_t rect;
     287        gfx_bitmap_alloc_t alloc;
     288        gfx_context_t *gc;
     289        test_resp_t resp;
     290        errno_t rc;
     291
     292        /* Bounding rectangle for memory GC */
     293        rect.p0.x = 0;
     294        rect.p0.y = 0;
     295        rect.p1.x = 10;
     296        rect.p1.y = 10;
     297
     298        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     299        alloc.off0 = 0;
     300        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     301        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     302
     303        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
     304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     305
     306        gc = mem_gc_get_ctx(mgc);
     307        PCUT_ASSERT_NOT_NULL(gc);
     308
     309        memset(&resp, 0, sizeof(resp));
     310        PCUT_ASSERT_FALSE(resp.update_called);
     311
     312        gfx_update(gc);
     313        PCUT_ASSERT_TRUE(resp.update_called);
     314
     315        mem_gc_delete(mgc);
     316        free(alloc.pixels);
     317}
     318
     319/** Test gfx_cursor_get_pos() on a memory GC */
     320PCUT_TEST(gfx_cursor_get_pos)
     321{
     322        mem_gc_t *mgc;
     323        gfx_rect_t rect;
     324        gfx_bitmap_alloc_t alloc;
     325        gfx_coord2_t pos;
     326        gfx_context_t *gc;
     327        test_resp_t resp;
     328        errno_t rc;
     329
     330        /* Bounding rectangle for memory GC */
     331        rect.p0.x = 0;
     332        rect.p0.y = 0;
     333        rect.p1.x = 10;
     334        rect.p1.y = 10;
     335
     336        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     337        alloc.off0 = 0;
     338        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     339        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     340
     341        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
     342        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     343
     344        gc = mem_gc_get_ctx(mgc);
     345        PCUT_ASSERT_NOT_NULL(gc);
     346
     347        memset(&resp, 0, sizeof(resp));
     348        resp.rc = EOK;
     349        resp.get_pos_pos.x = 1;
     350        resp.get_pos_pos.y = 2;
     351        PCUT_ASSERT_FALSE(resp.cursor_get_pos_called);
     352
     353        rc = gfx_cursor_get_pos(gc, &pos);
     354        PCUT_ASSERT_TRUE(resp.cursor_get_pos_called);
     355        PCUT_ASSERT_INT_EQUALS(resp.get_pos_pos.x, pos.x);
     356        PCUT_ASSERT_INT_EQUALS(resp.get_pos_pos.y, pos.y);
     357
     358        mem_gc_delete(mgc);
     359        free(alloc.pixels);
     360}
     361
     362/** Test gfx_cursor_set_pos() on a memory GC */
     363PCUT_TEST(gfx_cursor_set_pos)
     364{
     365        mem_gc_t *mgc;
     366        gfx_rect_t rect;
     367        gfx_bitmap_alloc_t alloc;
     368        gfx_coord2_t pos;
     369        gfx_context_t *gc;
     370        test_resp_t resp;
     371        errno_t rc;
     372
     373        /* Bounding rectangle for memory GC */
     374        rect.p0.x = 0;
     375        rect.p0.y = 0;
     376        rect.p1.x = 10;
     377        rect.p1.y = 10;
     378
     379        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     380        alloc.off0 = 0;
     381        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     382        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     383
     384        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
     385        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     386
     387        gc = mem_gc_get_ctx(mgc);
     388        PCUT_ASSERT_NOT_NULL(gc);
     389
     390        memset(&resp, 0, sizeof(resp));
     391        resp.rc = EOK;
     392        pos.x = 1;
     393        pos.y = 2;
     394        PCUT_ASSERT_FALSE(resp.cursor_set_pos_called);
     395
     396        rc = gfx_cursor_set_pos(gc, &pos);
     397        PCUT_ASSERT_TRUE(resp.cursor_set_pos_called);
     398        PCUT_ASSERT_INT_EQUALS(pos.x, resp.set_pos_pos.x);
     399        PCUT_ASSERT_INT_EQUALS(pos.y, resp.set_pos_pos.y);
     400
     401        mem_gc_delete(mgc);
     402        free(alloc.pixels);
     403}
     404
     405/** Test gfx_cursor_set_visible() on a memory GC */
     406PCUT_TEST(gfx_cursor_set_visible)
     407{
     408        mem_gc_t *mgc;
     409        gfx_rect_t rect;
     410        gfx_bitmap_alloc_t alloc;
     411        gfx_context_t *gc;
     412        test_resp_t resp;
     413        errno_t rc;
     414
     415        /* Bounding rectangle for memory GC */
     416        rect.p0.x = 0;
     417        rect.p0.y = 0;
     418        rect.p1.x = 10;
     419        rect.p1.y = 10;
     420
     421        alloc.pitch = (rect.p1.x - rect.p0.x) * sizeof(uint32_t);
     422        alloc.off0 = 0;
     423        alloc.pixels = calloc(1, alloc.pitch * (rect.p1.y - rect.p0.y));
     424        PCUT_ASSERT_NOT_NULL(alloc.pixels);
     425
     426        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
     427        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     428
     429        gc = mem_gc_get_ctx(mgc);
     430        PCUT_ASSERT_NOT_NULL(gc);
     431
     432        memset(&resp, 0, sizeof(resp));
     433        resp.rc = EOK;
     434        PCUT_ASSERT_FALSE(resp.cursor_set_visible_called);
     435
     436        rc = gfx_cursor_set_visible(gc, true);
     437        PCUT_ASSERT_TRUE(resp.cursor_set_visible_called);
     438        PCUT_ASSERT_TRUE(resp.set_visible_vis);
     439
     440        resp.cursor_set_visible_called = false;
     441
     442        rc = gfx_cursor_set_visible(gc, false);
     443        PCUT_ASSERT_TRUE(resp.cursor_set_visible_called);
     444        PCUT_ASSERT_FALSE(resp.set_visible_vis);
     445
     446        mem_gc_delete(mgc);
     447        free(alloc.pixels);
     448}
     449
     450/** Called by memory GC when a rectangle is modified. */
     451static void test_invalidate_rect(void *arg, gfx_rect_t *rect)
     452{
     453        test_resp_t *resp = (test_resp_t *)arg;
     454
     455        resp->invalidate_called = true;
     456        resp->inv_rect = *rect;
     457}
     458
     459/** Called by memory GC when update is called. */
     460static void test_update(void *arg)
     461{
     462        test_resp_t *resp = (test_resp_t *)arg;
     463
     464        resp->update_called = true;
     465}
     466
     467/** Called by memory GC when cursor_get_pos is called. */
     468static errno_t test_cursor_get_pos(void *arg, gfx_coord2_t *pos)
     469{
     470        test_resp_t *resp = (test_resp_t *)arg;
     471
     472        resp->cursor_get_pos_called = true;
     473        *pos = resp->get_pos_pos;
     474        return resp->rc;
     475}
     476
     477/** Called by memory GC when cursor_set_pos is called. */
     478static errno_t test_cursor_set_pos(void *arg, gfx_coord2_t *pos)
     479{
     480        test_resp_t *resp = (test_resp_t *)arg;
     481
     482        resp->cursor_set_pos_called = true;
     483        resp->set_pos_pos = *pos;
     484        return resp->rc;
     485}
     486
     487/** Called by memory GC when cursor_set_visible is called. */
     488static errno_t test_cursor_set_visible(void *arg, bool visible)
     489{
     490        test_resp_t *resp = (test_resp_t *)arg;
     491
     492        resp->cursor_set_visible_called = true;
     493        resp->set_visible_vis = visible;
     494        return resp->rc;
    259495}
    260496
Note: See TracChangeset for help on using the changeset viewer.