Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ipcgfx/test/ipcgfx.c

    rafcf704 r7470d97  
    11/*
    2  * Copyright (c) 2019 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5050static void test_ipcgc_conn(ipc_call_t *, void *);
    5151
     52static errno_t test_gc_set_clip_rect(void *, gfx_rect_t *);
    5253static errno_t test_gc_set_color(void *, gfx_color_t *);
    5354static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
     55static errno_t test_gc_update(void *);
    5456static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
    5557    gfx_bitmap_alloc_t *, void **);
    … …  
    5961
    6062static gfx_context_ops_t test_gc_ops = {
     63        .set_clip_rect = test_gc_set_clip_rect,
    6164        .set_color = test_gc_set_color,
    6265        .fill_rect = test_gc_fill_rect,
     66        .update = test_gc_update,
    6367        .bitmap_create = test_gc_bitmap_create,
    6468        .bitmap_destroy = test_gc_bitmap_destroy,
    … …  
    7377        errno_t rc;
    7478
     79        bool set_clip_rect_called;
     80        bool do_clip;
     81        gfx_rect_t set_clip_rect_rect;
     82
    7583        bool set_color_called;
    7684        uint16_t set_color_r;
    … …  
    8088        bool fill_rect_called;
    8189        gfx_rect_t fill_rect_rect;
     90
     91        bool update_called;
    8292
    8393        bool bitmap_create_called;
    … …  
    99109        gfx_bitmap_alloc_t alloc;
    100110} test_bitmap_t;
     111
     112/** gfx_set_clip_rect with server returning failure */
     113PCUT_TEST(set_clip_rect_failure)
     114{
     115        errno_t rc;
     116        service_id_t sid;
     117        test_response_t resp;
     118        gfx_context_t *gc;
     119        gfx_rect_t rect;
     120        async_sess_t *sess;
     121        ipc_gc_t *ipcgc;
     122
     123        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     124
     125        // FIXME This causes this test to be non-reentrant!
     126        rc = loc_server_register(test_ipcgfx_server);
     127        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     128
     129        rc = loc_service_register(test_ipcgfx_svc, &sid);
     130        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     131
     132        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     133        PCUT_ASSERT_NOT_NULL(sess);
     134
     135        rc = ipc_gc_create(sess, &ipcgc);
     136        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     137
     138        gc = ipc_gc_get_ctx(ipcgc);
     139        PCUT_ASSERT_NOT_NULL(gc);
     140
     141        resp.rc = ENOMEM;
     142        resp.set_clip_rect_called = false;
     143        rect.p0.x = 1;
     144        rect.p0.y = 2;
     145        rect.p1.x = 3;
     146        rect.p1.y = 4;
     147        rc = gfx_set_clip_rect(gc, &rect);
     148        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     149        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     150        PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
     151        PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
     152        PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
     153        PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
     154
     155        ipc_gc_delete(ipcgc);
     156        async_hangup(sess);
     157
     158        rc = loc_service_unregister(sid);
     159        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     160}
     161
     162/** gfx_set_clip_rect with server returning success */
     163PCUT_TEST(set_clip_rect_success)
     164{
     165        errno_t rc;
     166        service_id_t sid;
     167        test_response_t resp;
     168        gfx_context_t *gc;
     169        gfx_rect_t rect;
     170        async_sess_t *sess;
     171        ipc_gc_t *ipcgc;
     172
     173        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     174
     175        // FIXME This causes this test to be non-reentrant!
     176        rc = loc_server_register(test_ipcgfx_server);
     177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     178
     179        rc = loc_service_register(test_ipcgfx_svc, &sid);
     180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     181
     182        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     183        PCUT_ASSERT_NOT_NULL(sess);
     184
     185        rc = ipc_gc_create(sess, &ipcgc);
     186        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     187
     188        gc = ipc_gc_get_ctx(ipcgc);
     189        PCUT_ASSERT_NOT_NULL(gc);
     190
     191        resp.rc = EOK;
     192        resp.set_clip_rect_called = false;
     193        rect.p0.x = 1;
     194        rect.p0.y = 2;
     195        rect.p1.x = 3;
     196        rect.p1.y = 4;
     197        rc = gfx_set_clip_rect(gc, &rect);
     198        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     199        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     200        PCUT_ASSERT_TRUE(resp.do_clip);
     201        PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
     202        PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
     203        PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
     204        PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
     205
     206        ipc_gc_delete(ipcgc);
     207        async_hangup(sess);
     208
     209        rc = loc_service_unregister(sid);
     210        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     211}
     212
     213/** gfx_set_clip_rect with null rectangle, server returning success */
     214PCUT_TEST(set_clip_rect_null_success)
     215{
     216        errno_t rc;
     217        service_id_t sid;
     218        test_response_t resp;
     219        gfx_context_t *gc;
     220        async_sess_t *sess;
     221        ipc_gc_t *ipcgc;
     222
     223        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     224
     225        // FIXME This causes this test to be non-reentrant!
     226        rc = loc_server_register(test_ipcgfx_server);
     227        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     228
     229        rc = loc_service_register(test_ipcgfx_svc, &sid);
     230        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     231
     232        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     233        PCUT_ASSERT_NOT_NULL(sess);
     234
     235        rc = ipc_gc_create(sess, &ipcgc);
     236        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     237
     238        gc = ipc_gc_get_ctx(ipcgc);
     239        PCUT_ASSERT_NOT_NULL(gc);
     240
     241        resp.rc = EOK;
     242        resp.set_clip_rect_called = false;
     243
     244        rc = gfx_set_clip_rect(gc, NULL);
     245        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     246        PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
     247        PCUT_ASSERT_FALSE(resp.do_clip);
     248
     249        ipc_gc_delete(ipcgc);
     250        async_hangup(sess);
     251
     252        rc = loc_service_unregister(sid);
     253        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     254}
    101255
    102256/** gfx_set_color with server returning failure */
    … …  
    230384
    231385        resp.rc = ENOMEM;
    232         resp.set_color_called = false;
     386        resp.fill_rect_called = false;
    233387        rect.p0.x = 1;
    234388        rect.p0.y = 2;
    … …  
    280434
    281435        resp.rc = EOK;
    282         resp.set_color_called = false;
     436        resp.fill_rect_called = false;
    283437        rect.p0.x = 1;
    284438        rect.p0.y = 2;
    … …  
    292446        PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
    293447        PCUT_ASSERT_EQUALS(rect.p1.y, resp.fill_rect_rect.p1.y);
     448
     449        ipc_gc_delete(ipcgc);
     450        async_hangup(sess);
     451
     452        rc = loc_service_unregister(sid);
     453        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     454}
     455
     456/** gfx_update with server returning failure */
     457PCUT_TEST(update_failure)
     458{
     459        errno_t rc;
     460        service_id_t sid;
     461        test_response_t resp;
     462        gfx_context_t *gc;
     463        async_sess_t *sess;
     464        ipc_gc_t *ipcgc;
     465
     466        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     467
     468        // FIXME This causes this test to be non-reentrant!
     469        rc = loc_server_register(test_ipcgfx_server);
     470        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     471
     472        rc = loc_service_register(test_ipcgfx_svc, &sid);
     473        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     474
     475        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     476        PCUT_ASSERT_NOT_NULL(sess);
     477
     478        rc = ipc_gc_create(sess, &ipcgc);
     479        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     480
     481        gc = ipc_gc_get_ctx(ipcgc);
     482        PCUT_ASSERT_NOT_NULL(gc);
     483
     484        resp.rc = ENOMEM;
     485        resp.update_called = false;
     486        rc = gfx_update(gc);
     487        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     488        PCUT_ASSERT_TRUE(resp.update_called);
     489
     490        ipc_gc_delete(ipcgc);
     491        async_hangup(sess);
     492
     493        rc = loc_service_unregister(sid);
     494        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     495}
     496
     497/** gfx_update with server returning success */
     498PCUT_TEST(update_success)
     499{
     500        errno_t rc;
     501        service_id_t sid;
     502        test_response_t resp;
     503        gfx_context_t *gc;
     504        async_sess_t *sess;
     505        ipc_gc_t *ipcgc;
     506
     507        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     508
     509        // FIXME This causes this test to be non-reentrant!
     510        rc = loc_server_register(test_ipcgfx_server);
     511        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     512
     513        rc = loc_service_register(test_ipcgfx_svc, &sid);
     514        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     515
     516        sess = loc_service_connect(sid, INTERFACE_GC, 0);
     517        PCUT_ASSERT_NOT_NULL(sess);
     518
     519        rc = ipc_gc_create(sess, &ipcgc);
     520        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     521
     522        gc = ipc_gc_get_ctx(ipcgc);
     523        PCUT_ASSERT_NOT_NULL(gc);
     524
     525        resp.rc = EOK;
     526        resp.update_called = false;
     527        rc = gfx_update(gc);
     528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     529        PCUT_ASSERT_TRUE(resp.update_called);
    294530
    295531        ipc_gc_delete(ipcgc);
    … …  
    8121048}
    8131049
     1050/** Set clipping rectangle in test GC.
     1051 *
     1052 * @param arg Test GC
     1053 * @param rect Rectangle
     1054 *
     1055 * @return EOK on success or an error code
     1056 */
     1057static errno_t test_gc_set_clip_rect(void *arg, gfx_rect_t *rect)
     1058{
     1059        test_response_t *resp = (test_response_t *) arg;
     1060
     1061        resp->set_clip_rect_called = true;
     1062        if (rect != NULL) {
     1063                resp->do_clip = true;
     1064                resp->set_clip_rect_rect = *rect;
     1065        } else {
     1066                resp->do_clip = false;
     1067        }
     1068
     1069        return resp->rc;
     1070}
     1071
    8141072/** Set color in test GC.
    8151073 *
    … …  
    8441102        resp->fill_rect_called = true;
    8451103        resp->fill_rect_rect = *rect;
     1104        return resp->rc;
     1105}
     1106
     1107/** Update test GC.
     1108 *
     1109 * @param arg Test GC
     1110 *
     1111 * @return EOK on success or an error code
     1112 */
     1113static errno_t test_gc_update(void *arg)
     1114{
     1115        test_response_t *resp = (test_response_t *) arg;
     1116
     1117        resp->update_called = true;
    8461118        return resp->rc;
    8471119}
Note: See TracChangeset for help on using the changeset viewer.