unit_tests_logger_default.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Sylvain Labopin
 */
 
#include "logger_default/cr/logger_default_cr_api.h"
 
#include "logger/borrowers/logger.h"
#include "logger/lifecycle/logger_lifecycle.h"
#include "logger/cr/logger_cr_api.h"
 
#include "stream/borrowers/stream_types.h"
#include "stream/test/stream_fake_provider.h"
 
#include "osal/mem/osal_mem.h"
#include "osal/mem/test/osal_mem_fake_provider.h"
 
#include "osal/time/test/osal_time_fake_provider.h"
 
#include "policy/lexleo_cstd_types.h"
#include "policy/lexleo_cstd_lib.h"
 
#include "lexleo_cmocka.h"
 
static void test_logger_default_default_cfg(void **state)
{
    (void)state;
 
    logger_default_cfg_t ret = logger_default_default_cfg();
 
    assert_true(ret.append_newline);
}
 
static void test_logger_default_default_env(void **state) {
    (void)state;
 
    stream_t *dummy_stream_p = (stream_t *)(uintptr_t)0x1234u;
 
    const osal_time_ops_t *dummy_time_ops =
        (const osal_time_ops_t *)(uintptr_t)0x4567u;
 
    const osal_mem_ops_t *dummy_adapter_mem_p =
        (const osal_mem_ops_t *)(uintptr_t)0x5678u;
 
    const logger_env_t dummy_port_env = {0};
    const logger_env_t *dummy_port_env_p = &dummy_port_env;
 
    logger_default_env_t ret =
        logger_default_default_env(
            dummy_stream_p,
            dummy_time_ops,
            dummy_adapter_mem_p,
            dummy_port_env_p);
 
    assert_ptr_equal(ret.stream, dummy_stream_p);
    assert_ptr_equal(ret.time_ops, dummy_time_ops);
    assert_ptr_equal(ret.adapter_mem, dummy_adapter_mem_p);
    assert_memory_equal(&ret.port_env, dummy_port_env_p, sizeof(ret.port_env));
}
 
typedef enum {
    LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OK = 0,
 
    LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OUT_NULL,
 
    LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_CFG_NULL,
 
    LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_ENV_NULL,
 
    LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OOM,
} logger_default_create_logger_scenario_t;
 
typedef enum {
    OUT_CHECK_NONE,
    OUT_EXPECT_NULL,
    OUT_EXPECT_NON_NULL,
    OUT_EXPECT_UNCHANGED
} out_expect_t;
 
typedef struct {
    const char *name;
 
    // arrange
    logger_default_create_logger_scenario_t scenario;
    size_t fail_call_idx; // 0 = no OOM; otherwise 1-based allocation index
 
    // assert
    logger_status_t expected_ret;
    out_expect_t out_expect;
} test_logger_default_create_logger_case_t;
 
typedef struct {
    // runtime resources
    logger_t *out;
    stream_fake_t *fake_stream_adapter;
    stream_t *fake_stream;
 
    // injection
    logger_default_env_t env;
 
    logger_default_cfg_t cfg;
 
    const test_logger_default_create_logger_case_t *tc;
} test_logger_default_create_logger_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_logger_default_create_logger(void **state)
{
    const test_logger_default_create_logger_case_t *tc =
        (const test_logger_default_create_logger_case_t *)(*state);
 
    test_logger_default_create_logger_fixture_t *fx = malloc(sizeof(*fx));
    if (!fx) return -1;
    osal_memset(fx, 0, sizeof(*fx));
 
    fake_memory_reset();
    fake_time_reset();
 
    fx->cfg.append_newline = true;
 
    assert_int_equal(
        stream_fake_create(&fx->fake_stream_adapter, &fx->fake_stream, osal_mem_test_fake_ops()),
        STREAM_STATUS_OK
    );
 
    stream_fake_reset(fx->fake_stream_adapter);
 
    // DI
    fx->env.stream = fx->fake_stream;
    fx->env.time_ops = osal_time_test_fake_ops();
    fx->env.adapter_mem = osal_mem_test_fake_ops();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
 
    fx->tc = tc;
 
    if (tc->scenario == LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OOM) {
        fake_memory_fail_only_on_call(tc->fail_call_idx);
    }
 
    *state = fx;
 
    return 0;
}
 
