Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7470d97 rafcf704  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5050static void test_ipcgc_conn(ipc_call_t *, void *);
    5151
    52 static errno_t test_gc_set_clip_rect(void *, gfx_rect_t *);
    5352static errno_t test_gc_set_color(void *, gfx_color_t *);
    5453static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
    55 static errno_t test_gc_update(void *);
    5654static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
    5755    gfx_bitmap_alloc_t *, void **);
    … …  
    6159
    6260static gfx_context_ops_t test_gc_ops = {
    63         .set_clip_rect = test_gc_set_clip_rect,
    6461        .set_color = test_gc_set_color,
    6562        .fill_rect = test_gc_fill_rect,
    66         .update = test_gc_update,
    6763        .bitmap_create = test_gc_bitmap_create,
    6864        .bitmap_destroy = test_gc_bitmap_destroy,
    … …  
    7773        errno_t rc;
    7874
    79         bool set_clip_rect_called;
    80         bool do_clip;
    81         gfx_rect_t set_clip_rect_rect;
    82 
    8375        bool set_color_called;
    8476        uint16_t set_color_r;
    … …  
    8880        bool fill_rect_called;
    8981        gfx_rect_t fill_rect_rect;
    90 
    91         bool update_called;
    9282
    9383        bool bitmap_create_called;
    … …  
    10999        gfx_bitmap_alloc_t alloc;
    110100} test_bitmap_t;
    111 
    112 /** gfx_set_clip_rect with server returning failure */
    113 PCUT_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 */
    163 PCUT_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 */
    214 PCUT_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 }
    255101
    256102/** gfx_set_color with server returning failure */
    … …  
    384230
    385231        resp.rc = ENOMEM;
    386         resp.fill_rect_called = false;
     232        resp.set_color_called = false;
    387233        rect.p0.x = 1;
    388234        rect.p0.y = 2;
    … …  
    434280
    435281        resp.rc = EOK;
    436         resp.fill_rect_called = false;
     282        resp.set_color_called = false;
    437283        rect.p0.x = 1;
    438284        rect.p0.y = 2;
    … …  
    446292        PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
    447293        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 */
    457 PCUT_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 */
    498 PCUT_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);
    530294
    531295        ipc_gc_delete(ipcgc);
    … …  
    1048812}
    1049813
    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  */
    1057 static 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 
    1072814/** Set color in test GC.
    1073815 *
    … …  
    1102844        resp->fill_rect_called = true;
    1103845        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  */
    1113 static errno_t test_gc_update(void *arg)
    1114 {
    1115         test_response_t *resp = (test_response_t *) arg;
    1116 
    1117         resp->update_called = true;
    1118846        return resp->rc;
    1119847}
Note: See TracChangeset for help on using the changeset viewer.