unit_test_osal_file.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Sylvain Labopin
 */
 
#include "osal/file/osal_file_ops.h"
 
#include "osal/mem/osal_mem.h"
#include "osal/mem/test/osal_mem_fake_provider.h"
 
#include "lexleo_cmocka.h"
 
static void test_osal_file_default_ops(void **state) {
    (void)state;
 
    const osal_file_ops_t *ret = osal_file_default_ops();
 
    assert_non_null(ret);
    assert_non_null(ret->open);
    assert_non_null(ret->read);
    assert_non_null(ret->write);
    assert_non_null(ret->flush);
    assert_non_null(ret->close);
}
 
typedef enum {
    OSAL_FILE_OPEN_SCENARIO_OUT_NULL = 0,
 
    OSAL_FILE_OPEN_SCENARIO_PATHNAME_NULL,
 
    OSAL_FILE_OPEN_SCENARIO_PATHNAME_EMPTY,
 
    OSAL_FILE_OPEN_SCENARIO_MODE_NULL,
 
    OSAL_FILE_OPEN_SCENARIO_MODE_UNSUPPORTED,
 
    OSAL_FILE_OPEN_SCENARIO_MEM_OPS_NULL,
 
    OSAL_FILE_OPEN_SCENARIO_OOM,
 
    OSAL_FILE_OPEN_SCENARIO_OK
 
} osal_file_open_scenario_t;
 
typedef enum {
    OUT_CHECK_NONE,
    OUT_EXPECT_NON_NULL,
    OUT_EXPECT_UNCHANGED
} out_expect_t;
 
typedef struct {
    const char *name;
 
    /* arrange */
    osal_file_open_scenario_t scenario;
    size_t fail_call_idx; /* 0 = no OOM, otherwise 1-based */
 
    /* assert */
    osal_file_status_t expected_ret;
    out_expect_t out_expect;
} test_osal_file_open_case_t;
 
typedef struct {
    /* output state */
    OSAL_FILE *out;
    OSAL_FILE *snapshot;
 
    /* DI */
    const osal_mem_ops_t *mem_ops;
 
    const char *pathname;
    const char *mode;
 
    const osal_file_ops_t *file_ops;
 
    /* active parametric test case */
    const test_osal_file_open_case_t *tc;
} test_osal_file_open_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_osal_file_open(void **state)
{
    const test_osal_file_open_case_t *tc =
        (const test_osal_file_open_case_t *)(*state);
 
    test_osal_file_open_fixture_t *fx =
        (test_osal_file_open_fixture_t *)osal_malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_OOM && tc->fail_call_idx > 0) {
        fake_memory_fail_only_on_call(tc->fail_call_idx);
    }
 
    // DI
    fx->mem_ops = osal_mem_test_fake_ops();
 
    fx->file_ops = osal_file_default_ops();
 
    fx->pathname = "unit_test_osal_file.tmp";
    fx->mode = "wb";
 
    *state = fx;
    return 0;
}
 
