unit_test_dynamic_buffer_stream.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Sylvain Labopin
 */
 
#include "dynamic_buffer_stream/cr/dynamic_buffer_stream_cr_api.h"
 
#include "stream/borrowers/stream.h"
#include "stream/lifecycle/stream_lifecycle.h"
 
#include "osal/mem/osal_mem.h"
#include "osal/mem/test/osal_mem_fake_provider.h"
 
// for white-box tests
#include "internal/dynamic_buffer_stream_handle.h"
#include "internal/stream_handle.h"
 
#include "policy/lexleo_cstd_types.h"
#include "policy/lexleo_cstd_lib.h"
#include "policy/lexleo_cstd_jmp.h"
 
#include "lexleo_cmocka.h"
 
static void test_dynamic_buffer_stream_default_cfg(void **state)
{
    (void)state;
 
    dynamic_buffer_stream_cfg_t ret = dynamic_buffer_stream_default_cfg();
 
    assert_true(ret.default_cap > 0);
}
 
static void test_dynamic_buffer_stream_default_env(void **state)
{
    (void)state;
 
    const osal_mem_ops_t *dummy_mem_p =
        (const osal_mem_ops_t *)(uintptr_t)0x1234u;
 
    const stream_env_t dummy_port_env = {0};
    const stream_env_t *dummy_port_env_p = &dummy_port_env;
 
    dynamic_buffer_stream_env_t ret =
        dynamic_buffer_stream_default_env(dummy_mem_p, dummy_port_env_p);
 
    assert_ptr_equal(ret.mem, dummy_mem_p);
    assert_memory_equal(&ret.port_env, dummy_port_env_p, sizeof(ret.port_env));
}
 
typedef enum {
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OK = 0,
 
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OUT_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_CFG_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_ENV_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OOM,
} dynamic_buffer_stream_create_stream_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
    dynamic_buffer_stream_create_stream_scenario_t scenario;
    size_t fail_call_idx; // 0 = no OOM, otherwise 1-based
 
    // assert
    stream_status_t expected_ret;
    out_expect_t out_expect;
} test_dynamic_buffer_stream_create_stream_case_t;
 
typedef struct {
    // runtime resources
    stream_t *out;
 
    // injection
    dynamic_buffer_stream_env_t env;
 
    dynamic_buffer_stream_cfg_t cfg;
 
    const test_dynamic_buffer_stream_create_stream_case_t *tc;
} test_dynamic_buffer_stream_create_stream_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_dynamic_buffer_stream_create_stream(void **state)
{
    const test_dynamic_buffer_stream_create_stream_case_t *tc =
        (const test_dynamic_buffer_stream_create_stream_case_t *)(*state);
 
    test_dynamic_buffer_stream_create_stream_fixture_t *fx =
        (test_dynamic_buffer_stream_create_stream_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_STREAM_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();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
 
    fx->cfg.default_cap = 16;
 
    *state = fx;
    return 0;
}
 
static int teardown_dynamic_buffer_stream_create_stream(void **state)
{
    test_dynamic_buffer_stream_create_stream_fixture_t *fx =
        (test_dynamic_buffer_stream_create_stream_fixture_t *)(*state);
 
    if (fx->out) {
        stream_destroy(&fx->out);
        fx->out = NULL;
    }
 
    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_dynamic_buffer_stream_create_stream(void **state)
{
    test_dynamic_buffer_stream_create_stream_fixture_t *fx =
        (test_dynamic_buffer_stream_create_stream_fixture_t *)(*state);
    const test_dynamic_buffer_stream_create_stream_case_t *tc = fx->tc;
 
    // ARRANGE
    stream_status_t st = STREAM_STATUS_INVALID;
    stream_status_t ret = STREAM_STATUS_INVALID;
 
    stream_t **out_arg = &fx->out;
    const dynamic_buffer_stream_cfg_t *cfg_arg = &fx->cfg;
    const dynamic_buffer_stream_env_t *env_arg = &fx->env;
 
    // invalid args
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OUT_NULL) out_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_CFG_NULL) cfg_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_ENV_NULL) env_arg = NULL;
 
    // 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 = dynamic_buffer_stream_create_stream(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 == DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OK) {
        assert_non_null(fx->out);
 
        const char msg[] = "hello";
        size_t w = stream_write(fx->out, msg, sizeof(msg) - 1, &st);
        assert_int_equal((int)w, (int)(sizeof(msg) - 1));
        assert_true(st == STREAM_STATUS_OK);
 
        assert_int_equal(stream_flush(fx->out), STREAM_STATUS_OK);
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_dynamic_buffer_stream_create_stream_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OK = {
    .name = "dynamic_buffer_stream_create_stream_ok",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OK,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_OK,
    .out_expect = OUT_EXPECT_NON_NULL
};
 
static const test_dynamic_buffer_stream_create_stream_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OUT_NULL = {
    .name = "dynamic_buffer_stream_create_stream_out_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OUT_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_CHECK_NONE
};
 
