source: mainline/uspace/lib/system/test/system.c@ cb20b05

/*
 * Copyright (c) 2025 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <async.h>
#include <errno.h>
#include <fibril_synch.h>
#include <loc.h>
#include <pcut/pcut.h>
#include <str.h>
#include <system.h>
#include <system_srv.h>
#include "../private/system.h"

PCUT_INIT;

PCUT_TEST_SUITE(system);

static const char *test_system_server = "test-system";
static const char *test_system_svc = "test/system";

void test_system_conn(ipc_call_t *, void *);

static errno_t test_poweroff(void *);
static errno_t test_restart(void *);

static void test_sys_shutdown_complete(void *);
static void test_sys_shutdown_failed(void *);

static system_ops_t test_system_srv_ops = {
        .poweroff = test_poweroff,
        .restart = test_restart
};

system_cb_t test_system_cb = {
        .shutdown_complete = test_sys_shutdown_complete,
        .shutdown_failed = test_sys_shutdown_failed
};

/** Describes to the server how to respond to our request and pass tracking
 * data back to the client.
 */
typedef struct {
        errno_t rc;

        bool poweroff_called;
        bool restart_called;
        bool shutdown_complete_called;
        bool shutdown_failed_called;

        fibril_condvar_t event_cv;
        fibril_mutex_t event_lock;
        system_srv_t *srv;
} test_response_t;

/** system_open(), system_close() work for valid system control service */
PCUT_TEST(open_close)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, NULL, NULL, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);

        system_close(system);
        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** system_poweroff() with server returning error response works */
PCUT_TEST(poweroff_failure)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, NULL, NULL, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);

        resp.rc = ENOMEM;
        resp.poweroff_called = false;

        rc = system_poweroff(system);
        PCUT_ASSERT_TRUE(resp.poweroff_called);
        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);

        system_close(system);
        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** system_poweroff() with server returning success response works */
PCUT_TEST(poweroff_success)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, NULL, NULL, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);

        resp.rc = EOK;
        resp.poweroff_called = false;

        rc = system_poweroff(system);
        PCUT_ASSERT_TRUE(resp.poweroff_called);
        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);

        system_close(system);
        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** system_restart() with server returning error response works */
PCUT_TEST(restart_failure)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, NULL, NULL, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);

        resp.rc = ENOMEM;
        resp.restart_called = false;

        rc = system_restart(system);
        PCUT_ASSERT_TRUE(resp.restart_called);
        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);

        system_close(system);
        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** system_restart() with server returning success response works */
PCUT_TEST(restart_success)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, NULL, NULL, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);

        resp.rc = EOK;
        resp.restart_called = false;

        rc = system_restart(system);
        PCUT_ASSERT_TRUE(resp.restart_called);
        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);

        system_close(system);
        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** 'Shutdown complete' event is delivered from server to client callback
 * function.
 */
PCUT_TEST(shutdown_complete)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, &test_system_cb, &resp, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);
        PCUT_ASSERT_NOT_NULL(resp.srv);

        resp.shutdown_complete_called = false;
        fibril_mutex_initialize(&resp.event_lock);
        fibril_condvar_initialize(&resp.event_cv);
        system_srv_shutdown_complete(resp.srv);

        /* Wait for the event handler to be called. */
        fibril_mutex_lock(&resp.event_lock);
        while (!resp.shutdown_complete_called) {
                fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
        }
        fibril_mutex_unlock(&resp.event_lock);

        system_close(system);

        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** 'Shutdown failed' event is delivered from server to client callback
 * function.
 */
PCUT_TEST(shutdown_failed)
{
        errno_t rc;
        service_id_t sid;
        system_t *system = NULL;
        test_response_t resp;
        loc_srv_t *srv;

        async_set_fallback_port_handler(test_system_conn, &resp);

        // FIXME This causes this test to be non-reentrant!
        rc = loc_server_register(test_system_server, &srv);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = loc_service_register(srv, test_system_svc, fallback_port_id, &sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);

        rc = system_open(test_system_svc, &test_system_cb, &resp, &system);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        PCUT_ASSERT_NOT_NULL(system);
        PCUT_ASSERT_NOT_NULL(resp.srv);

        resp.shutdown_failed_called = false;
        fibril_mutex_initialize(&resp.event_lock);
        fibril_condvar_initialize(&resp.event_cv);
        system_srv_shutdown_failed(resp.srv);

        /* Wait for the event handler to be called. */
        fibril_mutex_lock(&resp.event_lock);
        while (!resp.shutdown_failed_called) {
                fibril_condvar_wait(&resp.event_cv, &resp.event_lock);
        }
        fibril_mutex_unlock(&resp.event_lock);

        system_close(system);

        rc = loc_service_unregister(srv, sid);
        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
        loc_server_unregister(srv);
}

/** Test system control service connection. */
void test_system_conn(ipc_call_t *icall, void *arg)
{
        test_response_t *resp = (test_response_t *)arg;
        system_srv_t srv;

        /* Set up protocol structure */
        system_srv_initialize(&srv);
        srv.ops = &test_system_srv_ops;
        srv.arg = arg;
        resp->srv = &srv;

        /* Handle connection */
        system_conn(icall, &srv);

        resp->srv = NULL;
}

/** Test system poweroff.
 *
 * @param arg Argument (test_response_t *)
 */
static errno_t test_poweroff(void *arg)
{
        test_response_t *resp = (test_response_t *)arg;

        resp->poweroff_called = true;
        return resp->rc;
}

/** Test system restart.
 *
 * @param arg Argument (test_response_t *)
 */
static errno_t test_restart(void *arg)
{
        test_response_t *resp = (test_response_t *)arg;

        resp->restart_called = true;
        return resp->rc;
}

/** Test system shutdown complete.
 *
 * @param arg Argument (test_response_t *)
 */
static void test_sys_shutdown_complete(void *arg)
{
        test_response_t *resp = (test_response_t *)arg;

        resp->shutdown_complete_called = true;
        fibril_condvar_signal(&resp->event_cv);
}

/** Test system shutdown failed.
 *
 * @param arg Argument (test_response_t *)
 */
static void test_sys_shutdown_failed(void *arg)
{
        test_response_t *resp = (test_response_t *)arg;

        resp->shutdown_failed_called = true;
}

PCUT_EXPORT(system);