unit_test_stream.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Sylvain Labopin
 */
 
#include "stream/borrowers/stream.h"
 
#include "stream/lifecycle/stream_lifecycle.h"
#include "stream/adapters/stream_adapters_api.h"
#include "stream/cr/stream_cr_api.h"
 
#include "osal/mem/osal_mem.h"
#include "osal/mem/test/osal_mem_fake_provider.h"
 
#include "policy/lexleo_cstd_types.h"
#include "policy/lexleo_cstd_lib.h"
#include "policy/lexleo_cstd_jmp.h"
 
#include "lexleo_cmocka.h"
 
//-----------------------------------------------------------------------------
// LOCAL TEST DOUBLES
//-----------------------------------------------------------------------------
 
typedef struct fake_stream_backend_t {
    int read_called;
    int write_called;
    int flush_called;
    int close_called;
 
    void *last_read_buf;
    const void *last_write_buf;
    size_t last_read_n;
    size_t last_write_n;
    void *last_backend;
    stream_status_t *last_read_st;
    stream_status_t *last_write_st;
 
    stream_status_t read_st_to_set;
    stream_status_t write_st_to_set;
    size_t read_ret;
    size_t write_ret;
    stream_status_t flush_ret;
    stream_status_t close_ret;
} fake_stream_backend_t;
 
static void fake_stream_backend_reset(fake_stream_backend_t *b) {
    assert_non_null(b);
    b->read_called = 0;
    b->write_called = 0;
    b->flush_called = 0;
    b->close_called = 0;
 
    // last arguments
    b->last_read_buf = NULL;
    b->last_write_buf = NULL;
    b->last_read_n = (size_t)-1;
    b->last_write_n = (size_t)-1;
    b->last_backend = NULL;
    b->last_read_st = NULL;
    b->last_write_st = NULL;
 
    // configurable behavior
    b->read_st_to_set = STREAM_STATUS_INVALID;
    b->write_st_to_set = STREAM_STATUS_INVALID;
    b->read_ret = (size_t)-1;
    b->write_ret = (size_t)-1;
    b->flush_ret = STREAM_STATUS_INVALID;
    b->close_ret = STREAM_STATUS_OK;
}
 
static size_t fake_stream_read(
    void *backend,
    void *buf,
    size_t n,
    stream_status_t *st)
{
    fake_stream_backend_t *b = (fake_stream_backend_t *)backend;
    assert_non_null(b);
 
    b->read_called++;
 
    b->last_backend = backend;
    b->last_read_buf = buf;
    b->last_read_n = n;
    b->last_read_st = st;
 
    if (st) *st = b->read_st_to_set;
    return b->read_ret;
}
 
static size_t fake_stream_write(
    void *backend,
    const void *buf,
    size_t n,
    stream_status_t *st)
{
    fake_stream_backend_t *b = (fake_stream_backend_t *)backend;
    assert_non_null(b);
 
    b->write_called++;
 
    b->last_backend = backend;
    b->last_write_buf = buf;
    b->last_write_n = n;
    b->last_write_st = st;
 
    if (st) *st = b->write_st_to_set;
    return b->write_ret;
}
 
static stream_status_t fake_stream_flush(void *backend)
{
    fake_stream_backend_t *b = (fake_stream_backend_t *)backend;
    assert_non_null(b);
 
    b->flush_called++;
 
    b->last_backend = backend;
 
    return b->flush_ret;
}
 
static stream_status_t fake_stream_close(void *backend)
{
    if (!backend) return STREAM_STATUS_NO_BACKEND;
    fake_stream_backend_t *b = (fake_stream_backend_t *)backend;
 
    b->close_called++;
 
    b->last_backend = backend;
 
    return b->close_ret;
}
 
static const stream_vtbl_t fake_stream_vtbl = {
    .read = fake_stream_read,
    .write = fake_stream_write,
    .flush = fake_stream_flush,
    .close = fake_stream_close
};
 
static void test_stream_default_ops(void **state) {
    (void)state;
    const stream_ops_t *ret = stream_default_ops();
    assert_non_null(ret);
    assert_non_null(ret->read);
    assert_non_null(ret->write);
    assert_non_null(ret->flush);
}
 
static void test_stream_default_env(void **state) {
    (void)state;
 
    const osal_mem_ops_t dummy = {0};
    const osal_mem_ops_t *dummy_p = &dummy;
 
    stream_env_t ret = stream_default_env(dummy_p);
 
    assert_ptr_equal(ret.mem, dummy_p);
}
 