static const test_dynamic_buffer_stream_create_stream_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_CFG_NULL = {
    .name = "dynamic_buffer_stream_create_stream_cfg_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_CFG_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_dynamic_buffer_stream_create_stream_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_ENV_NULL = {
    .name = "dynamic_buffer_stream_create_stream_env_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_ENV_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
static const test_dynamic_buffer_stream_create_stream_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OOM = {
    .name = "dynamic_buffer_stream_create_stream_oom",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_STREAM_SCENARIO_OOM,
    .fail_call_idx = 1,
 
    .expected_ret = STREAM_STATUS_OOM,
    .out_expect = OUT_EXPECT_UNCHANGED
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define DYNAMIC_BUFFER_STREAM_CREATE_STREAM_CASES(X) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OK) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OUT_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_CFG_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_ENV_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_STREAM_OOM)
 
#define DYNAMIC_BUFFER_STREAM_MAKE_CREATE_STREAM_TEST(case_sym) \
LEXLEO_MAKE_TEST(dynamic_buffer_stream_create_stream, case_sym)
 
static const struct CMUnitTest dynamic_buffer_stream_create_stream_tests[] = {
    DYNAMIC_BUFFER_STREAM_CREATE_STREAM_CASES(
        DYNAMIC_BUFFER_STREAM_MAKE_CREATE_STREAM_TEST)
};
 
#undef DYNAMIC_BUFFER_STREAM_CREATE_STREAM_CASES
#undef DYNAMIC_BUFFER_STREAM_MAKE_CREATE_STREAM_TEST
 
typedef enum {
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OK = 0,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OUT_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_EMPTY,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_CFG_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_ENV_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_MEM_NULL,
 
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OOM
} dynamic_buffer_stream_create_desc_scenario_t;
 
typedef enum {
    DESC_CHECK_NONE,
    DESC_EXPECT_EMPTY,
    DESC_EXPECT_VALID
} desc_expect_t;
 
typedef struct {
    const char *name;
 
    // arrange
    dynamic_buffer_stream_create_desc_scenario_t scenario;
    size_t fail_call_idx; // 0 = no OOM, otherwise 1-based
 
    // assert
    stream_status_t expected_ret;
    desc_expect_t desc_expect;
} test_dynamic_buffer_stream_create_desc_case_t;
 
