Changeset 35cffea in mainline for uspace/lib/display/test/display.c


Ignore:
Timestamp:
2022-05-19T08:02:31Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ad698f4
Parents:
fd05ea6
git-author:
Jiri Svoboda <jiri@…> (2022-05-18 17:02:12)
git-committer:
Jiri Svoboda <jiri@…> (2022-05-19 08:02:31)
Message:

Maximizing/unmaximizing a window

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/display/test/display.c

    rfd05ea6 r35cffea  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2022 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    6060static errno_t test_window_move(void *, sysarg_t, gfx_coord2_t *);
    6161static errno_t test_window_get_pos(void *, sysarg_t, gfx_coord2_t *);
     62static errno_t test_window_get_max_rect(void *, sysarg_t, gfx_rect_t *);
    6263static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t,
    6364    gfx_coord2_t *);
    6465static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *,
    6566    gfx_rect_t *);
     67static errno_t test_window_maximize(void *, sysarg_t);
     68static errno_t test_window_unmaximize(void *, sysarg_t);
    6669static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t);
    6770static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *);
    … …  
    7679        .window_move = test_window_move,
    7780        .window_get_pos = test_window_get_pos,
     81        .window_get_max_rect = test_window_get_max_rect,
    7882        .window_resize_req = test_window_resize_req,
    7983        .window_resize = test_window_resize,
     84        .window_maximize = test_window_maximize,
     85        .window_unmaximize = test_window_unmaximize,
    8086        .window_set_cursor = test_window_set_cursor,
    8187        .get_event = test_get_event,
    … …  
    122128        gfx_coord2_t get_pos_rpos;
    123129
     130        bool window_get_max_rect_called;
     131        sysarg_t get_max_rect_wnd_id;
     132        gfx_rect_t get_max_rect_rrect;
     133
    124134        bool window_resize_req_called;
    125135        sysarg_t resize_req_wnd_id;
    … …  
    131141        gfx_rect_t resize_nbound;
    132142        sysarg_t resize_wnd_id;
     143
     144        bool window_maximize_called;
     145        bool window_unmaximize_called;
    133146
    134147        bool window_set_cursor_called;
    … …  
    674687}
    675688
     689/** display_window_get_max_rect() with server returning error response works. */
     690PCUT_TEST(window_get_max_rect_failure)
     691{
     692        errno_t rc;
     693        service_id_t sid;
     694        display_t *disp = NULL;
     695        display_wnd_params_t params;
     696        display_window_t *wnd;
     697        gfx_rect_t rect;
     698        test_response_t resp;
     699
     700        async_set_fallback_port_handler(test_display_conn, &resp);
     701
     702        // FIXME This causes this test to be non-reentrant!
     703        rc = loc_server_register(test_display_server);
     704        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     705
     706        rc = loc_service_register(test_display_svc, &sid);
     707        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     708
     709        rc = display_open(test_display_svc, &disp);
     710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     711        PCUT_ASSERT_NOT_NULL(disp);
     712
     713        resp.rc = EOK;
     714        display_wnd_params_init(&params);
     715        params.rect.p0.x = 0;
     716        params.rect.p0.y = 0;
     717        params.rect.p0.x = 100;
     718        params.rect.p0.y = 100;
     719
     720        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     721            (void *) &resp, &wnd);
     722        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     723        PCUT_ASSERT_NOT_NULL(wnd);
     724
     725        resp.rc = EIO;
     726        resp.window_get_max_rect_called = false;
     727
     728        rect.p0.x = 0;
     729        rect.p0.y = 0;
     730        rect.p1.x = 0;
     731        rect.p1.y = 0;
     732
     733        rc = display_window_get_max_rect(wnd, &rect);
     734        PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
     735        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     736        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
     737        PCUT_ASSERT_INT_EQUALS(0, rect.p0.x);
     738        PCUT_ASSERT_INT_EQUALS(0, rect.p0.y);
     739        PCUT_ASSERT_INT_EQUALS(0, rect.p1.x);
     740        PCUT_ASSERT_INT_EQUALS(0, rect.p1.y);
     741
     742        display_window_destroy(wnd);
     743        display_close(disp);
     744        rc = loc_service_unregister(sid);
     745        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     746}
     747
     748/** display_window_get_max_rect() with server returning success response works. */
     749PCUT_TEST(window_get_max_rect_success)
     750{
     751        errno_t rc;
     752        service_id_t sid;
     753        display_t *disp = NULL;
     754        display_wnd_params_t params;
     755        display_window_t *wnd;
     756        gfx_rect_t rect;
     757        test_response_t resp;
     758
     759        async_set_fallback_port_handler(test_display_conn, &resp);
     760
     761        // FIXME This causes this test to be non-reentrant!
     762        rc = loc_server_register(test_display_server);
     763        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     764
     765        rc = loc_service_register(test_display_svc, &sid);
     766        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     767
     768        rc = display_open(test_display_svc, &disp);
     769        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     770        PCUT_ASSERT_NOT_NULL(disp);
     771
     772        resp.rc = EOK;
     773        display_wnd_params_init(&params);
     774        params.rect.p0.x = 0;
     775        params.rect.p0.y = 0;
     776        params.rect.p0.x = 100;
     777        params.rect.p0.y = 100;
     778
     779        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     780            (void *) &resp, &wnd);
     781        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     782        PCUT_ASSERT_NOT_NULL(wnd);
     783
     784        resp.rc = EOK;
     785        resp.window_get_max_rect_called = false;
     786        resp.get_max_rect_rrect.p0.x = 11;
     787        resp.get_max_rect_rrect.p0.y = 12;
     788        resp.get_max_rect_rrect.p1.x = 13;
     789        resp.get_max_rect_rrect.p1.y = 14;
     790
     791        rect.p0.x = 0;
     792        rect.p0.y = 0;
     793        rect.p1.x = 0;
     794        rect.p1.y = 0;
     795
     796        rc = display_window_get_max_rect(wnd, &rect);
     797        PCUT_ASSERT_TRUE(resp.window_get_max_rect_called);
     798        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     799        PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id);
     800        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x);
     801        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y);
     802        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x);
     803        PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y);
     804
     805        display_window_destroy(wnd);
     806        display_close(disp);
     807        rc = loc_service_unregister(sid);
     808        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     809}
     810
    676811/** display_window_resize_req() with server returning error response works. */
    677812PCUT_TEST(window_resize_req_failure)
    … …  
    9081043        PCUT_ASSERT_INT_EQUALS(nrect.p1.x, resp.resize_nbound.p1.x);
    9091044        PCUT_ASSERT_INT_EQUALS(nrect.p1.y, resp.resize_nbound.p1.y);
     1045
     1046        display_window_destroy(wnd);
     1047        display_close(disp);
     1048        rc = loc_service_unregister(sid);
     1049        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1050}
     1051
     1052/** display_window_maximize() with server returning error response works. */
     1053PCUT_TEST(window_maximize_failure)
     1054{
     1055        errno_t rc;
     1056        service_id_t sid;
     1057        display_t *disp = NULL;
     1058        display_wnd_params_t params;
     1059        display_window_t *wnd;
     1060        test_response_t resp;
     1061
     1062        async_set_fallback_port_handler(test_display_conn, &resp);
     1063
     1064        // FIXME This causes this test to be non-reentrant!
     1065        rc = loc_server_register(test_display_server);
     1066        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1067
     1068        rc = loc_service_register(test_display_svc, &sid);
     1069        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1070
     1071        rc = display_open(test_display_svc, &disp);
     1072        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1073        PCUT_ASSERT_NOT_NULL(disp);
     1074
     1075        resp.rc = EOK;
     1076        display_wnd_params_init(&params);
     1077        params.rect.p0.x = 0;
     1078        params.rect.p0.y = 0;
     1079        params.rect.p0.x = 100;
     1080        params.rect.p0.y = 100;
     1081
     1082        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1083            (void *) &resp, &wnd);
     1084        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1085        PCUT_ASSERT_NOT_NULL(wnd);
     1086
     1087        resp.rc = EIO;
     1088        resp.window_maximize_called = false;
     1089
     1090        rc = display_window_maximize(wnd);
     1091        PCUT_ASSERT_TRUE(resp.window_maximize_called);
     1092        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     1093
     1094        display_window_destroy(wnd);
     1095        display_close(disp);
     1096        rc = loc_service_unregister(sid);
     1097        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1098}
     1099
     1100/** display_window_maximize() with server returning success response works. */
     1101PCUT_TEST(window_maximize_success)
     1102{
     1103        errno_t rc;
     1104        service_id_t sid;
     1105        display_t *disp = NULL;
     1106        display_wnd_params_t params;
     1107        display_window_t *wnd;
     1108        test_response_t resp;
     1109
     1110        async_set_fallback_port_handler(test_display_conn, &resp);
     1111
     1112        // FIXME This causes this test to be non-reentrant!
     1113        rc = loc_server_register(test_display_server);
     1114        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1115
     1116        rc = loc_service_register(test_display_svc, &sid);
     1117        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1118
     1119        rc = display_open(test_display_svc, &disp);
     1120        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1121        PCUT_ASSERT_NOT_NULL(disp);
     1122
     1123        resp.rc = EOK;
     1124        display_wnd_params_init(&params);
     1125        params.rect.p0.x = 0;
     1126        params.rect.p0.y = 0;
     1127        params.rect.p0.x = 100;
     1128        params.rect.p0.y = 100;
     1129
     1130        rc = display_window_create(disp, &params, &test_display_wnd_cb,
     1131            (void *) &resp, &wnd);
     1132        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1133        PCUT_ASSERT_NOT_NULL(wnd);
     1134
     1135        resp.rc = EOK;
     1136        resp.window_maximize_called = false;
     1137
     1138        rc = display_window_maximize(wnd);
     1139        PCUT_ASSERT_TRUE(resp.window_maximize_called);
     1140        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    9101141
    9111142        display_window_destroy(wnd);
    … …  
    17191950}
    17201951
     1952static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id,
     1953    gfx_rect_t *rect)
     1954{
     1955        test_response_t *resp = (test_response_t *) arg;
     1956
     1957        resp->window_get_max_rect_called = true;
     1958        resp->get_max_rect_wnd_id = wnd_id;
     1959
     1960        if (resp->rc == EOK)
     1961                *rect = resp->get_max_rect_rrect;
     1962
     1963        return resp->rc;
     1964}
     1965
    17211966static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id,
    17221967    display_wnd_rsztype_t rsztype, gfx_coord2_t *pos)
    … …  
    17401985        resp->resize_offs = *offs;
    17411986        resp->resize_nbound = *nrect;
     1987        return resp->rc;
     1988}
     1989
     1990static errno_t test_window_maximize(void *arg, sysarg_t wnd_id)
     1991{
     1992        test_response_t *resp = (test_response_t *) arg;
     1993
     1994        resp->window_maximize_called = true;
     1995        resp->resize_wnd_id = wnd_id;
     1996        return resp->rc;
     1997}
     1998
     1999static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id)
     2000{
     2001        test_response_t *resp = (test_response_t *) arg;
     2002
     2003        resp->window_unmaximize_called = true;
     2004        resp->resize_wnd_id = wnd_id;
    17422005        return resp->rc;
    17432006}
Note: See TracChangeset for help on using the changeset viewer.