static int teardown_logger_default_create_logger(void **state)
{
    test_logger_default_create_logger_fixture_t *fx =
        (test_logger_default_create_logger_fixture_t *)(*state);
 
    if (fx->out) {
        logger_destroy(&fx->out);
        fx->out = NULL;
    }
 
    stream_fake_destroy(&fx->fake_stream_adapter, &fx->fake_stream);
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    free(fx);
 
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_logger_default_create_logger(void **state)
{
    test_logger_default_create_logger_fixture_t *fx =
        (test_logger_default_create_logger_fixture_t *)(*state);
    const test_logger_default_create_logger_case_t *tc = fx->tc;
 
    // ARRANGE
    logger_status_t ret = (logger_status_t)-1; // poison
 
    logger_t **out_arg = &fx->out;
    const logger_default_cfg_t *cfg_arg = &fx->cfg;
    const logger_default_env_t *env_arg = &fx->env;
 
    // invalid args
    if (tc->scenario == LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OUT_NULL) out_arg = NULL;
    if (tc->scenario == LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_CFG_NULL) cfg_arg = NULL;
    if (tc->scenario == LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_ENV_NULL) env_arg = NULL;
 
    // ensure OUT_EXPECT_UNCHANGED is meaningful
    if (tc->out_expect == OUT_EXPECT_UNCHANGED && out_arg != NULL) {
        fx->out = (logger_t *)(uintptr_t)0xDEADC0DEu; // sentinel
    }
 
    logger_t *out_arg_snapshot = fx->out;
 
    // ACT
    ret = logger_default_create_logger(out_arg, cfg_arg, env_arg);
 
    // ASSERT
    assert_int_equal(ret, tc->expected_ret);
 
    switch (tc->out_expect) {
        case OUT_CHECK_NONE: break;
        case OUT_EXPECT_NULL: assert_null(fx->out); break;
        case OUT_EXPECT_NON_NULL: assert_non_null(fx->out); break;
        case OUT_EXPECT_UNCHANGED:
            assert_ptr_equal(out_arg_snapshot, fx->out);
            fx->out = NULL; // prevent teardown from destroying sentinel
            break;
        default: assert_true(false);
    }
 
    if (tc->scenario == LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OK) {
        assert_non_null(fx->out);
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_OUT_NULL = {
    .name = "logger_default_create_logger_out_null",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OUT_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = LOGGER_STATUS_INVALID,
    .out_expect = OUT_CHECK_NONE
};
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_CFG_NULL = {
    .name = "logger_default_create_logger_cfg_null",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_CFG_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = LOGGER_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_ENV_NULL = {
    .name = "logger_default_create_logger_env_null",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_ENV_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = LOGGER_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_OOM_1 = {
    .name = "logger_default_create_logger_oom_1",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OOM,
    .fail_call_idx = 1,
 
    .expected_ret = LOGGER_STATUS_OOM,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_OOM_2 = {
    .name = "logger_default_create_logger_oom_2",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OOM,
    .fail_call_idx = 2,
 
    .expected_ret = LOGGER_STATUS_OOM,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_logger_default_create_logger_case_t CASE_LOGGER_DEFAULT_CREATE_LOGGER_OK = {
    .name = "logger_default_create_logger_ok",
    .scenario = LOGGER_DEFAULT_CREATE_LOGGER_SCENARIO_OK,
    .fail_call_idx = 0,
 
    .expected_ret = LOGGER_STATUS_OK,
    .out_expect = OUT_EXPECT_NON_NULL
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define LOGGER_DEFAULT_CREATE_LOGGER_CASES(X) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_OUT_NULL) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_CFG_NULL) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_ENV_NULL) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_OOM_1) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_OOM_2) \
X(CASE_LOGGER_DEFAULT_CREATE_LOGGER_OK)
 
#define LOGGER_DEFAULT_MAKE_CREATE_LOGGER_TEST(case_sym) \
LEXLEO_MAKE_TEST(logger_default_create_logger, case_sym)
 
static const struct CMUnitTest logger_default_create_logger_tests[] = {
    LOGGER_DEFAULT_CREATE_LOGGER_CASES(LOGGER_DEFAULT_MAKE_CREATE_LOGGER_TEST)
};
 
#undef LOGGER_DEFAULT_CREATE_LOGGER_CASES
#undef LOGGER_DEFAULT_MAKE_CREATE_LOGGER_TEST
 
typedef enum {
    LOGGER_DEFAULT_LOG_SCENARIO_OK_NO_NEWLINE = 0,
    LOGGER_DEFAULT_LOG_SCENARIO_MESSAGE_NULL,
    LOGGER_DEFAULT_LOG_SCENARIO_OK_APPEND_NEWLINE,
    LOGGER_DEFAULT_LOG_SCENARIO_STREAM_WRITE_FAIL,
    LOGGER_DEFAULT_LOG_SCENARIO_TIME_OPS_FAIL,
} logger_default_log_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    logger_default_log_scenario_t scenario;
    const char *message;
    stream_status_t write_ret;
    osal_time_status_t time_ops_status;
 
    // assert
    logger_status_t expected_ret;
    bool write_call;
    size_t expected_written_len;
    const char *expected_written_message;
} test_logger_default_log_case_t;
 
typedef struct {
    logger_t *logger;
 
    logger_default_env_t env;
    logger_default_cfg_t cfg;
 
    stream_fake_t *fake_stream_adapter;
    stream_t *fake_stream;
 
    const test_logger_default_log_case_t *tc;
} test_logger_default_log_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_logger_default_log(void **state)
{
    const test_logger_default_log_case_t *tc = *state;
 
    test_logger_default_log_fixture_t *fx = malloc(sizeof(*fx));
    if (!fx) return -1;
    osal_memset(fx, 0, sizeof(*fx));
 
    fake_memory_reset();
    fake_time_reset();
 
    fake_time_set_now_status(OSAL_TIME_STATUS_OK);
    fake_time_set_now_out((osal_time_t){ .epoch_seconds = 0 });
 
    assert_int_equal(
        stream_fake_create(&fx->fake_stream_adapter, &fx->fake_stream, osal_mem_test_fake_ops()),
        STREAM_STATUS_OK
    );
 
    stream_fake_reset(fx->fake_stream_adapter);
 
    fx->cfg.append_newline =
        (tc->scenario == LOGGER_DEFAULT_LOG_SCENARIO_OK_APPEND_NEWLINE);
 
    fx->env.stream = fx->fake_stream;
    fx->env.time_ops = osal_time_test_fake_ops();
    fx->env.adapter_mem = osal_mem_test_fake_ops();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
 
    assert_int_equal(
        logger_default_create_logger(&fx->logger, &fx->cfg, &fx->env),
        LOGGER_STATUS_OK
    );
 
    fx->tc = tc;
    *state = fx;
 
    return 0;
}
 
static int teardown_logger_default_log(void **state)
{
    test_logger_default_log_fixture_t *fx = *state;
 
    logger_destroy(&fx->logger);
    stream_fake_destroy(&fx->fake_stream_adapter, &fx->fake_stream);
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    free(fx);
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_logger_default_log(void **state)
{
    test_logger_default_log_fixture_t *fx = *state;
 
    logger_status_t ret = (logger_status_t)-1;
 
    if (fx->tc->scenario == LOGGER_DEFAULT_LOG_SCENARIO_STREAM_WRITE_FAIL) {
        stream_fake_fail_write_since(
            fx->fake_stream_adapter,
            1,
            fx->tc->write_ret
        );
    }
 
    if (fx->tc->scenario == LOGGER_DEFAULT_LOG_SCENARIO_TIME_OPS_FAIL) {
        fake_time_set_now_status(fx->tc->time_ops_status);
    }
 
    ret = logger_log(fx->logger, fx->tc->message);
 
    assert_int_equal(ret, fx->tc->expected_ret);
 
    assert_true(
        fx->tc->write_call ==
        (stream_fake_counters(fx->fake_stream_adapter)->write_calls > 0)
    );
 
    if (fx->tc->expected_written_message) {
        assert_int_equal(
            fx->tc->expected_written_len,
            stream_fake_written_len(fx->fake_stream_adapter)
        );
 
        assert_memory_equal(
            stream_fake_written_data(fx->fake_stream_adapter),
            fx->tc->expected_written_message,
            fx->tc->expected_written_len
        );
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_logger_default_log_case_t CASE_LOGGER_DEFAULT_LOG_MESSAGE_NULL = {
    .name = "logger_default_log_message_null",
    .scenario = LOGGER_DEFAULT_LOG_SCENARIO_MESSAGE_NULL,
    .message = NULL,
    .expected_ret = LOGGER_STATUS_INVALID,
    .write_call = false,
};
 
static const test_logger_default_log_case_t CASE_LOGGER_DEFAULT_LOG_OK_NO_NEWLINE = {
    .name = "logger_default_log_ok_no_newline",
    .scenario = LOGGER_DEFAULT_LOG_SCENARIO_OK_NO_NEWLINE,
    .message = "abc",
    .write_ret = STREAM_STATUS_OK,
    .time_ops_status = OSAL_TIME_STATUS_OK,
    .expected_ret = LOGGER_STATUS_OK,
    .write_call = true,
    .expected_written_len = sizeof("[1970-01-01 00:00:00 UTC+0] abc") - 1,
    .expected_written_message = "[1970-01-01 00:00:00 UTC+0] abc"
};
 
static const test_logger_default_log_case_t CASE_LOGGER_DEFAULT_LOG_OK_APPEND_NEWLINE = {
    .name = "logger_default_log_ok_append_newline",
    .scenario = LOGGER_DEFAULT_LOG_SCENARIO_OK_APPEND_NEWLINE,
    .message = "abc",
    .write_ret = STREAM_STATUS_OK,
    .time_ops_status = OSAL_TIME_STATUS_OK,
    .expected_ret = LOGGER_STATUS_OK,
    .write_call = true,
    .expected_written_len = sizeof("[1970-01-01 00:00:00 UTC+0] abc\n") - 1,
    .expected_written_message = "[1970-01-01 00:00:00 UTC+0] abc\n"
};
 
static const test_logger_default_log_case_t CASE_LOGGER_DEFAULT_LOG_WRITE_FAIL = {
    .name = "logger_default_log_write_fail",
    .scenario = LOGGER_DEFAULT_LOG_SCENARIO_STREAM_WRITE_FAIL,
    .message = "abc",
    .write_ret = STREAM_STATUS_IO_ERROR,
    .expected_ret = LOGGER_STATUS_IO_ERROR,
    .write_call = true,
};
 
static const test_logger_default_log_case_t CASE_LOGGER_DEFAULT_LOG_TIME_FAIL = {
    .name = "logger_default_log_time_fail",
    .scenario = LOGGER_DEFAULT_LOG_SCENARIO_TIME_OPS_FAIL,
    .message = "abc",
    .time_ops_status = OSAL_TIME_STATUS_ERROR,
    .expected_ret = LOGGER_STATUS_OK,
    .write_call = true,
    .expected_written_len = sizeof("[timestamp error] abc") - 1,
    .expected_written_message = "[timestamp error] abc"
};
 
//-----------------------------------------------------------------------------
// REGISTRY
//-----------------------------------------------------------------------------
 
#define LOGGER_DEFAULT_LOG_CASES(X) \
X(CASE_LOGGER_DEFAULT_LOG_MESSAGE_NULL) \
X(CASE_LOGGER_DEFAULT_LOG_OK_NO_NEWLINE) \
X(CASE_LOGGER_DEFAULT_LOG_OK_APPEND_NEWLINE) \
X(CASE_LOGGER_DEFAULT_LOG_WRITE_FAIL) \
X(CASE_LOGGER_DEFAULT_LOG_TIME_FAIL)
 
#define LOGGER_DEFAULT_MAKE_LOG_TEST(case_sym) \
LEXLEO_MAKE_TEST(logger_default_log, case_sym)
 
static const struct CMUnitTest logger_default_log_tests[] = {
    LOGGER_DEFAULT_LOG_CASES(LOGGER_DEFAULT_MAKE_LOG_TEST)
};
 
#undef LOGGER_DEFAULT_LOG_CASES
#undef LOGGER_DEFAULT_MAKE_LOG_TEST
 
static void test_logger_default_destroy(void **state)
{
    (void)state;
 
    fake_memory_reset();
    fake_time_reset();
 
    logger_t *logger = NULL;
    stream_fake_t *fake_stream_adapter = NULL;
    stream_t *fake_stream = NULL;
 
    const logger_default_cfg_t cfg = {
        .append_newline = true
    };
 
    const logger_default_env_t env = {
        .stream = NULL, /* set below after stream creation */
        .time_ops = NULL, /* set below */
        .adapter_mem = NULL, /* set below */
        .port_env = {
            .mem = NULL /* set below */
        }
    };
 
    logger_default_env_t env_local = env;
 
    assert_int_equal(
        stream_fake_create(
            &fake_stream_adapter,
            &fake_stream,
            osal_mem_test_fake_ops()),
        STREAM_STATUS_OK
    );
 
    stream_fake_reset(fake_stream_adapter);
 
    env_local.stream = fake_stream;
    env_local.time_ops = osal_time_test_fake_ops();
    env_local.adapter_mem = osal_mem_test_fake_ops();
    env_local.port_env.mem = osal_mem_test_fake_ops();
 
    assert_int_equal(
        logger_default_create_logger(&logger, &cfg, &env_local),
        LOGGER_STATUS_OK
    );
    assert_non_null(logger);
 
    /*
     * Exercise the private destroy callback through the public lifecycle API.
     */
    logger_destroy(&logger);
 
    assert_null(logger);
 
    stream_fake_destroy(&fake_stream_adapter, &fake_stream);
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
}
 
//-----------------------------------------------------------------------------
// MAIN
//-----------------------------------------------------------------------------
 
int main(void) {
    static const struct CMUnitTest logger_default_non_parametric_tests[] = {
        cmocka_unit_test(test_logger_default_default_cfg),
        cmocka_unit_test(test_logger_default_default_env),
        cmocka_unit_test(test_logger_default_destroy),
    };
 
    int failed = 0;
    failed += cmocka_run_group_tests(logger_default_non_parametric_tests, NULL, NULL);
    failed += cmocka_run_group_tests(logger_default_create_logger_tests, NULL, NULL);
    failed += cmocka_run_group_tests(logger_default_log_tests, NULL, NULL);
 
    return failed;
}