Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 1215db9 in mainline for uspace/lib/memgfx/test/memgfx.c


Ignore:
Timestamp:
2021-06-26T23:30:18Z (5 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
e87415e6
Parents:
bb14312
Message:

Memory GC needs to be able to forward cursor control

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/memgfx/test/memgfx.c

    rbb14312 r1215db9  
    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>
     
    4445static void test_invalidate_rect(void *arg, gfx_rect_t *rect);
    4546static 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};
    4658
    4759typedef struct {
     60        /** Return code to return */
     61        errno_t rc;
    4862        /** True if invalidate was called */
    4963        bool invalidate_called;
     
    5266        /** True if update was called */
    5367        bool update_called;
     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;
    5480} test_resp_t;
    5581
     
    7298        PCUT_ASSERT_NOT_NULL(alloc.pixels);
    7399
    74         rc = mem_gc_create(&rect, &alloc, NULL, NULL, NULL, &mgc);
     100        rc = mem_gc_create(&rect, &alloc, NULL, NULL, &mgc);
    75101        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    76102
     
    106132        PCUT_ASSERT_NOT_NULL(alloc.pixels);
    107133
    108         rc = mem_gc_create(&rect, &alloc, test_invalidate_rect,
    109             test_update, &resp, &mgc);
     134        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
    110135        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    111136
     
    187212        PCUT_ASSERT_NOT_NULL(alloc.pixels);
    188213
    189         rc = mem_gc_create(&rect, &alloc, test_invalidate_rect,
    190             test_update, &resp, &mgc);
     214        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
    191215        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    192216
     
    277301        PCUT_ASSERT_NOT_NULL(alloc.pixels);
    278302
    279         rc = mem_gc_create(&rect, &alloc, test_invalidate_rect,
    280             test_update, &resp, &mgc);
     303        rc = mem_gc_create(&rect, &alloc, &test_mem_gc_cb, &resp, &mgc);
    281304        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    282305
     
    294317}
    295318
     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
    296450/** Called by memory GC when a rectangle is modified. */
    297451static void test_invalidate_rect(void *arg, gfx_rect_t *rect)
     
    311465}
    312466
     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;
     495}
     496
    313497PCUT_EXPORT(memgfx);
Note: See TracChangeset for help on using the changeset viewer.