static int teardown_osal_file_open(void **state)
{
    test_osal_file_open_fixture_t *fx =
        (test_osal_file_open_fixture_t *)(*state);
 
    if (fx->out && fx->out != fx->snapshot) {
        assert_true(
            fx->file_ops->close(fx->out) == OSAL_FILE_STATUS_OK
        );
        fx->out = NULL;
    }
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    osal_free(fx);
    *state = NULL;
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_osal_file_open(void **state)
{
    test_osal_file_open_fixture_t *fx =
        (test_osal_file_open_fixture_t *)(*state);
    const test_osal_file_open_case_t *tc =
        (const test_osal_file_open_case_t *)fx->tc;
 
    // ARRANGE
    osal_file_status_t ret = (osal_file_status_t)-1; // poison
    fx->out = (OSAL_FILE *)(uintptr_t)0xDEADC0DEu;
    OSAL_FILE **out_arg = &fx->out;
    const char *pathname_arg = fx->pathname;
    const char *mode_arg = fx->mode;
    const osal_mem_ops_t *mem_ops_arg = fx->mem_ops;
 
    // invalid args
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_OUT_NULL) {
        out_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_PATHNAME_NULL) {
        pathname_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_PATHNAME_EMPTY) {
        pathname_arg = "";
    }
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_MODE_NULL) {
        mode_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_MODE_UNSUPPORTED) {
        mode_arg = "w+";
    }
    if (tc->scenario == OSAL_FILE_OPEN_SCENARIO_MEM_OPS_NULL) {
        mem_ops_arg = NULL;
    }
 
    fx->snapshot = fx->out;
 
    // ACT
    ret = fx->file_ops->open(out_arg, pathname_arg, mode_arg, mem_ops_arg);
 
    // ASSERT
    assert_int_equal(ret, tc->expected_ret);
 
    switch (tc->out_expect) {
        case OUT_CHECK_NONE:
            break;
        case OUT_EXPECT_NON_NULL:
            assert_non_null(fx->out);
            assert_ptr_not_equal(fx->out, fx->snapshot);
            break;
        case OUT_EXPECT_UNCHANGED:
            assert_ptr_equal(fx->out, fx->snapshot);
            break;
        default:
            fail();
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_OUT_NULL = {
    .name = "osal_file_open_out_null",
    .scenario = OSAL_FILE_OPEN_SCENARIO_OUT_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_CHECK_NONE
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_PATHNAME_NULL = {
    .name = "osal_file_open_pathname_null",
    .scenario = OSAL_FILE_OPEN_SCENARIO_PATHNAME_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_PATHNAME_EMPTY = {
    .name = "osal_file_open_pathname_empty",
    .scenario = OSAL_FILE_OPEN_SCENARIO_PATHNAME_EMPTY,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_MODE_NULL = {
    .name = "osal_file_open_mode_null",
    .scenario = OSAL_FILE_OPEN_SCENARIO_MODE_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_MODE_UNSUPPORTED = {
    .name = "osal_file_open_mode_unsupported",
    .scenario = OSAL_FILE_OPEN_SCENARIO_MODE_UNSUPPORTED,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_MEM_OPS_NULL = {
    .name = "osal_file_open_mem_ops_null",
    .scenario = OSAL_FILE_OPEN_SCENARIO_MEM_OPS_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_OOM_1 = {
    .name = "osal_file_open_oom_1",
    .scenario = OSAL_FILE_OPEN_SCENARIO_OOM,
    .fail_call_idx = 1,
 
    .expected_ret = OSAL_FILE_STATUS_OOM,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_osal_file_open_case_t CASE_OSAL_FILE_OPEN_OK = {
    .name = "osal_file_open_ok",
    .scenario = OSAL_FILE_OPEN_SCENARIO_OK,
    .fail_call_idx = 0,
 
    .expected_ret = OSAL_FILE_STATUS_OK,
    .out_expect = OUT_EXPECT_NON_NULL
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define OSAL_FILE_OPEN_CASES(X) \
X(CASE_OSAL_FILE_OPEN_OUT_NULL) \
X(CASE_OSAL_FILE_OPEN_PATHNAME_NULL) \
X(CASE_OSAL_FILE_OPEN_PATHNAME_EMPTY) \
X(CASE_OSAL_FILE_OPEN_MODE_NULL) \
X(CASE_OSAL_FILE_OPEN_MODE_UNSUPPORTED) \
X(CASE_OSAL_FILE_OPEN_MEM_OPS_NULL) \
X(CASE_OSAL_FILE_OPEN_OOM_1) \
X(CASE_OSAL_FILE_OPEN_OK)
 
#define OSAL_FILE_MAKE_OPEN_TEST(case_sym) \
LEXLEO_MAKE_TEST(osal_file_open, case_sym)
 
static const struct CMUnitTest osal_file_open_tests[] = {
    OSAL_FILE_OPEN_CASES(OSAL_FILE_MAKE_OPEN_TEST)
};
 
#undef OSAL_FILE_OPEN_CASES
#undef OSAL_FILE_MAKE_OPEN_TEST
 
typedef enum {
    OSAL_FILE_READ_SCENARIO_PTR_NULL = 0,
 
    OSAL_FILE_READ_SCENARIO_ST_NULL,
 
    OSAL_FILE_READ_SCENARIO_STREAM_NULL,
 
    OSAL_FILE_READ_SCENARIO_READ_LESS_THAN_AVAILABLE,
 
    OSAL_FILE_READ_SCENARIO_READ_EXACT_AVAILABLE,
 
    OSAL_FILE_READ_SCENARIO_READ_MORE_THAN_AVAILABLE,
 
    OSAL_FILE_READ_SCENARIO_EMPTY_FILE,
 
    OSAL_FILE_READ_SCENARIO_SEQUENTIAL_READS_PARTIAL_THEN_PARTIAL,
 
    OSAL_FILE_READ_SCENARIO_READ_AFTER_EOF,
 
    OSAL_FILE_READ_SCENARIO_ZERO_SIZE,
 
    OSAL_FILE_READ_SCENARIO_ZERO_NMEMB,
 
    OSAL_FILE_READ_SCENARIO_READ_LESS_THAN_AVAILABLE_SIZE_GT_1,
 
    OSAL_FILE_READ_SCENARIO_READ_EXACT_AVAILABLE_SIZE_GT_1,
 
    OSAL_FILE_READ_SCENARIO_READ_MORE_THAN_AVAILABLE_SIZE_GT_1,
 
} osal_file_read_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    osal_file_read_scenario_t scenario;
    uint8_t file_content[16];
    size_t file_content_len;
    size_t first_size;
    size_t first_nmemb;
    bool do_second_read;
    size_t second_size;
    size_t second_nmemb;
 
    // assert
    size_t first_expected_ret;
    osal_file_status_t first_expected_st;
    size_t second_expected_ret;
    osal_file_status_t second_expected_st;
} test_osal_file_read_case_t;
 
typedef struct {
    // runtime resources
    OSAL_FILE *readable_osal_file;
    OSAL_FILE *writable_osal_file;
 
    osal_file_status_t first_st_storage;
    osal_file_status_t second_st_storage;
    uint8_t first_read_content[16];
    uint8_t second_read_content[16];
 
    // injection
    const osal_mem_ops_t *mem_ops;
 
    // exercised public API
    const osal_file_ops_t *file_ops;
 
    const test_osal_file_read_case_t *tc;
} test_osal_file_read_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_osal_file_read(void **state)
{
    const test_osal_file_read_case_t *tc =
        (const test_osal_file_read_case_t *)(*state);
 
    test_osal_file_read_fixture_t *fx =
        (test_osal_file_read_fixture_t *)osal_malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    // DI
    fake_memory_reset();
    fx->mem_ops = osal_mem_test_fake_ops();
 
    // prepare tmp file
    fx->file_ops = osal_file_default_ops();
    assert_int_equal(
        fx->file_ops->open(
            &fx->writable_osal_file,
            "osal_file_read_tmp_file.txt",
            "wb",
            fx->mem_ops
        ),
        OSAL_FILE_STATUS_OK
    );
    osal_file_status_t st;
    assert_int_equal(
        fx->file_ops->write(
            tc->file_content,
            1,
            tc->file_content_len,
            fx->writable_osal_file,
            &st
        ),
        (size_t)tc->file_content_len
    );
    assert_int_equal(st, OSAL_FILE_STATUS_OK);
    assert_int_equal(
        fx->file_ops->close(
            fx->writable_osal_file
        ),
        OSAL_FILE_STATUS_OK
    );
    fx->writable_osal_file = NULL;
    assert_int_equal(
        fx->file_ops->open(
            &fx->readable_osal_file,
            "osal_file_read_tmp_file.txt",
            "rb",
            fx->mem_ops
        ),
        OSAL_FILE_STATUS_OK
    );
 
    *state = fx;
    return 0;
}
 
static int teardown_osal_file_read(void **state)
{
    test_osal_file_read_fixture_t *fx =
        (test_osal_file_read_fixture_t *)(*state);
 
    if (fx->readable_osal_file) {
        assert_true(
            fx->file_ops->close(fx->readable_osal_file) == OSAL_FILE_STATUS_OK
        );
        fx->readable_osal_file = NULL;
    }
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    osal_free(fx);
    *state = NULL;
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_osal_file_read(void **state)
{
    test_osal_file_read_fixture_t *fx =
        (test_osal_file_read_fixture_t *)(*state);
    const test_osal_file_read_case_t *tc =
        (const test_osal_file_read_case_t *)fx->tc;
 
    // ARRANGE (first read call)
    size_t ret = (size_t)-1; // poison
    void *ptr_arg = fx->first_read_content;
    size_t size_arg = tc->first_size;
    size_t nmemb_arg = tc->first_nmemb;
    OSAL_FILE *stream_arg = fx->readable_osal_file;
    osal_file_status_t *st_arg = &fx->first_st_storage;
 
    // invalid args
    if (tc->scenario == OSAL_FILE_READ_SCENARIO_PTR_NULL) {
        ptr_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_READ_SCENARIO_ST_NULL) {
        st_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_READ_SCENARIO_STREAM_NULL) {
        stream_arg = NULL;
    }
 
    // ACT (first read call)
    ret = fx->file_ops->read(ptr_arg, size_arg, nmemb_arg, stream_arg, st_arg);
 
    // ASSERT (first read call)
    assert_int_equal(ret, tc->first_expected_ret);
    if (st_arg) {
        assert_int_equal(*st_arg, tc->first_expected_st);
    }
    if (tc->first_expected_ret > 0) {
        assert_memory_equal(
            fx->first_read_content,
            tc->file_content,
            (tc->first_expected_ret * tc->first_size <= tc->file_content_len) ?
                tc->first_expected_ret * tc->first_size
                :
                tc->file_content_len
        );
    }
 
    if (!tc->do_second_read) {
        return;
    }
 
    // ARRANGE (second read call)
    ret = (size_t)-1; // poison
    ptr_arg = fx->second_read_content;
    size_arg = tc->second_size;
    nmemb_arg = tc->second_nmemb;
    stream_arg = fx->readable_osal_file;
    st_arg = &fx->second_st_storage;
 
    // ACT (second read call)
    ret = fx->file_ops->read(ptr_arg, size_arg, nmemb_arg, stream_arg, st_arg);
 
    // ASSERT (second read call)
    assert_int_equal(ret, tc->second_expected_ret);
    if (st_arg) {
        assert_int_equal(*st_arg, tc->second_expected_st);
    }
    if (tc->second_expected_ret > 0) {
        assert_true(
            tc->file_content_len >= tc->first_expected_ret * tc->first_size
        );
        assert_memory_equal(
            fx->second_read_content,
            tc->file_content + tc->first_expected_ret * tc->first_size,
            (tc->second_expected_ret * tc->second_size + tc->first_expected_ret * tc->first_size <= tc->file_content_len) ?
                tc->second_expected_ret * tc->second_size : tc->file_content_len - tc->first_expected_ret * tc->first_size
        );
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_PTR_NULL = {
    .name = "osal_file_read_ptr_null",
    .scenario = OSAL_FILE_READ_SCENARIO_PTR_NULL,
 
    /* arrange */
    .file_content = "dummy content", /* '\0' is not considered */
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 3,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_INVALID,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_ST_NULL = {
    .name = "osal_file_read_st_null",
    .scenario = OSAL_FILE_READ_SCENARIO_ST_NULL,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 3,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_STREAM_NULL = {
    .name = "osal_file_read_stream_null",
    .scenario = OSAL_FILE_READ_SCENARIO_STREAM_NULL,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 3,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_INVALID,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_LESS_THAN_AVAILABLE = {
    .name = "osal_file_read_less_than_available",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_LESS_THAN_AVAILABLE,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 10,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 10,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_EXACT_AVAILABLE = {
    .name = "osal_file_read_exact_available",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_EXACT_AVAILABLE,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 14,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 14,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_MORE_THAN_AVAILABLE = {
    .name = "osal_file_read_more_than_available",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_MORE_THAN_AVAILABLE,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 17,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 14,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_EMPTY_FILE = {
    .name = "osal_file_read_empty_file",
    .scenario = OSAL_FILE_READ_SCENARIO_EMPTY_FILE,
 
    /* arrange */
    .file_content = "",
    .file_content_len = 0,
    .first_size = 1,
    .first_nmemb = 3,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_SEQUENTIAL_READS_PARTIAL_THEN_PARTIAL = {
    .name = "osal_file_read_sequential_reads_partial_then_partial",
    .scenario = OSAL_FILE_READ_SCENARIO_SEQUENTIAL_READS_PARTIAL_THEN_PARTIAL,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 6,
    .do_second_read = true,
    .second_size = 1,
    .second_nmemb = 4,
 
    /* assert */
    .first_expected_ret = 6,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .second_expected_ret = 4,
    .second_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_AFTER_EOF = {
    .name = "osal_file_read_after_eof",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_AFTER_EOF,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 14,
    .do_second_read = true,
    .second_size = 1,
    .second_nmemb = 1,
 
    /* assert */
    .first_expected_ret = 14,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .second_expected_ret = 0,
    .second_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_ZERO_SIZE = {
    .name = "osal_file_read_zero_size",
    .scenario = OSAL_FILE_READ_SCENARIO_ZERO_SIZE,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 0,
    .first_nmemb = 14,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_ZERO_NMEMB = {
    .name = "osal_file_read_zero_nmemb",
    .scenario = OSAL_FILE_READ_SCENARIO_ZERO_NMEMB,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 1,
    .first_nmemb = 0,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_LESS_THAN_AVAILABLE_SIZE_GT_1 = {
    .name = "osal_file_read_read_less_than_available_size_gt_1",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_LESS_THAN_AVAILABLE_SIZE_GT_1,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 3,
    .first_nmemb = 4,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 4,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_EXACT_AVAILABLE_SIZE_GT_1 = {
    .name = "osal_file_read_read_exact_available_size_gt_1",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_EXACT_AVAILABLE_SIZE_GT_1,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 2,
    .first_nmemb = 7,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 7,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
static const test_osal_file_read_case_t CASE_OSAL_FILE_READ_READ_MORE_THAN_AVAILABLE_SIZE_GT_1 = {
    .name = "osal_file_read_more_than_available_size_gt_1",
    .scenario = OSAL_FILE_READ_SCENARIO_READ_MORE_THAN_AVAILABLE_SIZE_GT_1,
 
    /* arrange */
    .file_content = "dummy content",
    .file_content_len = 14,
    .first_size = 3,
    .first_nmemb = 5,
    .do_second_read = false,
 
    /* assert */
    .first_expected_ret = 4,
    .first_expected_st = OSAL_FILE_STATUS_OK,
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define OSAL_FILE_READ_CASES(X) \
X(CASE_OSAL_FILE_READ_PTR_NULL) \
X(CASE_OSAL_FILE_READ_ST_NULL) \
X(CASE_OSAL_FILE_READ_STREAM_NULL) \
X(CASE_OSAL_FILE_READ_LESS_THAN_AVAILABLE) \
X(CASE_OSAL_FILE_READ_READ_EXACT_AVAILABLE) \
X(CASE_OSAL_FILE_READ_READ_MORE_THAN_AVAILABLE) \
X(CASE_OSAL_FILE_READ_EMPTY_FILE) \
X(CASE_OSAL_FILE_READ_SEQUENTIAL_READS_PARTIAL_THEN_PARTIAL) \
X(CASE_OSAL_FILE_READ_AFTER_EOF) \
X(CASE_OSAL_FILE_READ_READ_ZERO_SIZE) \
X(CASE_OSAL_FILE_READ_READ_ZERO_NMEMB) \
X(CASE_OSAL_FILE_READ_READ_LESS_THAN_AVAILABLE_SIZE_GT_1) \
X(CASE_OSAL_FILE_READ_READ_EXACT_AVAILABLE_SIZE_GT_1) \
X(CASE_OSAL_FILE_READ_READ_MORE_THAN_AVAILABLE_SIZE_GT_1)
 
#define OSAL_FILE_MAKE_READ_TEST(case_sym) \
LEXLEO_MAKE_TEST(osal_file_read, case_sym)
 
static const struct CMUnitTest osal_file_read_tests[] = {
    OSAL_FILE_READ_CASES(OSAL_FILE_MAKE_READ_TEST)
};
 
#undef OSAL_FILE_READ_CASES
#undef OSAL_FILE_MAKE_READ_TEST
 
typedef enum {
    OSAL_FILE_WRITE_SCENARIO_PTR_NULL = 0,
 
    OSAL_FILE_WRITE_SCENARIO_STREAM_NULL,
 
    OSAL_FILE_WRITE_SCENARIO_ST_NULL,
 
    OSAL_FILE_WRITE_SCENARIO_ZERO_SIZE,
 
    OSAL_FILE_WRITE_SCENARIO_ZERO_NMEMB,
 
    OSAL_FILE_WRITE_SCENARIO_WRITE_ONE_ELEMENT_OK,
 
    OSAL_FILE_WRITE_SCENARIO_WRITE_MULTIPLE_ELEMENTS_SIZE_1_OK,
 
    OSAL_FILE_WRITE_SCENARIO_WRITE_MULTIPLE_ELEMENTS_SIZE_GT_1_OK,
 
    OSAL_FILE_WRITE_SCENARIO_SEQUENTIAL_WRITES_OK,
} osal_file_write_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    osal_file_write_scenario_t scenario;
    uint8_t initial_file_content[16];
    size_t initial_file_content_len;
    const uint8_t first_write_content[16];
    size_t first_size;
    size_t first_nmemb;
    bool do_second_write;
    const uint8_t second_write_content[16];
    size_t second_size;
    size_t second_nmemb;
 
    // assert
    size_t first_expected_ret;
    osal_file_status_t first_expected_st;
    size_t second_expected_ret;
    osal_file_status_t second_expected_st;
    uint8_t expected_file_content[16];
    size_t expected_file_content_len;
} test_osal_file_write_case_t;
 
typedef struct {
    // runtime resources
    OSAL_FILE *writable_osal_file;
    OSAL_FILE *verification_osal_file;
 
    osal_file_status_t first_st_storage;
    osal_file_status_t second_st_storage;
 
    // injection
    const osal_mem_ops_t *mem_ops;
 
    // exercised public API
    const osal_file_ops_t *file_ops;
 
    const test_osal_file_write_case_t *tc;
} test_osal_file_write_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_osal_file_write(void **state)
{
    const test_osal_file_write_case_t *tc =
        (const test_osal_file_write_case_t *)(*state);
 
    test_osal_file_write_fixture_t *fx =
        (test_osal_file_write_fixture_t *)osal_malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    // DI
    fake_memory_reset();
    fx->mem_ops = osal_mem_test_fake_ops();
 
    // prepare tmp file
    fx->file_ops = osal_file_default_ops();
    assert_int_equal(
        fx->file_ops->open(
            &fx->writable_osal_file,
            "osal_file_write_tmp_file.txt",
            "wb",
            fx->mem_ops
        ),
        OSAL_FILE_STATUS_OK
    );
    osal_file_status_t st;
    assert_int_equal(
        fx->file_ops->write(
            tc->initial_file_content,
            1,
            tc->initial_file_content_len,
            fx->writable_osal_file,
            &st
        ),
        (size_t)tc->initial_file_content_len
    );
    assert_int_equal(st, OSAL_FILE_STATUS_OK);
 
    *state = fx;
    return 0;
}
 
static int teardown_osal_file_write(void **state)
{
    test_osal_file_write_fixture_t *fx =
        (test_osal_file_write_fixture_t *)(*state);
 
    if (fx->verification_osal_file) {
            assert_true(
                fx->file_ops->close(fx->verification_osal_file) == OSAL_FILE_STATUS_OK
            );
            fx->verification_osal_file = NULL;
    }
 
    if (fx->writable_osal_file) {
            assert_true(
                fx->file_ops->close(fx->writable_osal_file) == OSAL_FILE_STATUS_OK
            );
            fx->writable_osal_file = NULL;
    }
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    osal_free(fx);
    *state = NULL;
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_osal_file_write(void **state)
{
    test_osal_file_write_fixture_t *fx =
        (test_osal_file_write_fixture_t *)(*state);
    const test_osal_file_write_case_t *tc =
        (const test_osal_file_write_case_t *)fx->tc;
 
    // ARRANGE (first write call)
    size_t first_write_ret = (size_t)-1; // poison
    fx->first_st_storage = (osal_file_status_t)-1;
    const void *ptr_arg = tc->first_write_content;
    size_t size_arg = tc->first_size;
    size_t nmemb_arg = tc->first_nmemb;
    OSAL_FILE *stream_arg = fx->writable_osal_file;
    osal_file_status_t *first_write_st_arg = &fx->first_st_storage;
 
    // invalid args
    if (tc->scenario == OSAL_FILE_WRITE_SCENARIO_PTR_NULL) {
        ptr_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_WRITE_SCENARIO_STREAM_NULL) {
        stream_arg = NULL;
    }
    if (tc->scenario == OSAL_FILE_WRITE_SCENARIO_ST_NULL) {
        first_write_st_arg = NULL;
    }
 
    // ACT (first write call)
    first_write_ret = fx->file_ops->write(ptr_arg, size_arg, nmemb_arg, stream_arg, first_write_st_arg);
 
    // ARRANGE (second write call)
    osal_file_status_t *second_write_st_arg = NULL;
    size_t second_write_ret = (size_t)-1; // poison
    if (tc->do_second_write) {
        fx->second_st_storage = (osal_file_status_t)-1;
        ptr_arg = tc->second_write_content;
        size_arg = tc->second_size;
        nmemb_arg = tc->second_nmemb;
        stream_arg = fx->writable_osal_file;
        second_write_st_arg = &fx->second_st_storage;
 
        // ACT (second write call)
        second_write_ret = fx->file_ops->write(ptr_arg, size_arg, nmemb_arg, stream_arg, second_write_st_arg);
    }
 
    // ASSERT
    assert_true(first_write_ret == tc->first_expected_ret);
    if (first_write_st_arg) {
        assert_int_equal(*first_write_st_arg, tc->first_expected_st);
    }
    if (tc->do_second_write) {
        assert_true(second_write_ret == tc->second_expected_ret);
        if (second_write_st_arg) {
            assert_int_equal(*second_write_st_arg, tc->second_expected_st);
        }
    }
 
    size_t total_len =
        tc->initial_file_content_len
        +
        tc->first_expected_ret * tc->first_size
        +
        ((tc->do_second_write) ? tc->second_expected_ret * tc->second_size : 0);
    assert_true(
        tc->expected_file_content_len
        ==
        total_len
    );
    assert_true(
        fx->file_ops->close(fx->writable_osal_file)
        ==
        OSAL_FILE_STATUS_OK
    );
 
    fx->writable_osal_file = NULL;
 
    if (tc->expected_file_content_len > 0) {
 
        assert_int_equal(
            fx->file_ops->open(
                &fx->verification_osal_file,
                "osal_file_write_tmp_file.txt",
                "rb",
                fx->mem_ops
            ),
            OSAL_FILE_STATUS_OK
        );
        uint8_t read_buf[16] = { 0 };
        osal_file_status_t st;
        assert_true(
            fx->file_ops->read(read_buf, 1, tc->expected_file_content_len, fx->verification_osal_file, &st)
            ==
            tc->expected_file_content_len
        );
        assert_int_equal(st, OSAL_FILE_STATUS_OK);
        assert_memory_equal(
            read_buf,
            tc->expected_file_content,
            tc->expected_file_content_len
        );
        assert_int_equal(
            fx->file_ops->close(
                fx->verification_osal_file
            ),
            OSAL_FILE_STATUS_OK
        );
        fx->verification_osal_file = NULL;
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_PTR_NULL = {
    .name = "osal_file_write_ptr_null",
    .scenario = OSAL_FILE_WRITE_SCENARIO_PTR_NULL,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_size = 1,
    .first_nmemb = 5,
    .do_second_write = false,
 
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_INVALID,
    .expected_file_content = "abc",
    .expected_file_content_len = 3
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_STREAM_NULL = {
    .name = "osal_file_write_stream_null",
    .scenario = OSAL_FILE_WRITE_SCENARIO_STREAM_NULL,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 1,
    .first_nmemb = 5,
    .do_second_write = false,
 
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_INVALID,
    .expected_file_content = "abc",
    .expected_file_content_len = 3
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_ST_NULL = {
    .name = "osal_file_write_st_null",
    .scenario = OSAL_FILE_WRITE_SCENARIO_ST_NULL,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 1,
    .first_nmemb = 5,
    .do_second_write = false,
 
    .first_expected_ret = 0,
    .expected_file_content = "abc",
    .expected_file_content_len = 3
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_ZERO_SIZE = {
    .name = "osal_file_write_zero_size",
    .scenario = OSAL_FILE_WRITE_SCENARIO_ZERO_SIZE,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 0,
    .first_nmemb = 5,
    .do_second_write = false,
 
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abc",
    .expected_file_content_len = 3
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_ZERO_NMEMB = {
    .name = "osal_file_write_zero_nmemb",
    .scenario = OSAL_FILE_WRITE_SCENARIO_ZERO_NMEMB,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 1,
    .first_nmemb = 0,
    .do_second_write = false,
 
    .first_expected_ret = 0,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abc",
    .expected_file_content_len = 3
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_ONE_ELEMENT_OK = {
    .name = "osal_file_write_one_element_ok",
    .scenario = OSAL_FILE_WRITE_SCENARIO_WRITE_ONE_ELEMENT_OK,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 2,
    .first_nmemb = 1,
    .do_second_write = false,
 
    .first_expected_ret = 1,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abcfi",
    .expected_file_content_len = 5
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_MULTIPLE_ELEMENTS_SIZE_1_OK = {
    .name = "osal_file_write_multiple_elements_size_1_ok",
    .scenario = OSAL_FILE_WRITE_SCENARIO_WRITE_MULTIPLE_ELEMENTS_SIZE_1_OK,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 1,
    .first_nmemb = 4,
    .do_second_write = false,
 
    .first_expected_ret = 4,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abcfirs",
    .expected_file_content_len = 7
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_MULTIPLE_ELEMENTS_SIZE_GT_1_OK = {
    .name = "osal_file_write_multiple_elements_size_gt_1_ok",
    .scenario = OSAL_FILE_WRITE_SCENARIO_WRITE_MULTIPLE_ELEMENTS_SIZE_GT_1_OK,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 2,
    .first_nmemb = 2,
    .do_second_write = false,
 
    .first_expected_ret = 2,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abcfirs",
    .expected_file_content_len = 7
};
 
static const test_osal_file_write_case_t CASE_OSAL_FILE_WRITE_SEQUENTIAL_WRITES_OK = {
    .name = "osal_file_write_sequential_writes_ok",
    .scenario = OSAL_FILE_WRITE_SCENARIO_SEQUENTIAL_WRITES_OK,
 
    .initial_file_content = "abc",
    .initial_file_content_len = 3,
    .first_write_content = "first",
    .first_size = 1,
    .first_nmemb = 5,
    .do_second_write = true,
    .second_write_content = "second",
    .second_size = 2,
    .second_nmemb = 3,
 
    .first_expected_ret = 5,
    .first_expected_st = OSAL_FILE_STATUS_OK,
    .second_expected_ret = 3,
    .second_expected_st = OSAL_FILE_STATUS_OK,
    .expected_file_content = "abcfirstsecond",
    .expected_file_content_len = 14
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define OSAL_FILE_WRITE_CASES(X) \
X(CASE_OSAL_FILE_WRITE_PTR_NULL) \
X(CASE_OSAL_FILE_WRITE_STREAM_NULL) \
X(CASE_OSAL_FILE_WRITE_ST_NULL) \
X(CASE_OSAL_FILE_WRITE_ZERO_SIZE) \
X(CASE_OSAL_FILE_WRITE_ZERO_NMEMB) \
X(CASE_OSAL_FILE_WRITE_ONE_ELEMENT_OK) \
X(CASE_OSAL_FILE_WRITE_MULTIPLE_ELEMENTS_SIZE_1_OK) \
X(CASE_OSAL_FILE_WRITE_MULTIPLE_ELEMENTS_SIZE_GT_1_OK) \
X(CASE_OSAL_FILE_WRITE_SEQUENTIAL_WRITES_OK)
 
#define OSAL_FILE_MAKE_WRITE_TEST(case_sym) \
LEXLEO_MAKE_TEST(osal_file_write, case_sym)
 
static const struct CMUnitTest osal_file_write_tests[] = {
    OSAL_FILE_WRITE_CASES(OSAL_FILE_MAKE_WRITE_TEST)
};
 
#undef OSAL_FILE_WRITE_CASES
#undef OSAL_FILE_MAKE_WRITE_TEST
 
typedef enum {
    OSAL_FILE_FLUSH_SCENARIO_STREAM_NULL = 0,
 
    OSAL_FILE_FLUSH_SCENARIO_OK,
} osal_file_flush_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    osal_file_flush_scenario_t scenario;
    uint8_t file_content[16];
    size_t file_content_len;
 
    // assert
    osal_file_status_t expected_ret;
} test_osal_file_flush_case_t;
 
typedef struct {
    // runtime resources
    OSAL_FILE *writable_osal_file;
 
    // injection
    const osal_mem_ops_t *mem_ops;
 
    // exercised public operations table
    const osal_file_ops_t *file_ops;
 
    const test_osal_file_flush_case_t *tc;
} test_osal_file_flush_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_osal_file_flush(void **state)
{
    const test_osal_file_flush_case_t *tc =
        (const test_osal_file_flush_case_t *)(*state);
 
    test_osal_file_flush_fixture_t *fx =
        (test_osal_file_flush_fixture_t *)osal_malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    // DI
    fake_memory_reset();
    fx->mem_ops = osal_mem_test_fake_ops();
 
    // prepare tmp file
    fx->file_ops = osal_file_default_ops();
    assert_int_equal(
        fx->file_ops->open(
            &fx->writable_osal_file,
            "osal_file_flush_tmp_file.txt",
            "wb",
            fx->mem_ops
        ),
        OSAL_FILE_STATUS_OK
    );
    osal_file_status_t st;
    assert_true(
        fx->file_ops->write(
            tc->file_content,
            1,
            tc->file_content_len,
            fx->writable_osal_file,
            &st)
        ==
        tc->file_content_len
    );
    assert_int_equal(st, OSAL_FILE_STATUS_OK);
 
    *state = fx;
    return 0;
}
 
static int teardown_osal_file_flush(void **state)
{
    test_osal_file_flush_fixture_t *fx =
        (test_osal_file_flush_fixture_t *)(*state);
 
    if (fx->writable_osal_file) {
            assert_true(
                fx->file_ops->close(fx->writable_osal_file) == OSAL_FILE_STATUS_OK
            );
            fx->writable_osal_file = NULL;
    }
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    osal_free(fx);
    *state = NULL;
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_osal_file_flush(void **state)
{
    test_osal_file_flush_fixture_t *fx =
        (test_osal_file_flush_fixture_t *)(*state);
    const test_osal_file_flush_case_t *tc =
        (const test_osal_file_flush_case_t *)fx->tc;
 
    // ARRANGE
    OSAL_FILE *stream_arg = fx->writable_osal_file;
 
    // invalid args
    if (tc->scenario == OSAL_FILE_FLUSH_SCENARIO_STREAM_NULL) {
        stream_arg = NULL;
    }
 
    // ACT
    osal_file_status_t ret = fx->file_ops->flush(stream_arg);
 
 
    // ASSERT
    assert_int_equal(ret, tc->expected_ret);
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_osal_file_flush_case_t CASE_OSAL_FILE_FLUSH_STREAM_NULL = {
    .name = "osal_file_flush_stream_null",
    .scenario = OSAL_FILE_FLUSH_SCENARIO_STREAM_NULL,
 
    .file_content = "abc",
    .file_content_len = 3,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID
};
 
static const test_osal_file_flush_case_t CASE_OSAL_FILE_FLUSH_OK = {
    .name = "osal_file_flush_ok",
    .scenario = OSAL_FILE_FLUSH_SCENARIO_OK,
 
    .file_content = "abc",
    .file_content_len = 3,
 
    .expected_ret = OSAL_FILE_STATUS_OK
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define OSAL_FILE_FLUSH_CASES(X) \
X(CASE_OSAL_FILE_FLUSH_STREAM_NULL) \
X(CASE_OSAL_FILE_FLUSH_OK)
 
#define OSAL_FILE_MAKE_FLUSH_TEST(case_sym) \
LEXLEO_MAKE_TEST(osal_file_flush, case_sym)
 
static const struct CMUnitTest osal_file_flush_tests[] = {
    OSAL_FILE_FLUSH_CASES(OSAL_FILE_MAKE_FLUSH_TEST)
};
 
#undef OSAL_FILE_FLUSH_CASES
#undef OSAL_FILE_MAKE_FLUSH_TEST
 
typedef enum {
    OSAL_FILE_CLOSE_SCENARIO_STREAM_NULL = 0,
 
    OSAL_FILE_CLOSE_SCENARIO_OK,
} osal_file_close_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    osal_file_close_scenario_t scenario;
 
    // assert
    osal_file_status_t expected_ret;
} test_osal_file_close_case_t;
 
typedef struct {
    // runtime resources
    OSAL_FILE *osal_file;
 
    // injection
    const osal_mem_ops_t *mem_ops;
 
    // exercised public operations table
    const osal_file_ops_t *file_ops;
 
    const test_osal_file_close_case_t *tc;
} test_osal_file_close_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_osal_file_close(void **state)
{
    const test_osal_file_close_case_t *tc =
        (const test_osal_file_close_case_t *)(*state);
 
    test_osal_file_close_fixture_t *fx =
        (test_osal_file_close_fixture_t *)osal_malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    // DI
    fake_memory_reset();
    fx->mem_ops = osal_mem_test_fake_ops();
 
    // prepare tmp file
    fx->file_ops = osal_file_default_ops();
    assert_int_equal(
        fx->file_ops->open(
            &fx->osal_file,
            "osal_file_close_tmp_file.txt",
            "wb",
            fx->mem_ops
        ),
        OSAL_FILE_STATUS_OK
    );
 
    *state = fx;
    return 0;
}
 
static int teardown_osal_file_close(void **state)
{
    test_osal_file_close_fixture_t *fx =
        (test_osal_file_close_fixture_t *)(*state);
 
    if (fx->osal_file) {
        assert_int_equal(
            fx->file_ops->close(fx->osal_file),
            OSAL_FILE_STATUS_OK
        );
        fx->osal_file = NULL;
    }
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
 
    osal_free(fx);
    *state = NULL;
    return 0;
}
 
//-----------------------------------------------------------------------------
// TEST
//-----------------------------------------------------------------------------
 
static void test_osal_file_close(void **state)
{
    test_osal_file_close_fixture_t *fx =
        (test_osal_file_close_fixture_t *)(*state);
    const test_osal_file_close_case_t *tc =
        (const test_osal_file_close_case_t *)fx->tc;
 
    // ARRANGE
    OSAL_FILE *stream_arg = fx->osal_file;
 
    // invalid args
    if (tc->scenario == OSAL_FILE_CLOSE_SCENARIO_STREAM_NULL) {
        stream_arg = NULL;
    }
 
    // ACT
    osal_file_status_t ret = fx->file_ops->close(stream_arg);
    if (ret == OSAL_FILE_STATUS_OK && stream_arg == fx->osal_file) {
        fx->osal_file = NULL;
    }
 
    // ASSERT
    assert_int_equal(ret, tc->expected_ret);
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_osal_file_close_case_t CASE_OSAL_FILE_CLOSE_STREAM_NULL = {
    .name = "osal_file_close_stream_null",
    .scenario = OSAL_FILE_CLOSE_SCENARIO_STREAM_NULL,
 
    .expected_ret = OSAL_FILE_STATUS_INVALID
};
 
static const test_osal_file_close_case_t CASE_OSAL_FILE_CLOSE_OK = {
    .name = "osal_file_close_ok",
    .scenario = OSAL_FILE_CLOSE_SCENARIO_OK,
 
    .expected_ret = OSAL_FILE_STATUS_OK
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define OSAL_FILE_CLOSE_CASES(X) \
X(CASE_OSAL_FILE_CLOSE_STREAM_NULL) \
X(CASE_OSAL_FILE_CLOSE_OK)
 
#define OSAL_FILE_MAKE_CLOSE_TEST(case_sym) \
LEXLEO_MAKE_TEST(osal_file_close, case_sym)
 
static const struct CMUnitTest osal_file_close_tests[] = {
    OSAL_FILE_CLOSE_CASES(OSAL_FILE_MAKE_CLOSE_TEST)
};
 
#undef OSAL_FILE_CLOSE_CASES
#undef OSAL_FILE_MAKE_CLOSE_TEST
 
//-----------------------------------------------------------------------------
// MAIN
//-----------------------------------------------------------------------------
 
int main(void) {
    static const struct CMUnitTest osal_file_non_parametric_tests[] = {
        cmocka_unit_test(test_osal_file_default_ops)
    };
 
    int failed = 0;
    failed += cmocka_run_group_tests(osal_file_non_parametric_tests, NULL, NULL);
    failed += cmocka_run_group_tests(osal_file_open_tests, NULL, NULL);
    failed += cmocka_run_group_tests(osal_file_read_tests, NULL, NULL);
    failed += cmocka_run_group_tests(osal_file_write_tests, NULL, NULL);
    failed += cmocka_run_group_tests(osal_file_flush_tests, NULL, NULL);
    failed += cmocka_run_group_tests(osal_file_close_tests, NULL, NULL);
 
    return failed;
}