typedef struct {
    // runtime resources
    stream_adapter_desc_t out;
 
    // injection
    dynamic_buffer_stream_env_t env;
    const osal_mem_ops_t *mem;
 
    stream_key_t key;
    dynamic_buffer_stream_cfg_t cfg;
 
    const test_dynamic_buffer_stream_create_desc_case_t *tc;
} test_dynamic_buffer_stream_create_desc_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_dynamic_buffer_stream_create_desc(void **state)
{
    const test_dynamic_buffer_stream_create_desc_case_t *tc =
        (const test_dynamic_buffer_stream_create_desc_case_t *)(*state);
 
    test_dynamic_buffer_stream_create_desc_fixture_t *fx =
        (test_dynamic_buffer_stream_create_desc_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_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();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
    fx->mem = osal_mem_test_fake_ops();
 
    fx->key = "dynamic_buffer";
 
    fx->cfg.default_cap = 16u;
 
    *state = fx;
    return 0;
}
 
static int teardown_dynamic_buffer_stream_create_desc(void **state)
{
    test_dynamic_buffer_stream_create_desc_fixture_t *fx =
        (test_dynamic_buffer_stream_create_desc_fixture_t *)(*state);
 
    if (fx->out.ud_dtor) fx->out.ud_dtor(fx->out.ud, fx->mem);
 
    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_dynamic_buffer_stream_create_desc(void **state)
{
    test_dynamic_buffer_stream_create_desc_fixture_t *fx =
        (test_dynamic_buffer_stream_create_desc_fixture_t *)(*state);
    const test_dynamic_buffer_stream_create_desc_case_t *tc = fx->tc;
 
    // ARRANGE
    stream_status_t ret = STREAM_STATUS_INVALID;
 
    stream_adapter_desc_t *out_arg = &fx->out;
    stream_key_t key_arg = fx->key;
    const dynamic_buffer_stream_cfg_t *cfg_arg = &fx->cfg;
    const dynamic_buffer_stream_env_t *env_arg = &fx->env;
    const osal_mem_ops_t *mem_arg = fx->mem;
 
    // invalid args
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OUT_NULL) out_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_NULL) key_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_EMPTY) key_arg = "";
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_CFG_NULL) cfg_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_ENV_NULL) env_arg = NULL;
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_MEM_NULL) mem_arg = NULL;
 
    if (tc->desc_expect == DESC_EXPECT_EMPTY && out_arg != NULL) {
        fx->out.key = (stream_key_t)(uintptr_t)0xDEADC0DEu;
        fx->out.ctor = (void *)(uintptr_t)0xDEADC0DEu;
        fx->out.ud = (void *)(uintptr_t)0xDEADC0DEu;
        fx->out.ud_dtor = (void *)(uintptr_t)0xDEADC0DEu;
    }
 
    // ACT
    ret = dynamic_buffer_stream_create_desc(out_arg, key_arg, cfg_arg, env_arg, mem_arg);
 
    // ASSERT
    assert_int_equal(ret, tc->expected_ret);
 
    if (tc->desc_expect == DESC_EXPECT_EMPTY) {
        assert_null(fx->out.key);
        assert_null(fx->out.ctor);
        assert_null(fx->out.ud);
        assert_null(fx->out.ud_dtor);
    }
    else if (tc->desc_expect == DESC_EXPECT_VALID) {
        assert_true(fx->out.key != (stream_key_t)(uintptr_t)0xDEADC0DEu);
        assert_non_null(fx->out.key);
        assert_true(*fx->out.key != '\0');
        assert_true(fx->out.ctor != (void *)(uintptr_t)0xDEADC0DEu);
        assert_non_null(fx->out.ctor);
        assert_true(fx->out.ud != (void *)(uintptr_t)0xDEADC0DEu);
        assert_non_null(fx->out.ud);
        assert_true(fx->out.ud_dtor != (void *)(uintptr_t)0xDEADC0DEu);
        assert_non_null(fx->out.ud_dtor);
    }
    else {
        assert_true(tc->desc_expect == DESC_CHECK_NONE);
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OK = {
    .name = "dynamic_buffer_stream_create_desc_ok",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OK,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_OK,
    .desc_expect = DESC_EXPECT_VALID
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OUT_NULL = {
    .name = "dynamic_buffer_stream_create_desc_out_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OUT_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_CHECK_NONE
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_KEY_NULL = {
    .name = "dynamic_buffer_stream_create_desc_key_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_KEY_EMPTY = {
    .name = "dynamic_buffer_stream_create_desc_key_empty",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_KEY_EMPTY,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_CFG_NULL = {
    .name = "dynamic_buffer_stream_create_desc_cfg_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_CFG_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_ENV_NULL = {
    .name = "dynamic_buffer_stream_create_desc_env_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_ENV_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_MEM_NULL = {
    .name = "dynamic_buffer_stream_create_desc_mem_null",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_MEM_NULL,
    .fail_call_idx = 0,
 
    .expected_ret = STREAM_STATUS_INVALID,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
static const test_dynamic_buffer_stream_create_desc_case_t
CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OOM_1 = {
    .name = "dynamic_buffer_stream_create_desc_oom_1",
    .scenario = DYNAMIC_BUFFER_STREAM_CREATE_DESC_SCENARIO_OOM,
    .fail_call_idx = 1,
 
    .expected_ret = STREAM_STATUS_OOM,
    .desc_expect = DESC_EXPECT_EMPTY
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define DYNAMIC_BUFFER_STREAM_CREATE_DESC_CASES(X) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OK) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OUT_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_KEY_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_KEY_EMPTY) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_CFG_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_ENV_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_MEM_NULL) \
X(CASE_DYNAMIC_BUFFER_STREAM_CREATE_DESC_OOM_1)
 
#define DYNAMIC_BUFFER_STREAM_MAKE_CREATE_DESC_TEST(case_sym) \
LEXLEO_MAKE_TEST(dynamic_buffer_stream_create_desc, case_sym)
 
static const struct CMUnitTest create_desc_dynamic_buffer_stream_tests[] = {
    DYNAMIC_BUFFER_STREAM_CREATE_DESC_CASES(
        DYNAMIC_BUFFER_STREAM_MAKE_CREATE_DESC_TEST)
};
 
#undef DYNAMIC_BUFFER_STREAM_CREATE_DESC_CASES
#undef DYNAMIC_BUFFER_STREAM_MAKE_CREATE_DESC_TEST
 
typedef enum {
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_OK_NO_GROW = 0,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_ZERO_LEN,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_ZERO_LEN,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_OK_GROW,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_NONZERO,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_RESERVE_OOM,
 
    DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_SIZE_OVERFLOW
} dynamic_buffer_stream_write_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    dynamic_buffer_stream_write_scenario_t scenario;
    size_t initial_cap;
    size_t prefill_len;
    size_t prefill_read_pos;
    size_t write_len;
    size_t fail_call_idx; // 0 = no injected OOM, otherwise 1-based
 
    // assert
    size_t expected_written;
    stream_status_t expected_st;
    bool expect_cap_growth;
    bool expect_backend_unchanged;
} test_dynamic_buffer_stream_write_case_t;
 
typedef struct {
    // runtime resources
    stream_t *s;
 
    // injection
    dynamic_buffer_stream_env_t env;
    dynamic_buffer_stream_cfg_t cfg;
 
    // test payload
    uint8_t payload[64];
 
    const test_dynamic_buffer_stream_write_case_t *tc;
} test_dynamic_buffer_stream_write_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_dynamic_buffer_stream_write(void **state)
{
    const test_dynamic_buffer_stream_write_case_t *tc =
        (const test_dynamic_buffer_stream_write_case_t *)(*state);
 
    test_dynamic_buffer_stream_write_fixture_t *fx =
        (test_dynamic_buffer_stream_write_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
 
    // DI
    fx->env.mem = osal_mem_test_fake_ops();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
 
    fx->cfg.default_cap = tc->initial_cap;
 
    for (size_t i = 0; i < sizeof(fx->payload); ++i) {
        fx->payload[i] = (uint8_t)('A' + (i % 26));
    }
 
    if (dynamic_buffer_stream_create_stream(&fx->s, &fx->cfg, &fx->env) != STREAM_STATUS_OK) {
        free(fx);
        return -1;
    }
 
    /*
     * Inject OOM after creation so the first subsequent allocation performed by
     * growth/reserve fails.
     */
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_RESERVE_OOM
        && tc->fail_call_idx > 0) {
        fake_memory_fail_only_on_call(tc->fail_call_idx);
    }
 
    *state = fx;
    return 0;
}
 
static int teardown_dynamic_buffer_stream_write(void **state)
{
    test_dynamic_buffer_stream_write_fixture_t *fx =
        (test_dynamic_buffer_stream_write_fixture_t *)(*state);
 
    if (fx->s) {
        stream_destroy(&fx->s);
        fx->s = NULL;
    }
 
    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_dynamic_buffer_stream_write(void **state)
{
    test_dynamic_buffer_stream_write_fixture_t *fx =
        (test_dynamic_buffer_stream_write_fixture_t *)(*state);
    const test_dynamic_buffer_stream_write_case_t *tc = fx->tc;
 
    // ARRANGE
    stream_status_t st = STREAM_STATUS_INVALID;
 
    stream_t *s = fx->s;
    assert_non_null(s);
    assert_non_null(s->backend);
 
    dynamic_buffer_stream_t *dbs = (dynamic_buffer_stream_t *)s->backend;
    assert_non_null(dbs);
 
    dynamic_buffer_t *dbuf = &dbs->state.dbuf;
    assert_non_null(dbuf);
 
    /*
     * Seed backend state.
     *
     * Backend fields used here:
     * - buf
     * - len
     * - cap
     * - read_pos
     */
    assert_true(tc->prefill_len <= tc->initial_cap);
    if (tc->prefill_len > 0) {
        assert_non_null(dbuf->buf);
        osal_memcpy(dbuf->buf, fx->payload, tc->prefill_len);
    }
    dbuf->len = tc->prefill_len;
    dbuf->read_pos = tc->prefill_read_pos;
 
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_SIZE_OVERFLOW) {
        dbuf->len = SIZE_MAX;
        dbuf->read_pos = tc->prefill_read_pos;
    }
 
    const void *buf_arg = fx->payload;
    size_t n_arg = tc->write_len;
 
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_ZERO_LEN) {
        buf_arg = NULL;
        n_arg = 0;
    }
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_NONZERO) {
        buf_arg = NULL;
    }
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_ZERO_LEN) {
        n_arg = 0;
    }
 
    // Snapshot backend state for failure / invariance assertions.
    uint8_t before_bytes[64];
    const size_t snap_n =
        (dbuf->len < sizeof(before_bytes)) ? dbuf->len : sizeof(before_bytes);
    if (snap_n > 0 && dbuf->buf) {
        osal_memcpy(before_bytes, dbuf->buf, snap_n);
    }
 
    const void *buf_snapshot = dbuf->buf;
    const size_t len_snapshot = dbuf->len;
    const size_t cap_snapshot = dbuf->cap;
    const size_t read_pos_snapshot = dbuf->read_pos;
 
    // ACT
    size_t written = stream_write(s, buf_arg, n_arg, &st);
 
    // ASSERT
    assert_int_equal((int)written, (int)tc->expected_written);
    assert_int_equal((int)st, (int)tc->expected_st);
 
    if (tc->expect_backend_unchanged) {
        assert_ptr_equal(dbuf->buf, buf_snapshot);
        assert_int_equal((int)dbuf->len, (int)len_snapshot);
        assert_int_equal((int)dbuf->cap, (int)cap_snapshot);
        assert_int_equal((int)dbuf->read_pos, (int)read_pos_snapshot);
 
        if (snap_n > 0 && dbuf->buf) {
            assert_memory_equal(dbuf->buf, before_bytes, snap_n);
        }
        return;
    }
 
    // Success paths.
    assert_int_equal((int)dbuf->read_pos, (int)read_pos_snapshot);
    assert_int_equal((int)dbuf->len, (int)(len_snapshot + tc->write_len));
 
    if (tc->expect_cap_growth) {
        assert_true(dbuf->cap > cap_snapshot);
    }
    else {
        assert_true(dbuf->cap >= cap_snapshot);
    }
 
    if (len_snapshot > 0) {
        assert_memory_equal(dbuf->buf, before_bytes, snap_n);
    }
    if (tc->write_len > 0) {
        assert_memory_equal(
            (uint8_t *)dbuf->buf + len_snapshot,
            fx->payload,
            tc->write_len);
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_OK_NO_GROW = {
    .name = "dynamic_buffer_stream_write_ok_no_grow",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_OK_NO_GROW,
    .initial_cap = 16u,
    .prefill_len = 3u,
    .prefill_read_pos = 1u,
    .write_len = 5u,
    .fail_call_idx = 0u,
 
    .expected_written = 5u,
    .expected_st = STREAM_STATUS_OK,
    .expect_cap_growth = false,
    .expect_backend_unchanged = false
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_ZERO_LEN = {
    .name = "dynamic_buffer_stream_write_zero_len",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_ZERO_LEN,
    .initial_cap = 16u,
    .prefill_len = 3u,
    .prefill_read_pos = 1u,
    .write_len = 0u,
    .fail_call_idx = 0u,
 
    .expected_written = 0u,
    .expected_st = STREAM_STATUS_OK,
    .expect_cap_growth = false,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_BUF_NULL_ZERO_LEN = {
    .name = "dynamic_buffer_stream_write_buf_null_zero_len",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_ZERO_LEN,
    .initial_cap = 16u,
    .prefill_len = 3u,
    .prefill_read_pos = 1u,
    .write_len = 0u,
    .fail_call_idx = 0u,
 
    .expected_written = 0u,
    .expected_st = STREAM_STATUS_OK,
    .expect_cap_growth = false,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_OK_GROW = {
    .name = "dynamic_buffer_stream_write_ok_grow",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_OK_GROW,
    .initial_cap = 4u,
    .prefill_len = 4u,
    .prefill_read_pos = 2u,
    .write_len = 5u,
    .fail_call_idx = 0u,
 
    .expected_written = 5u,
    .expected_st = STREAM_STATUS_OK,
    .expect_cap_growth = true,
    .expect_backend_unchanged = false
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_BUF_NULL_NONZERO = {
    .name = "dynamic_buffer_stream_write_buf_null_nonzero",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_BUF_NULL_NONZERO,
    .initial_cap = 16u,
    .prefill_len = 3u,
    .prefill_read_pos = 1u,
    .write_len = 5u,
    .fail_call_idx = 0u,
 
    .expected_written = 0u,
    .expected_st = STREAM_STATUS_INVALID,
    .expect_cap_growth = false,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_RESERVE_OOM = {
    .name = "dynamic_buffer_stream_write_reserve_oom",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_RESERVE_OOM,
    .initial_cap = 4u,
    .prefill_len = 4u,
    .prefill_read_pos = 2u,
    .write_len = 5u,
    .fail_call_idx = 1u,
 
    .expected_written = 0u,
    .expected_st = STREAM_STATUS_OOM,
    .expect_cap_growth = false,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_write_case_t
CASE_DYNAMIC_BUFFER_STREAM_WRITE_SIZE_OVERFLOW = {
    .name = "dynamic_buffer_stream_write_size_overflow",
    .scenario = DYNAMIC_BUFFER_STREAM_WRITE_SCENARIO_SIZE_OVERFLOW,
    .initial_cap = 16u,
    .prefill_len = 0u,
    .prefill_read_pos = 0u,
    .write_len = 1u,
    .fail_call_idx = 0u,
 
    .expected_written = 0u,
    .expected_st = STREAM_STATUS_INVALID,
    .expect_cap_growth = false,
    .expect_backend_unchanged = true
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define DYNAMIC_BUFFER_STREAM_WRITE_CASES(X) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_OK_NO_GROW) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_ZERO_LEN) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_BUF_NULL_ZERO_LEN) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_OK_GROW) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_BUF_NULL_NONZERO) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_RESERVE_OOM) \
X(CASE_DYNAMIC_BUFFER_STREAM_WRITE_SIZE_OVERFLOW)
 
#define DYNAMIC_BUFFER_STREAM_MAKE_WRITE_TEST(case_sym) \
LEXLEO_MAKE_TEST(dynamic_buffer_stream_write, case_sym)
 
static const struct CMUnitTest dynamic_buffer_stream_write_tests[] = {
    DYNAMIC_BUFFER_STREAM_WRITE_CASES(DYNAMIC_BUFFER_STREAM_MAKE_WRITE_TEST)
};
 
#undef DYNAMIC_BUFFER_STREAM_WRITE_CASES
#undef DYNAMIC_BUFFER_STREAM_MAKE_WRITE_TEST
 
typedef enum {
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_OK_EXACT = 0,
 
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_OK_CLAMP_TO_AVAILABLE,
 
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_ZERO_LEN,
 
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_ZERO_LEN,
 
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_NONZERO,
 
    DYNAMIC_BUFFER_STREAM_READ_SCENARIO_EOF
} dynamic_buffer_stream_read_scenario_t;
 
typedef struct {
    const char *name;
 
    // arrange
    dynamic_buffer_stream_read_scenario_t scenario;
    size_t initial_cap;
    size_t prefill_len;
    size_t prefill_read_pos;
    size_t read_len;
 
    // assert
    size_t expected_read;
    stream_status_t expected_st;
    bool expect_backend_unchanged;
} test_dynamic_buffer_stream_read_case_t;
 
typedef struct {
    // runtime resources
    stream_t *s;
 
    // injection
    dynamic_buffer_stream_env_t env;
    dynamic_buffer_stream_cfg_t cfg;
 
    // test buffers
    uint8_t payload[64];
    uint8_t read_buf[64];
 
    const test_dynamic_buffer_stream_read_case_t *tc;
} test_dynamic_buffer_stream_read_fixture_t;
 
//-----------------------------------------------------------------------------
// FIXTURES
//-----------------------------------------------------------------------------
 
static int setup_dynamic_buffer_stream_read(void **state)
{
    const test_dynamic_buffer_stream_read_case_t *tc =
        (const test_dynamic_buffer_stream_read_case_t *)(*state);
 
    test_dynamic_buffer_stream_read_fixture_t *fx =
        (test_dynamic_buffer_stream_read_fixture_t *)malloc(sizeof(*fx));
    if (!fx) return -1;
 
    osal_memset(fx, 0, sizeof(*fx));
    fx->tc = tc;
 
    fake_memory_reset();
 
    // DI
    fx->env.mem = osal_mem_test_fake_ops();
    fx->env.port_env.mem = osal_mem_test_fake_ops();
 
    fx->cfg.default_cap = tc->initial_cap;
 
    for (size_t i = 0; i < sizeof(fx->payload); ++i) {
        fx->payload[i] = (uint8_t)('A' + (i % 26));
    }
    for (size_t i = 0; i < sizeof(fx->read_buf); ++i) {
        fx->read_buf[i] = (uint8_t)0xCDu;
    }
 
    if (dynamic_buffer_stream_create_stream(&fx->s, &fx->cfg, &fx->env)
        != STREAM_STATUS_OK) {
        free(fx);
        return -1;
    }
 
    *state = fx;
    return 0;
}
 
static int teardown_dynamic_buffer_stream_read(void **state)
{
    test_dynamic_buffer_stream_read_fixture_t *fx =
        (test_dynamic_buffer_stream_read_fixture_t *)(*state);
 
    if (fx->s) {
        stream_destroy(&fx->s);
        fx->s = NULL;
    }
 
    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_dynamic_buffer_stream_read(void **state)
{
    test_dynamic_buffer_stream_read_fixture_t *fx =
        (test_dynamic_buffer_stream_read_fixture_t *)(*state);
    const test_dynamic_buffer_stream_read_case_t *tc = fx->tc;
 
    // ARRANGE
    stream_status_t st = STREAM_STATUS_INVALID;
 
    stream_t *s = fx->s;
    assert_non_null(s);
    assert_non_null(s->backend);
 
    dynamic_buffer_stream_t *dbs = (dynamic_buffer_stream_t *)s->backend;
    assert_non_null(dbs);
 
    dynamic_buffer_t *dbuf = &dbs->state.dbuf;
    assert_non_null(dbuf);
 
    /*
     * Seed backend state.
     *
     * Backend fields used here:
     * - buf
     * - len
     * - cap
     * - read_pos
     */
    assert_true(tc->prefill_len <= dbuf->cap);
    if (tc->prefill_len > 0) {
        assert_non_null(dbuf->buf);
        osal_memcpy(dbuf->buf, fx->payload, tc->prefill_len);
    }
    dbuf->len = tc->prefill_len;
    dbuf->read_pos = tc->prefill_read_pos;
 
    void *buf_arg = fx->read_buf;
    size_t n_arg = tc->read_len;
 
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_ZERO_LEN) {
        buf_arg = NULL;
        n_arg = 0u;
    }
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_NONZERO) {
        buf_arg = NULL;
    }
    if (tc->scenario == DYNAMIC_BUFFER_STREAM_READ_SCENARIO_ZERO_LEN) {
        n_arg = 0u;
    }
 
    const size_t unread_before =
        (dbuf->read_pos < dbuf->len) ? (dbuf->len - dbuf->read_pos) : 0u;
    const size_t expected_copy =
        (tc->read_len < unread_before) ? tc->read_len : unread_before;
 
    uint8_t before_bytes[64];
    const size_t snap_n =
        (dbuf->len < sizeof(before_bytes)) ? dbuf->len : sizeof(before_bytes);
    if (snap_n > 0 && dbuf->buf) {
        osal_memcpy(before_bytes, dbuf->buf, snap_n);
    }
 
    uint8_t read_buf_snapshot[64];
    osal_memcpy(read_buf_snapshot, fx->read_buf, sizeof(read_buf_snapshot));
 
    const void *buf_snapshot = dbuf->buf;
    const size_t len_snapshot = dbuf->len;
    const size_t cap_snapshot = dbuf->cap;
    const size_t read_pos_snapshot = dbuf->read_pos;
 
    // ACT
    size_t rd = stream_read(s, buf_arg, n_arg, &st);
 
    // ASSERT
    assert_int_equal((int)rd, (int)tc->expected_read);
    assert_int_equal((int)st, (int)tc->expected_st);
 
    if (tc->expect_backend_unchanged) {
        assert_ptr_equal(dbuf->buf, buf_snapshot);
        assert_int_equal((int)dbuf->len, (int)len_snapshot);
        assert_int_equal((int)dbuf->cap, (int)cap_snapshot);
        assert_int_equal((int)dbuf->read_pos, (int)read_pos_snapshot);
 
        if (snap_n > 0 && dbuf->buf) {
            assert_memory_equal(dbuf->buf, before_bytes, snap_n);
        }
 
        if (buf_arg != NULL) {
            assert_memory_equal(fx->read_buf, read_buf_snapshot, sizeof(fx->read_buf));
        }
        return;
    }
 
    // Success paths with data consumption.
    assert_ptr_equal(dbuf->buf, buf_snapshot);
    assert_int_equal((int)dbuf->len, (int)len_snapshot);
    assert_int_equal((int)dbuf->cap, (int)cap_snapshot);
    assert_int_equal((int)dbuf->read_pos, (int)(read_pos_snapshot + expected_copy));
 
    if (snap_n > 0 && dbuf->buf) {
        assert_memory_equal(dbuf->buf, before_bytes, snap_n);
    }
 
    if (expected_copy > 0) {
        assert_memory_equal(
            fx->read_buf,
            fx->payload + read_pos_snapshot,
            expected_copy);
    }
    if (expected_copy < sizeof(fx->read_buf)) {
        assert_memory_equal(
            fx->read_buf + expected_copy,
            read_buf_snapshot + expected_copy,
            sizeof(fx->read_buf) - expected_copy);
    }
}
 
//-----------------------------------------------------------------------------
// CASES
//-----------------------------------------------------------------------------
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_OK_EXACT = {
    .name = "dynamic_buffer_stream_read_ok_exact",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_OK_EXACT,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 2u,
    .read_len = 3u,
 
    .expected_read = 3u,
    .expected_st = STREAM_STATUS_OK,
    .expect_backend_unchanged = false
};
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_OK_CLAMP_TO_AVAILABLE = {
    .name = "dynamic_buffer_stream_read_ok_clamp_to_available",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_OK_CLAMP_TO_AVAILABLE,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 6u,
    .read_len = 5u,
 
    .expected_read = 2u,
    .expected_st = STREAM_STATUS_OK,
    .expect_backend_unchanged = false
};
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_ZERO_LEN = {
    .name = "dynamic_buffer_stream_read_zero_len",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_ZERO_LEN,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 2u,
    .read_len = 0u,
 
    .expected_read = 0u,
    .expected_st = STREAM_STATUS_OK,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_BUF_NULL_ZERO_LEN = {
    .name = "dynamic_buffer_stream_read_buf_null_zero_len",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_ZERO_LEN,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 2u,
    .read_len = 0u,
 
    .expected_read = 0u,
    .expected_st = STREAM_STATUS_OK,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_BUF_NULL_NONZERO = {
    .name = "dynamic_buffer_stream_read_buf_null_nonzero",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_BUF_NULL_NONZERO,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 2u,
    .read_len = 3u,
 
    .expected_read = 0u,
    .expected_st = STREAM_STATUS_INVALID,
    .expect_backend_unchanged = true
};
 
static const test_dynamic_buffer_stream_read_case_t
CASE_DYNAMIC_BUFFER_STREAM_READ_EOF = {
    .name = "dynamic_buffer_stream_read_eof",
    .scenario = DYNAMIC_BUFFER_STREAM_READ_SCENARIO_EOF,
    .initial_cap = 16u,
    .prefill_len = 8u,
    .prefill_read_pos = 8u,
    .read_len = 3u,
 
    .expected_read = 0u,
    .expected_st = STREAM_STATUS_EOF,
    .expect_backend_unchanged = true
};
 
//-----------------------------------------------------------------------------
// CASES REGISTRY
//-----------------------------------------------------------------------------
 
#define DYNAMIC_BUFFER_STREAM_READ_CASES(X) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_OK_EXACT) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_OK_CLAMP_TO_AVAILABLE) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_ZERO_LEN) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_BUF_NULL_ZERO_LEN) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_BUF_NULL_NONZERO) \
X(CASE_DYNAMIC_BUFFER_STREAM_READ_EOF)
 
#define DYNAMIC_BUFFER_STREAM_MAKE_READ_TEST(case_sym) \
LEXLEO_MAKE_TEST(dynamic_buffer_stream_read, case_sym)
 
static const struct CMUnitTest dynamic_buffer_stream_read_tests[] = {
    DYNAMIC_BUFFER_STREAM_READ_CASES(DYNAMIC_BUFFER_STREAM_MAKE_READ_TEST)
};
 
#undef DYNAMIC_BUFFER_STREAM_READ_CASES
#undef DYNAMIC_BUFFER_STREAM_MAKE_READ_TEST
 
static void test_dynamic_buffer_stream_flush(void **state)
{
    (void)state;
 
    stream_t *s = NULL;
 
    const dynamic_buffer_stream_cfg_t cfg = {
        .default_cap = 16u
    };
 
    const dynamic_buffer_stream_env_t env = {
        .mem = osal_mem_test_fake_ops(),
        .port_env = {
            .mem = osal_mem_test_fake_ops()
        }
    };
 
    assert_int_equal(
        dynamic_buffer_stream_create_stream(&s, &cfg, &env),
        STREAM_STATUS_OK);
    assert_non_null(s);
    assert_non_null(s->backend);
 
    dynamic_buffer_stream_t *dbs = (dynamic_buffer_stream_t *)s->backend;
    assert_non_null(dbs);
 
    dynamic_buffer_t *dbuf = &dbs->state.dbuf;
    assert_non_null(dbuf);
    assert_non_null(dbuf->buf);
 
    osal_memcpy(dbuf->buf, "hello", 5);
    dbuf->len = 5u;
    dbuf->read_pos = 2u;
 
    char before_bytes[5];
    osal_memcpy(before_bytes, dbuf->buf, 5);
 
    const void *buf_snapshot = dbuf->buf;
    const size_t len_snapshot = dbuf->len;
    const size_t cap_snapshot = dbuf->cap;
    const size_t read_pos_snapshot = dbuf->read_pos;
 
    assert_int_equal(stream_flush(s), STREAM_STATUS_OK);
 
    assert_ptr_equal(dbuf->buf, buf_snapshot);
    assert_int_equal((int)dbuf->len, (int)len_snapshot);
    assert_int_equal((int)dbuf->cap, (int)cap_snapshot);
    assert_int_equal((int)dbuf->read_pos, (int)read_pos_snapshot);
    assert_memory_equal(dbuf->buf, before_bytes, sizeof(before_bytes));
 
    stream_destroy(&s);
    assert_null(s);
 
    assert_true(fake_memory_no_leak());
    assert_true(fake_memory_no_invalid_free());
    assert_true(fake_memory_no_double_free());
}
 
static void test_dynamic_buffer_stream_close(void **state)
{
    (void)state;
 
    fake_memory_reset();
 
    stream_t *s = NULL;
 
    const dynamic_buffer_stream_cfg_t cfg = {
        .default_cap = 16u
    };
 
    const dynamic_buffer_stream_env_t env = {
        .mem = osal_mem_test_fake_ops(),
        .port_env = {
            .mem = osal_mem_test_fake_ops()
        }
    };
 
    assert_int_equal(
        dynamic_buffer_stream_create_stream(&s, &cfg, &env),
        STREAM_STATUS_OK);
    assert_non_null(s);
    assert_non_null(s->backend);
 
    dynamic_buffer_stream_t *dbs = (dynamic_buffer_stream_t *)s->backend;
    assert_non_null(dbs);
 
    dynamic_buffer_t *dbuf = &dbs->state.dbuf;
    assert_non_null(dbuf);
    assert_non_null(dbuf->buf);
 
    /*
     * Seed backend state so destruction exercises a non-trivial backend.
     */
    osal_memcpy(dbuf->buf, "hello", 5);
    dbuf->len = 5u;
    dbuf->read_pos = 2u;
 
    /*
     * Exercise the private close callback through the public lifecycle API.
     */
    stream_destroy(&s);
 
    assert_null(s);
 
    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 dynamic_buffer_stream_stream_non_parametric_tests[] = {
        cmocka_unit_test(test_dynamic_buffer_stream_default_cfg),
        cmocka_unit_test(test_dynamic_buffer_stream_default_env),
        cmocka_unit_test(test_dynamic_buffer_stream_flush),
        cmocka_unit_test(test_dynamic_buffer_stream_close),
    };
 
    int failed = 0;
    failed += cmocka_run_group_tests(dynamic_buffer_stream_stream_non_parametric_tests, NULL, NULL);
    failed += cmocka_run_group_tests(dynamic_buffer_stream_create_stream_tests, NULL, NULL);
    failed += cmocka_run_group_tests(create_desc_dynamic_buffer_stream_tests, NULL, NULL);
    failed += cmocka_run_group_tests(dynamic_buffer_stream_write_tests, NULL, NULL);
    failed += cmocka_run_group_tests(dynamic_buffer_stream_read_tests, NULL, NULL);
 
    return failed;
}