typedef enum {
    STREAM_LIFECYCLE_SCENARIO_OK = 0,
 
    STREAM_LIFECYCLE_SCENARIO_OUT_NULL,
 
    STREAM_LIFECYCLE_SCENARIO_VTBL_NULL,
 
    STREAM_LIFECYCLE_SCENARIO_ENV_NULL,
 
    STREAM_LIFECYCLE_SCENARIO_ENV_MEM_NULL,
 
    STREAM_LIFECYCLE_SCENARIO_OOM,
 
    STREAM_LIFECYCLE_SCENARIO_DESTROY_IDEMPOTENT,
 
    STREAM_LIFECYCLE_SCENARIO_VTBL_READ_NULL,
} stream_lifecycle_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;
 
    stream_lifecycle_scenario_t scenario;
    size_t fail_call_idx;
 
    stream_status_t expected_ret;
    out_expect_t out_expect;
} test_stream_lifecycle_case_t;
 
typedef struct {
    // runtime resources
    stream_t *out;
 
    // injection
    stream_env_t env;
 
    fake_stream_backend_t backend;
 
    const test_stream_lifecycle_case_t *tc;
} test_stream_lifecycle_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_stream_lifecycle(void **state)
{
    const test_stream_lifecycle_case_t *tc =
        (const test_stream_lifecycle_case_t *)(*state);
 
    test_stream_lifecycle_fixture_t *fx =
        (test_stream_lifecycle_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_OOM && tc->fail_call_idx > 0) {
        fake_memory_fail_only_on_call(tc->fail_call_idx);
    }
 
    // DI
    fx->env.mem = osal_mem_test_fake_ops();
 
    osal_memset(&fx->backend, 0, sizeof(fx->backend));
    fx->backend.close_ret = STREAM_STATUS_OK;
 
    *state = fx;
    return 0;
}
 
