Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/system/test/system.c

    ra72f3b8 rca48672  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4646void test_system_conn(ipc_call_t *, void *);
    4747
    48 static errno_t test_shutdown(void *);
     48static errno_t test_poweroff(void *);
     49static errno_t test_restart(void *);
    4950
    5051static void test_sys_shutdown_complete(void *);
    … …  
    5253
    5354static system_ops_t test_system_srv_ops = {
    54         .shutdown = test_shutdown
     55        .poweroff = test_poweroff,
     56        .restart = test_restart
    5557};
    5658
    … …  
    6668        errno_t rc;
    6769
    68         bool shutdown_called;
     70        bool poweroff_called;
     71        bool restart_called;
    6972        bool shutdown_complete_called;
    7073        bool shutdown_failed_called;
    … …  
    9093        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9194
    92         rc = loc_service_register(srv, test_system_svc, &sid);
     95        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    9396        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9497
    … …  
    103106}
    104107
    105 /** system_shutdown() with server returning error response works */
    106 PCUT_TEST(shutdown_failure)
    107 {
    108         errno_t rc;
    109         service_id_t sid;
    110         system_t *system = NULL;
    111         test_response_t resp;
    112         loc_srv_t *srv;
    113 
    114         async_set_fallback_port_handler(test_system_conn, &resp);
    115 
    116         // FIXME This causes this test to be non-reentrant!
    117         rc = loc_server_register(test_system_server, &srv);
    118         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    119 
    120         rc = loc_service_register(srv, test_system_svc, &sid);
     108/** system_poweroff() with server returning error response works */
     109PCUT_TEST(poweroff_failure)
     110{
     111        errno_t rc;
     112        service_id_t sid;
     113        system_t *system = NULL;
     114        test_response_t resp;
     115        loc_srv_t *srv;
     116
     117        async_set_fallback_port_handler(test_system_conn, &resp);
     118
     119        // FIXME This causes this test to be non-reentrant!
     120        rc = loc_server_register(test_system_server, &srv);
     121        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     122
     123        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    121124        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    122125
    … …  
    126129
    127130        resp.rc = ENOMEM;
    128         resp.shutdown_called = false;
    129 
    130         rc = system_shutdown(system);
    131         PCUT_ASSERT_TRUE(resp.shutdown_called);
     131        resp.poweroff_called = false;
     132
     133        rc = system_poweroff(system);
     134        PCUT_ASSERT_TRUE(resp.poweroff_called);
    132135        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    133136
    … …  
    138141}
    139142
    140 /** system_shutdown() with server returning success response works */
    141 PCUT_TEST(shutdown_success)
    142 {
    143         errno_t rc;
    144         service_id_t sid;
    145         system_t *system = NULL;
    146         test_response_t resp;
    147         loc_srv_t *srv;
    148 
    149         async_set_fallback_port_handler(test_system_conn, &resp);
    150 
    151         // FIXME This causes this test to be non-reentrant!
    152         rc = loc_server_register(test_system_server, &srv);
    153         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    154 
    155         rc = loc_service_register(srv, test_system_svc, &sid);
     143/** system_poweroff() with server returning success response works */
     144PCUT_TEST(poweroff_success)
     145{
     146        errno_t rc;
     147        service_id_t sid;
     148        system_t *system = NULL;
     149        test_response_t resp;
     150        loc_srv_t *srv;
     151
     152        async_set_fallback_port_handler(test_system_conn, &resp);
     153
     154        // FIXME This causes this test to be non-reentrant!
     155        rc = loc_server_register(test_system_server, &srv);
     156        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     157
     158        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    156159        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    157160
    … …  
    161164
    162165        resp.rc = EOK;
    163         resp.shutdown_called = false;
    164 
    165         rc = system_shutdown(system);
    166         PCUT_ASSERT_TRUE(resp.shutdown_called);
     166        resp.poweroff_called = false;
     167
     168        rc = system_poweroff(system);
     169        PCUT_ASSERT_TRUE(resp.poweroff_called);
     170        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     171
     172        system_close(system);
     173        rc = loc_service_unregister(srv, sid);
     174        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     175        loc_server_unregister(srv);
     176}
     177
     178/** system_restart() with server returning error response works */
     179PCUT_TEST(restart_failure)
     180{
     181        errno_t rc;
     182        service_id_t sid;
     183        system_t *system = NULL;
     184        test_response_t resp;
     185        loc_srv_t *srv;
     186
     187        async_set_fallback_port_handler(test_system_conn, &resp);
     188
     189        // FIXME This causes this test to be non-reentrant!
     190        rc = loc_server_register(test_system_server, &srv);
     191        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     192
     193        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195
     196        rc = system_open(test_system_svc, NULL, NULL, &system);
     197        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     198        PCUT_ASSERT_NOT_NULL(system);
     199
     200        resp.rc = ENOMEM;
     201        resp.restart_called = false;
     202
     203        rc = system_restart(system);
     204        PCUT_ASSERT_TRUE(resp.restart_called);
     205        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     206
     207        system_close(system);
     208        rc = loc_service_unregister(srv, sid);
     209        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     210        loc_server_unregister(srv);
     211}
     212
     213/** system_restart() with server returning success response works */
     214PCUT_TEST(restart_success)
     215{
     216        errno_t rc;
     217        service_id_t sid;
     218        system_t *system = NULL;
     219        test_response_t resp;
     220        loc_srv_t *srv;
     221
     222        async_set_fallback_port_handler(test_system_conn, &resp);
     223
     224        // FIXME This causes this test to be non-reentrant!
     225        rc = loc_server_register(test_system_server, &srv);
     226        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     227
     228        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
     229        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     230
     231        rc = system_open(test_system_svc, NULL, NULL, &system);
     232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     233        PCUT_ASSERT_NOT_NULL(system);
     234
     235        resp.rc = EOK;
     236        resp.restart_called = false;
     237
     238        rc = system_restart(system);
     239        PCUT_ASSERT_TRUE(resp.restart_called);
    167240        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
    168241
    … …  
    190263        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    191264
    192         rc = loc_service_register(srv, test_system_svc, &sid);
     265        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    193266        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    194267
    … …  
    234307        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    235308
    236         rc = loc_service_register(srv, test_system_svc, &sid);
     309        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
    237310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    238311
    … …  
    279352}
    280353
    281 /** Test system shutdown.
     354/** Test system poweroff.
    282355 *
    283356 * @param arg Argument (test_response_t *)
    284357 */
    285 static errno_t test_shutdown(void *arg)
     358static errno_t test_poweroff(void *arg)
    286359{
    287360        test_response_t *resp = (test_response_t *)arg;
    288361
    289         resp->shutdown_called = true;
     362        resp->poweroff_called = true;
     363        return resp->rc;
     364}
     365
     366/** Test system restart.
     367 *
     368 * @param arg Argument (test_response_t *)
     369 */
     370static errno_t test_restart(void *arg)
     371{
     372        test_response_t *resp = (test_response_t *)arg;
     373
     374        resp->restart_called = true;
    290375        return resp->rc;
    291376}
Note: See TracChangeset for help on using the changeset viewer.