static int teardown_stream_lifecycle(void **state)
{
    test_stream_lifecycle_fixture_t *fx =
        (test_stream_lifecycle_fixture_t *)(*state);
 
    if (fx->out) {
        stream_destroy(&fx->out);
    }
 
    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_stream_lifecycle(void **state)
{
    test_stream_lifecycle_fixture_t *fx =
        (test_stream_lifecycle_fixture_t *)(*state);
    const test_stream_lifecycle_case_t *tc = fx->tc;
 
    // ARRANGE
    stream_status_t ret = STREAM_STATUS_INVALID;
 
    stream_t **out_arg = &fx->out;
    const stream_vtbl_t *vtbl_arg = &fake_stream_vtbl;
    stream_vtbl_t vtbl_local;
    void *backend_arg = &fx->backend;
    const stream_env_t *env_arg = &fx->env;
 
    // invalid args
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_OUT_NULL) out_arg = NULL;
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_VTBL_NULL) vtbl_arg = NULL;
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_ENV_NULL) env_arg = NULL;
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_ENV_MEM_NULL) fx->env.mem = NULL;
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_VTBL_READ_NULL) {
        vtbl_local = fake_stream_vtbl;
        vtbl_local.read = NULL;
        vtbl_arg = &vtbl_local;
    }
 
    // ensure OUT_EXPECT_UNCHANGED is meaningful
    if (tc->out_expect == OUT_EXPECT_UNCHANGED && out_arg != NULL) {
        fx->out = (stream_t *)(uintptr_t)0xDEADC0DEu; // sentinel
    }
 
    stream_t *out_arg_snapshot = fx->out;
 
    // ACT
    ret = stream_create(out_arg, vtbl_arg, backend_arg, env_arg);
    if (tc->scenario == STREAM_LIFECYCLE_SCENARIO_DESTROY_IDEMPOTENT) {
        assert_int_equal(ret, STREAM_STATUS_OK);
        assert_non_null(fx->out);
 
        stream_destroy(&fx->out);
        assert_null(fx->out);
 
        stream_destroy(&fx->out);
        assert_null(fx->out);
    }
 
    // 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: fail();
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_OUT_NULL = {
    .name = "stream_lifecycle_out_null",
    .scenario = STREAM_LIFECYCLE_SCENARIO_OUT_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_CHECK_NONE
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_VTBL_NULL = {
    .name = "stream_lifecycle_vtbl_null",
    .scenario = STREAM_LIFECYCLE_SCENARIO_VTBL_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_ENV_NULL = {
    .name = "stream_lifecycle_env_null",
    .scenario = STREAM_LIFECYCLE_SCENARIO_ENV_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_ENV_MEM_NULL = {
    .name = "stream_lifecycle_env_mem_null",
    .scenario = STREAM_LIFECYCLE_SCENARIO_ENV_MEM_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_OOM = {
    .name = "stream_lifecycle_oom",
    .scenario = STREAM_LIFECYCLE_SCENARIO_OOM,
    .fail_call_idx = 1,
 
    .expected_ret = STREAM_STATUS_OOM,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_DESTROY_IDEMPOTENT = {
    .name = "stream_lifecycle_destroy_idempotent",
    .scenario = STREAM_LIFECYCLE_SCENARIO_DESTROY_IDEMPOTENT,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_OK,
    .out_expect = OUT_EXPECT_NULL
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_OK = {
    .name = "stream_lifecycle_ok",
    .scenario = STREAM_LIFECYCLE_SCENARIO_OK,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_OK,
    .out_expect = OUT_EXPECT_NON_NULL
};
 
static const test_stream_lifecycle_case_t CASE_STREAM_LIFECYCLE_VTBL_READ_NULL = {
    .name = "stream_lifecycle_vtbl_read_null",
    .scenario = STREAM_LIFECYCLE_SCENARIO_VTBL_READ_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define STREAM_LIFECYCLE_CASES(X) \
X(CASE_STREAM_LIFECYCLE_OUT_NULL) \
X(CASE_STREAM_LIFECYCLE_VTBL_NULL) \
X(CASE_STREAM_LIFECYCLE_ENV_NULL) \
X(CASE_STREAM_LIFECYCLE_ENV_MEM_NULL) \
X(CASE_STREAM_LIFECYCLE_OOM) \
X(CASE_STREAM_LIFECYCLE_DESTROY_IDEMPOTENT) \
X(CASE_STREAM_LIFECYCLE_OK) \
X(CASE_STREAM_LIFECYCLE_VTBL_READ_NULL)
 
#define STREAM_MAKE_LIFECYCLE_TEST(case_sym) \
LEXLEO_MAKE_TEST(stream_lifecycle, case_sym)
 
static const struct CMUnitTest stream_lifecycle_tests[] = {
    STREAM_LIFECYCLE_CASES(STREAM_MAKE_LIFECYCLE_TEST)
};
 
#undef STREAM_LIFECYCLE_CASES
#undef STREAM_MAKE_LIFECYCLE_TEST
 
typedef enum {
    STREAM_READ_SCENARIO_N_ZERO = 0,
 
    STREAM_READ_SCENARIO_N_ZERO_ST_NULL,
 
    STREAM_READ_SCENARIO_S_NULL,
 
    STREAM_READ_SCENARIO_S_NULL_ST_NULL,
 
    STREAM_READ_SCENARIO_BUF_NULL,
 
    STREAM_READ_SCENARIO_BUF_NULL_ST_NULL,
 
    STREAM_READ_SCENARIO_BACKEND_NULL,
 
    STREAM_READ_SCENARIO_BACKEND_NULL_ST_NULL,
 
    STREAM_READ_SCENARIO_NOMINAL_OK,
 
    STREAM_READ_SCENARIO_NOMINAL_EOF,
 
    STREAM_READ_SCENARIO_NOMINAL_ST_NULL
} stream_read_scenario_t;
 
typedef struct {
    const char *name;
    stream_read_scenario_t scenario;
} test_stream_read_case_t;
 
typedef struct {
    stream_t *stream;
    stream_t *stream_no_backend;
    stream_env_t stream_env;
    fake_stream_backend_t fake_backend;
    uint8_t buf[32];
    stream_status_t st;
    const test_stream_read_case_t *tc;
} test_stream_read_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_stream_read(void **state) {
    const test_stream_read_case_t *tc = (const test_stream_read_case_t *) *state;
    test_stream_read_fixture_t *fx = (test_stream_read_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
 
    fx->stream_env.mem = osal_mem_test_fake_ops();
 
    fx->fake_backend.close_ret = STREAM_STATUS_OK;
 
    assert_int_equal(
        stream_create(&fx->stream, &fake_stream_vtbl, &fx->fake_backend, &fx->stream_env),
        STREAM_STATUS_OK
    );
 
    assert_int_equal(
        stream_create(&fx->stream_no_backend, &fake_stream_vtbl, NULL, &fx->stream_env),
        STREAM_STATUS_OK
    );
 
    *state = fx;
    return 0;
}
 
static int teardown_stream_read(void **state) {
    test_stream_read_fixture_t *fx = (test_stream_read_fixture_t *)*state;
    if (!fx) return 0;
 
    stream_destroy(&fx->stream);
    stream_destroy(&fx->stream_no_backend);
 
    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_stream_read(void **state) {
    test_stream_read_fixture_t *fx = (test_stream_read_fixture_t *)*state;
 
    // ARRANGE
    size_t ret = (size_t)-1;
    stream_t *s_arg = fx->stream;
    void *buf_arg = fx->buf;
    size_t n_arg = 5;
    stream_status_t *st_arg = &fx->st;
 
    // poison status so tests are meaningful
    *st_arg = (stream_status_t)-1;
 
    fake_stream_backend_reset(&fx->fake_backend);
 
    switch (fx->tc->scenario) {
    case STREAM_READ_SCENARIO_N_ZERO: n_arg = 0; break;
    case STREAM_READ_SCENARIO_N_ZERO_ST_NULL: n_arg = 0; st_arg = NULL; break;
    case STREAM_READ_SCENARIO_S_NULL: s_arg = NULL; break;
    case STREAM_READ_SCENARIO_S_NULL_ST_NULL: s_arg = NULL; st_arg = NULL; break;
    case STREAM_READ_SCENARIO_BUF_NULL: buf_arg = NULL; break;
    case STREAM_READ_SCENARIO_BUF_NULL_ST_NULL: buf_arg = NULL; st_arg = NULL; break;
    case STREAM_READ_SCENARIO_BACKEND_NULL: s_arg = fx->stream_no_backend; break;
    case STREAM_READ_SCENARIO_BACKEND_NULL_ST_NULL: s_arg = fx->stream_no_backend; st_arg = NULL; break;
    case STREAM_READ_SCENARIO_NOMINAL_OK:
        fx->fake_backend.read_ret = n_arg;
        fx->fake_backend.read_st_to_set = STREAM_STATUS_OK;
        break;
    case STREAM_READ_SCENARIO_NOMINAL_EOF:
        fx->fake_backend.read_ret = 0;
        fx->fake_backend.read_st_to_set = STREAM_STATUS_EOF;
        break;
    case STREAM_READ_SCENARIO_NOMINAL_ST_NULL:
        fx->fake_backend.read_ret = 5;
        st_arg = NULL;
        break;
    default: fail();
    }
 
    // ACT
    ret = stream_read(s_arg, buf_arg, n_arg, st_arg);
 
    // ASSERT
    switch (fx->tc->scenario) {
    case STREAM_READ_SCENARIO_N_ZERO:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_OK);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_N_ZERO_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_S_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_INVALID);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_S_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_BUF_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_INVALID);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_BUF_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_BACKEND_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_NO_BACKEND);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_BACKEND_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.read_called, 0);
        break;
    case STREAM_READ_SCENARIO_NOMINAL_OK:
        assert_int_equal((int)ret, (int)fx->fake_backend.read_ret);
        assert_int_equal(*st_arg, STREAM_STATUS_OK);
        assert_int_equal(fx->fake_backend.read_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_read_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_read_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_read_st, st_arg);
        break;
    case STREAM_READ_SCENARIO_NOMINAL_EOF:
        assert_int_equal((int)ret, (int)fx->fake_backend.read_ret);
        assert_int_equal(*st_arg, STREAM_STATUS_EOF);
        assert_int_equal(fx->fake_backend.read_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_read_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_read_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_read_st, st_arg);
        break;
    case STREAM_READ_SCENARIO_NOMINAL_ST_NULL:
        assert_int_equal((int)ret, (int)fx->fake_backend.read_ret);
        assert_int_equal(fx->fake_backend.read_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_read_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_read_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_read_st, NULL);
        break;
    default: fail();
    }
 
    assert_int_equal(fx->fake_backend.write_called, 0);
    assert_int_equal(fx->fake_backend.flush_called, 0);
    assert_int_equal(fx->fake_backend.close_called, 0);
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_stream_read_case_t CASE_STREAM_READ_N_ZERO = {
    .name = "stream_read_n_zero",
    .scenario = STREAM_READ_SCENARIO_N_ZERO,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_N_ZERO_ST_NULL = {
    .name = "stream_read_n_zero_st_null",
    .scenario = STREAM_READ_SCENARIO_N_ZERO_ST_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_S_NULL = {
    .name = "stream_read_s_null",
    .scenario = STREAM_READ_SCENARIO_S_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_S_NULL_ST_NULL = {
    .name = "stream_read_s_null_st_null",
    .scenario = STREAM_READ_SCENARIO_S_NULL_ST_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_BUF_NULL = {
    .name = "stream_read_buf_null",
    .scenario = STREAM_READ_SCENARIO_BUF_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_BUF_NULL_ST_NULL = {
    .name = "stream_read_buf_null_st_null",
    .scenario = STREAM_READ_SCENARIO_BUF_NULL_ST_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_BACKEND_NULL = {
    .name = "stream_read_backend_null",
    .scenario = STREAM_READ_SCENARIO_BACKEND_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_BACKEND_NULL_ST_NULL = {
    .name = "stream_read_backend_null_st_null",
    .scenario = STREAM_READ_SCENARIO_BACKEND_NULL_ST_NULL,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_NOMINAL_OK = {
    .name = "stream_read_nominal_ok",
    .scenario = STREAM_READ_SCENARIO_NOMINAL_OK,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_NOMINAL_EOF = {
    .name = "stream_read_nominal_eof",
    .scenario = STREAM_READ_SCENARIO_NOMINAL_EOF,
};
 
static const test_stream_read_case_t CASE_STREAM_READ_NOMINAL_ST_NULL = {
    .name = "stream_read_nominal_st_null",
    .scenario = STREAM_READ_SCENARIO_NOMINAL_ST_NULL,
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define STREAM_READ_CASES(X) \
X(CASE_STREAM_READ_N_ZERO) \
X(CASE_STREAM_READ_N_ZERO_ST_NULL) \
X(CASE_STREAM_READ_S_NULL) \
X(CASE_STREAM_READ_S_NULL_ST_NULL) \
X(CASE_STREAM_READ_BUF_NULL) \
X(CASE_STREAM_READ_BUF_NULL_ST_NULL) \
X(CASE_STREAM_READ_BACKEND_NULL) \
X(CASE_STREAM_READ_BACKEND_NULL_ST_NULL) \
X(CASE_STREAM_READ_NOMINAL_OK) \
X(CASE_STREAM_READ_NOMINAL_EOF) \
X(CASE_STREAM_READ_NOMINAL_ST_NULL)
 
#define STREAM_MAKE_STREAM_READ_TEST(case_sym) \
LEXLEO_MAKE_TEST(stream_read, case_sym)
 
static const struct CMUnitTest stream_read_tests[] = {
    STREAM_READ_CASES(STREAM_MAKE_STREAM_READ_TEST)
};
 
#undef STREAM_READ_CASES
#undef STREAM_MAKE_STREAM_READ_TEST
 
typedef enum {
    STREAM_WRITE_SCENARIO_N_ZERO = 0,
 
    STREAM_WRITE_SCENARIO_N_ZERO_ST_NULL,
 
    STREAM_WRITE_SCENARIO_S_NULL,
 
    STREAM_WRITE_SCENARIO_S_NULL_ST_NULL,
 
    STREAM_WRITE_SCENARIO_BUF_NULL,
 
    STREAM_WRITE_SCENARIO_BUF_NULL_ST_NULL,
 
    STREAM_WRITE_SCENARIO_BACKEND_NULL,
 
    STREAM_WRITE_SCENARIO_BACKEND_NULL_ST_NULL,
 
    STREAM_WRITE_SCENARIO_NOMINAL_OK,
 
    STREAM_WRITE_SCENARIO_NOMINAL_IO_ERROR,
 
    STREAM_WRITE_SCENARIO_NOMINAL_ST_NULL
} stream_write_scenario_t;
 
typedef struct {
    const char *name;
    stream_write_scenario_t scenario;
} test_stream_write_case_t;
 
typedef struct {
    stream_t *stream;
    stream_t *stream_no_backend;
    stream_env_t stream_env;
    fake_stream_backend_t fake_backend;
    uint8_t buf[32];
    stream_status_t st;
    const test_stream_write_case_t *tc;
} test_stream_write_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_stream_write(void **state) {
    const test_stream_write_case_t *tc = (const test_stream_write_case_t *) *state;
    test_stream_write_fixture_t *fx = (test_stream_write_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
 
    fx->stream_env.mem = osal_mem_test_fake_ops();
 
    fx->fake_backend.close_ret = STREAM_STATUS_OK;
 
    assert_int_equal(
        stream_create(&fx->stream, &fake_stream_vtbl, &fx->fake_backend, &fx->stream_env),
        STREAM_STATUS_OK
    );
 
    assert_int_equal(
        stream_create(&fx->stream_no_backend, &fake_stream_vtbl, NULL, &fx->stream_env),
        STREAM_STATUS_OK
    );
 
    *state = fx;
    return 0;
}
 
static int teardown_stream_write(void **state) {
    test_stream_write_fixture_t *fx = (test_stream_write_fixture_t *)*state;
    if (!fx) return 0;
 
    stream_destroy(&fx->stream);
    stream_destroy(&fx->stream_no_backend);
 
    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_stream_write(void **state) {
    test_stream_write_fixture_t *fx = (test_stream_write_fixture_t *)*state;
 
    // ARRANGE
    size_t ret = (size_t)-1;
    stream_t *s_arg = fx->stream;
    const void *buf_arg = fx->buf;
    size_t n_arg = 5;
    stream_status_t *st_arg = &fx->st;
 
    // poison status so tests are meaningful
    *st_arg = (stream_status_t)-1;
 
    fake_stream_backend_reset(&fx->fake_backend);
 
    switch (fx->tc->scenario) {
    case STREAM_WRITE_SCENARIO_N_ZERO: n_arg = 0; break;
    case STREAM_WRITE_SCENARIO_N_ZERO_ST_NULL: n_arg = 0; st_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_S_NULL: s_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_S_NULL_ST_NULL: s_arg = NULL; st_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_BUF_NULL: buf_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_BUF_NULL_ST_NULL: buf_arg = NULL; st_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_BACKEND_NULL: s_arg = fx->stream_no_backend; break;
    case STREAM_WRITE_SCENARIO_BACKEND_NULL_ST_NULL: s_arg = fx->stream_no_backend; st_arg = NULL; break;
    case STREAM_WRITE_SCENARIO_NOMINAL_OK:
        fx->fake_backend.write_ret = n_arg;
        fx->fake_backend.write_st_to_set = STREAM_STATUS_OK;
        break;
    case STREAM_WRITE_SCENARIO_NOMINAL_IO_ERROR:
        fx->fake_backend.write_ret = 0;
        fx->fake_backend.write_st_to_set = STREAM_STATUS_IO_ERROR;
        break;
    case STREAM_WRITE_SCENARIO_NOMINAL_ST_NULL:
        fx->fake_backend.write_ret = 5;
        st_arg = NULL;
        break;
    default: fail();
    }
 
    // ACT
    ret = stream_write(s_arg, buf_arg, n_arg, st_arg);
 
    // ASSERT
    switch (fx->tc->scenario) {
    case STREAM_WRITE_SCENARIO_N_ZERO:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_OK);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_N_ZERO_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_S_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_INVALID);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_S_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_BUF_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_INVALID);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_BUF_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_BACKEND_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(*st_arg, STREAM_STATUS_NO_BACKEND);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_BACKEND_NULL_ST_NULL:
        assert_int_equal((int)ret, 0);
        assert_int_equal(fx->fake_backend.write_called, 0);
        break;
    case STREAM_WRITE_SCENARIO_NOMINAL_OK:
        assert_int_equal((int)ret, (int)fx->fake_backend.write_ret);
        assert_int_equal(*st_arg, STREAM_STATUS_OK);
        assert_int_equal(fx->fake_backend.write_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_write_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_write_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_write_st, st_arg);
        break;
    case STREAM_WRITE_SCENARIO_NOMINAL_IO_ERROR:
        assert_int_equal((int)ret, (int)fx->fake_backend.write_ret);
        assert_int_equal(*st_arg, STREAM_STATUS_IO_ERROR);
        assert_int_equal(fx->fake_backend.write_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_write_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_write_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_write_st, st_arg);
        break;
    case STREAM_WRITE_SCENARIO_NOMINAL_ST_NULL:
        assert_int_equal((int)ret, (int)fx->fake_backend.write_ret);
        assert_int_equal(fx->fake_backend.write_called, 1);
        assert_ptr_equal(fx->fake_backend.last_backend, &fx->fake_backend);
        assert_ptr_equal(fx->fake_backend.last_write_buf, buf_arg);
        assert_int_equal((int)fx->fake_backend.last_write_n, (int)n_arg);
        assert_ptr_equal(fx->fake_backend.last_write_st, NULL);
        break;
    default: fail();
    }
 
    assert_int_equal(fx->fake_backend.read_called, 0);
    assert_int_equal(fx->fake_backend.flush_called, 0);
    assert_int_equal(fx->fake_backend.close_called, 0);
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_stream_write_case_t CASE_STREAM_WRITE_N_ZERO = {
    .name = "stream_write_n_zero",
    .scenario = STREAM_WRITE_SCENARIO_N_ZERO,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_N_ZERO_ST_NULL = {
    .name = "stream_write_n_zero_st_null",
    .scenario = STREAM_WRITE_SCENARIO_N_ZERO_ST_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_S_NULL = {
    .name = "stream_write_s_null",
    .scenario = STREAM_WRITE_SCENARIO_S_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_S_NULL_ST_NULL = {
    .name = "stream_write_s_null_st_null",
    .scenario = STREAM_WRITE_SCENARIO_S_NULL_ST_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_BUF_NULL = {
    .name = "stream_write_buf_null",
    .scenario = STREAM_WRITE_SCENARIO_BUF_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_BUF_NULL_ST_NULL = {
    .name = "stream_write_buf_null_st_null",
    .scenario = STREAM_WRITE_SCENARIO_BUF_NULL_ST_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_BACKEND_NULL = {
    .name = "stream_write_backend_null",
    .scenario = STREAM_WRITE_SCENARIO_BACKEND_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_BACKEND_NULL_ST_NULL = {
    .name = "stream_write_backend_null_st_null",
    .scenario = STREAM_WRITE_SCENARIO_BACKEND_NULL_ST_NULL,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_NOMINAL_OK = {
    .name = "stream_write_nominal_ok",
    .scenario = STREAM_WRITE_SCENARIO_NOMINAL_OK,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_NOMINAL_IO_ERROR = {
    .name = "stream_write_nominal_io_error",
    .scenario = STREAM_WRITE_SCENARIO_NOMINAL_IO_ERROR,
};
 
static const test_stream_write_case_t CASE_STREAM_WRITE_NOMINAL_ST_NULL = {
    .name = "stream_write_nominal_st_null",
    .scenario = STREAM_WRITE_SCENARIO_NOMINAL_ST_NULL,
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define STREAM_WRITE_CASES(X) \
X(CASE_STREAM_WRITE_N_ZERO) \
X(CASE_STREAM_WRITE_N_ZERO_ST_NULL) \
X(CASE_STREAM_WRITE_S_NULL) \
X(CASE_STREAM_WRITE_S_NULL_ST_NULL) \
X(CASE_STREAM_WRITE_BUF_NULL) \
X(CASE_STREAM_WRITE_BUF_NULL_ST_NULL) \
X(CASE_STREAM_WRITE_BACKEND_NULL) \
X(CASE_STREAM_WRITE_BACKEND_NULL_ST_NULL) \
X(CASE_STREAM_WRITE_NOMINAL_OK) \
X(CASE_STREAM_WRITE_NOMINAL_IO_ERROR) \
X(CASE_STREAM_WRITE_NOMINAL_ST_NULL)
 
#define STREAM_MAKE_STREAM_WRITE_TEST(case_sym) \
LEXLEO_MAKE_TEST(stream_write, case_sym)
 
static const struct CMUnitTest stream_write_tests[] = {
    STREAM_WRITE_CASES(STREAM_MAKE_STREAM_WRITE_TEST)
};
 
#undef STREAM_WRITE_CASES
#undef STREAM_MAKE_STREAM_WRITE_TEST
 
typedef enum {
    STREAM_FLUSH_SCENARIO_S_NULL = 0,
 
    STREAM_FLUSH_SCENARIO_BACKEND_NULL,
 
    STREAM_FLUSH_SCENARIO_NOMINAL_OK,
 
    STREAM_FLUSH_SCENARIO_NOMINAL_IO_ERROR
} stream_flush_scenario_t;
 
typedef struct {
    const char *name;
    stream_flush_scenario_t scenario;
} test_stream_flush_case_t;
 
typedef struct {
    stream_t *stream;
    stream_t *stream_no_backend;
    stream_env_t env;
    fake_stream_backend_t backend;
    const test_stream_flush_case_t *tc;
} test_stream_flush_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_stream_flush(void **state)
{
    const test_stream_flush_case_t *tc = (const test_stream_flush_case_t *)(*state);
 
    test_stream_flush_fixture_t *fx = (test_stream_flush_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
 
    fx->env.mem = osal_mem_test_fake_ops();
 
    fake_stream_backend_reset(&fx->backend);
    fx->backend.close_ret = STREAM_STATUS_OK;
 
    assert_int_equal(
        stream_create(&fx->stream, &fake_stream_vtbl, &fx->backend, &fx->env),
        STREAM_STATUS_OK
    );
 
    assert_int_equal(
        stream_create(&fx->stream_no_backend, &fake_stream_vtbl, NULL, &fx->env),
        STREAM_STATUS_OK
    );
 
    *state = fx;
    return 0;
}
 
static int teardown_stream_flush(void **state)
{
    test_stream_flush_fixture_t *fx = (test_stream_flush_fixture_t *)(*state);
    if (!fx) return 0;
 
    stream_destroy(&fx->stream);
    stream_destroy(&fx->stream_no_backend);
 
    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_stream_flush(void **state)
{
    test_stream_flush_fixture_t *fx = (test_stream_flush_fixture_t *)*state;
 
    stream_t *s_arg = fx->stream;
 
    fake_stream_backend_reset(&fx->backend);
 
    switch (fx->tc->scenario) {
        case STREAM_FLUSH_SCENARIO_S_NULL:
            s_arg = NULL;
            break;
        case STREAM_FLUSH_SCENARIO_BACKEND_NULL:
            s_arg = fx->stream_no_backend;
            break;
        case STREAM_FLUSH_SCENARIO_NOMINAL_OK:
            fx->backend.flush_ret = STREAM_STATUS_OK;
            break;
        case STREAM_FLUSH_SCENARIO_NOMINAL_IO_ERROR:
            fx->backend.flush_ret = STREAM_STATUS_IO_ERROR;
            break;
        default:
            fail();
    }
 
    stream_status_t ret = stream_flush(s_arg);
 
    switch (fx->tc->scenario) {
        case STREAM_FLUSH_SCENARIO_S_NULL:
            assert_int_equal(ret, STREAM_STATUS_INVALID);
            assert_int_equal(fx->backend.flush_called, 0);
            break;
        case STREAM_FLUSH_SCENARIO_BACKEND_NULL:
            assert_int_equal(ret, STREAM_STATUS_NO_BACKEND);
            assert_int_equal(fx->backend.flush_called, 0);
            break;
        case STREAM_FLUSH_SCENARIO_NOMINAL_OK:
            assert_int_equal(ret, STREAM_STATUS_OK);
            assert_int_equal(fx->backend.flush_called, 1);
            assert_ptr_equal(fx->backend.last_backend, &fx->backend);
            break;
        case STREAM_FLUSH_SCENARIO_NOMINAL_IO_ERROR:
            assert_int_equal(ret, STREAM_STATUS_IO_ERROR);
            assert_int_equal(fx->backend.flush_called, 1);
            assert_ptr_equal(fx->backend.last_backend, &fx->backend);
            break;
        default:
            fail();
    }
 
    assert_int_equal(fx->backend.read_called, 0);
    assert_int_equal(fx->backend.write_called, 0);
    assert_int_equal(fx->backend.close_called, 0);
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_stream_flush_case_t CASE_STREAM_FLUSH_S_NULL = {
    .name = "stream_flush_s_null",
    .scenario = STREAM_FLUSH_SCENARIO_S_NULL,
};
 
static const test_stream_flush_case_t CASE_STREAM_FLUSH_BACKEND_NULL = {
    .name = "stream_flush_backend_null",
    .scenario = STREAM_FLUSH_SCENARIO_BACKEND_NULL,
};
 
static const test_stream_flush_case_t CASE_STREAM_FLUSH_NOMINAL_OK = {
    .name = "stream_flush_nominal_ok",
    .scenario = STREAM_FLUSH_SCENARIO_NOMINAL_OK,
};
 
static const test_stream_flush_case_t CASE_STREAM_FLUSH_NOMINAL_IO_ERROR = {
    .name = "stream_flush_nominal_io_error",
    .scenario = STREAM_FLUSH_SCENARIO_NOMINAL_IO_ERROR,
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define STREAM_FLUSH_CASES(X) \
X(CASE_STREAM_FLUSH_S_NULL) \
X(CASE_STREAM_FLUSH_BACKEND_NULL) \
X(CASE_STREAM_FLUSH_NOMINAL_OK) \
X(CASE_STREAM_FLUSH_NOMINAL_IO_ERROR)
 
#define STREAM_MAKE_STREAM_FLUSH_TEST(case_sym) \
LEXLEO_MAKE_TEST(stream_flush, case_sym)
 
static const struct CMUnitTest stream_flush_tests[] = {
    STREAM_FLUSH_CASES(STREAM_MAKE_STREAM_FLUSH_TEST)
};
 
#undef STREAM_FLUSH_CASES
#undef STREAM_MAKE_STREAM_FLUSH_TEST
 
//-----------------------------------------------------------------------------
// MAIN
//-----------------------------------------------------------------------------
 
int main(void) {
    static const struct CMUnitTest stream_tests[] = {
        cmocka_unit_test(test_stream_default_ops),
        cmocka_unit_test(test_stream_default_env)
    };
 
    int failed = 0;
    failed += cmocka_run_group_tests(stream_tests, NULL, NULL);
    failed += cmocka_run_group_tests(stream_lifecycle_tests, NULL, NULL);
    failed += cmocka_run_group_tests(stream_read_tests, NULL, NULL);
    failed += cmocka_run_group_tests(stream_write_tests, NULL, NULL);
    failed += cmocka_run_group_tests(stream_flush_tests, NULL, NULL);
    return failed;
}