#include "test_dbuf.hpp"

extern "C" 
{
    #include "guf_alloc_libc.h"
    #include "impls/dbuf_impl.h"
}

/*
    DbufIntTest
*/

void DbufIntTest::run() 
{
    if (done) {
        return;
    }

    // allocator_ctx.tracker.log = fopen("alloc_log.txt", "w");
    // allocator_ctx.tracker.err_log = fopen("alloc_err_log.txt", "w");

    dbuf_int dbuf {};
    dbuf_int_init(&dbuf, 0, &allocator);

    push_check_name("test_push");

    test_push(&dbuf, 256);
    test_push(&dbuf, 128);
    test_push(&dbuf, 17);
    TEST_CHECK(dbuf.size == (256 + 128 + 17));

    dbuf_int_free(&dbuf, NULL);
    TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && dbuf.data == NULL);

    dbuf_int_init(&dbuf, 24, &allocator);
    TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 24 && dbuf.data);

    test_push(&dbuf, 365);
    test_push(&dbuf, 4);
    test_push(&dbuf, 25);
    test_push(&dbuf, 64);
    TEST_CHECK(dbuf.size == (365 + 4 + 25 + 64));

    dbuf_int_free(&dbuf, NULL);
    TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && dbuf.data == NULL);

    pop_check_name();

    push_check_name("insert_remove");

    for (int n = 0; n <= 128; ++n) {
        test_insert_remove(n);
    }
    test_insert_remove(400);
    test_insert_remove(401);
    test_insert_remove(512);
    test_insert_remove(513);
    test_insert_remove(601);
    test_insert_remove(2048);
    test_insert_remove(2049);

    pop_check_name();

    TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker));
    // guf_alloc_tracker_print(&allocator_ctx.tracker, stdout);
    // puts("");
    // fclose(allocator_ctx.tracker.log); 
    // fclose(allocator_ctx.tracker.err_log);
}

std::vector<int> DbufIntTest::dbuf_to_vec(dbuf_int *dbuf)
{
    std::vector<int> vec;
    GUF_CNT_FOREACH(dbuf, dbuf_int, it) {
        vec.push_back(*it.ptr);
    }
    return vec;
}

void DbufIntTest::test_push(dbuf_int *dbuf, int n)
{
    std::vector<int> vec = dbuf_to_vec(dbuf);

    TEST_CHECK(std::ssize(vec) == dbuf->size);

    for (int i = 0; i < n; ++i) {
        dbuf_int_push_val(dbuf, i);
        vec.push_back(i);
        TEST_CHECK(*dbuf_int_back(dbuf) == vec.back());
    }

    ptrdiff_t i = 0;
    GUF_CNT_FOREACH(dbuf, dbuf_int, it) {
        TEST_CHECK(*it.ptr == vec.at(i++));
    }
    TEST_CHECK(i == dbuf->size);

    i = dbuf->size - 1;
    GUF_CNT_FOREACH_REVERSE(dbuf, dbuf_int, rit) {
        TEST_CHECK(*rit.ptr == vec.at(i--));
    }
    TEST_CHECK(i == -1);

}

void DbufIntTest::test_insert_remove(int n)
{
    dbuf_int dbuf = {};
    dbuf_int_init(&dbuf, 0, &allocator);
    std::vector<int> vec = dbuf_to_vec(&dbuf);

    guf_err err = GUF_ERR_NONE;
    dbuf_int_try_erase(&dbuf, 0, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_int_try_erase(&dbuf, 12, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_int_try_front(&dbuf, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_int_try_back(&dbuf, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_int_try_at(&dbuf, 0, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    for (int i = 0; i < n; ++i) {
        dbuf_int_insert_val(&dbuf, i, i);
        dbuf_int_insert_val(&dbuf, i * 2, 0);
        dbuf_int_insert_val(&dbuf, i * 4, dbuf.size);

        vec.insert(vec.begin() + i, i);
        vec.insert(vec.begin(), i * 2);
        vec.insert(vec.end(), i * 4);
    }
    TEST_CHECK(std::ssize(vec) == dbuf.size);

    // Iterate
    dbuf_int_iter it_dbuf = dbuf_int_begin(&dbuf); 
    std::vector<int>::const_iterator it_vec = vec.begin();
    while (!dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec != vec.end()) {
        TEST_CHECK(*it_dbuf.ptr == *it_vec);
        it_dbuf = dbuf_int_iter_next(&dbuf, it_dbuf, 1);
        std::advance(it_vec, 1);
    }
    TEST_CHECK(dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec == vec.end());

    // Step iterate.
    it_dbuf = dbuf_int_begin(&dbuf); 
    it_vec = vec.begin();
    while (!dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec != vec.end()) {
        TEST_CHECK(*it_dbuf.ptr == *it_vec);
        it_dbuf = dbuf_int_iter_next(&dbuf, it_dbuf, 7);

        if (dbuf_int_iter_is_end(&dbuf, it_dbuf)) {
            it_vec = vec.end();
        } else {
            std::advance(it_vec, 7);
        }
    }
    TEST_CHECK(dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec == vec.end());
    
    // Reverse iterate.
    dbuf_int_iter rit_dbuf = dbuf_int_rbegin(&dbuf); 
    std::vector<int>::const_reverse_iterator rit_vec = vec.crbegin();
    while (!dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec != vec.crend()) {
        TEST_CHECK(*rit_dbuf.ptr == *rit_vec);
        rit_dbuf = dbuf_int_iter_next(&dbuf, rit_dbuf, 1);
        std::advance(rit_vec, 1);
    }
    TEST_CHECK(dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec == vec.rend());

    // Reverse iterate step.
    rit_dbuf = dbuf_int_rbegin(&dbuf); 
    rit_vec = vec.crbegin();
    while (!dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec != vec.crend()) {
        TEST_CHECK(*rit_dbuf.ptr == *rit_vec);
        rit_dbuf = dbuf_int_iter_next(&dbuf, rit_dbuf, 4);
        if (dbuf_int_iter_is_end(&dbuf, rit_dbuf)) {
            rit_vec = vec.rend();
        } else {
            std::advance(rit_vec, 4);
        }
    }
    TEST_CHECK(dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec == vec.rend());

    TEST_CHECK(dbuf.size == std::ssize(vec));

    for (ptrdiff_t i = 0; i < dbuf.size; i += 8) {
        dbuf_int_erase(&dbuf, i);
        dbuf_int_erase(&dbuf, 0);
        dbuf_int_pop(&dbuf);

        vec.erase(vec.begin() + i);
        vec.erase(vec.begin() + 0);
        vec.pop_back();
    }

    TEST_CHECK(dbuf.size == std::ssize(vec));

    for (ptrdiff_t i = 0; i < dbuf.size; i += 8) {
        TEST_CHECK(*dbuf_int_at(&dbuf, i) == vec.at(i));
    }

    const ptrdiff_t size = dbuf.size;
    for (ptrdiff_t i = 0; i < size; ++i) {
        int a = dbuf_int_pop_move(&dbuf);
        int b = vec.back();
        TEST_CHECK(a == b);
        vec.pop_back();
    }
    TEST_CHECK(dbuf.size == 0 && vec.size() == 0);

    dbuf_int_free(&dbuf, NULL);
    TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && !dbuf.data);
}




/*
    DbufCstringTest
*/

void DbufCstringTest::run() 
{
    if (done) {
        return;
    }
    
    // allocator_ctx.tracker.log = fopen("alloc_log.txt", "w");
    // allocator_ctx.tracker.err_log = fopen("alloc_err_log.txt", "w");

    push_check_name("push_insert_erase");

    for (int i = 1; i <= 32; ++i) {
        test_push_insert_erase(i);
        test_push_insert_erase(i, i - 1);
        test_push_insert_erase(i, i + 1);
        test_push_insert_erase(i, i);
        test_push_insert_erase(i, i / 2);
    }
    test_push_insert_erase(2048);
    test_push_insert_erase(2048, 11);

    dbuf_heap_cstr str_dbuf = {};
    dbuf_heap_cstr_init(&str_dbuf, 0, &allocator);
    std::vector<std::string> str_vec {};

    for (int i = 0; i < 512; ++i) {
        char buf[128];
        memset(buf, '\0', GUF_ARR_SIZE(buf));
        snprintf(buf, GUF_ARR_SIZE(buf), "This is a pretty guf string (number %d)", i);
        guf_cstr_heap str = buf;
        dbuf_heap_cstr_push(&str_dbuf, &str, GUF_CPY_DEEP);
        str_vec.push_back(std::string{buf});
    }
    for (int i = 0; i < str_dbuf.size + 16; ++i) {
        test_iter(str_vec, &str_dbuf, i);
    }

    dbuf_heap_cstr_free(&str_dbuf, NULL);
    TEST_CHECK(str_dbuf.size == 0 && str_dbuf.capacity == 0 && !str_dbuf.data);

    pop_check_name();

    push_check_name("find");
    test_find();
    test_find(3);
    test_find(42);
    test_find(129);
    pop_check_name();

    TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker));
    // guf_alloc_tracker_print(&allocator_ctx.tracker, stdout);
    // puts("");
    // fclose(allocator_ctx.tracker.log);
    // fclose(allocator_ctx.tracker.err_log);
}

void DbufCstringTest::test_iter(std::vector<std::string>& str_vec, dbuf_heap_cstr *str_dbuf, int step)
{
    GUF_ASSERT_RELEASE(str_dbuf);
    if (step <= 0) {
        step = 1;
    }

    ptrdiff_t i = 0;
    GUF_CNT_FOREACH(str_dbuf, dbuf_heap_cstr, it) {
        char *str = *it.ptr;
        TEST_CHECK(str_vec.at(i) == str);
        ++i;
    }
    TEST_CHECK(i == str_dbuf->size);

    i = str_dbuf->size - 1;
    GUF_CNT_FOREACH_REVERSE(str_dbuf, dbuf_heap_cstr, rit) {
        char *str = *rit.ptr;
        TEST_CHECK(str_vec.at(i) == str);
        --i;
    }
    TEST_CHECK(i == -1);

    dbuf_heap_cstr_iter it_dbuf = dbuf_heap_cstr_begin(str_dbuf);
    std::vector<std::string>::iterator it_vec = str_vec.begin();
    while (!dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf)) {
        TEST_CHECK(it_vec != str_vec.end());
        TEST_CHECK(*it_vec == *it_dbuf.ptr);
        it_dbuf = dbuf_heap_cstr_iter_next(str_dbuf, it_dbuf, step);
        if (!dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf)) {
            std::advance(it_vec, step);
        } else {
            it_vec = str_vec.end();
        }
    }
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf) && it_vec == str_vec.end());

    dbuf_heap_cstr_iter rit_dbuf = dbuf_heap_cstr_rbegin(str_dbuf);
    std::vector<std::string>::reverse_iterator rit_vec = str_vec.rbegin();
    while (!dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf)) {
        TEST_CHECK(rit_vec != str_vec.rend());
        TEST_CHECK(*rit_vec == *rit_dbuf.ptr);
        rit_dbuf = dbuf_heap_cstr_iter_next(str_dbuf, rit_dbuf, step);
        if (!dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf)) {
            std::advance(rit_vec, step);
        } else {
            rit_vec = str_vec.rend();
        }
    }
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf) && rit_vec == str_vec.rend());

    for (i = 0; i < str_dbuf->size; ++i) {
        char *str = *dbuf_heap_cstr_at(str_dbuf, i);
        TEST_CHECK(str_vec.at(i) == str);
    }
}

void DbufCstringTest::test_push_insert_erase(int n, ptrdiff_t start_cap)
{
    std::vector<std::string> str_vec;
    dbuf_heap_cstr str_dbuf {};
    dbuf_heap_cstr_init(&str_dbuf, start_cap, &allocator);

    for (int i = 0; i < n; ++i) {
        constexpr int BUF_SZ = 128;
        char buf[BUF_SZ]; 
        memset(buf, '\0', BUF_SZ);
        snprintf(buf, BUF_SZ, "This is string number %d", i);
        guf_cstr_heap str = buf;

        dbuf_heap_cstr_push(&str_dbuf, &str, GUF_CPY_DEEP);
        dbuf_heap_cstr_push_val_cpy(&str_dbuf, str);
        char *heap_buf = strdup("Move me plz");
        dbuf_heap_cstr_push(&str_dbuf, &heap_buf, GUF_CPY_MOVE);
        TEST_CHECK(heap_buf == NULL);

        TEST_CHECK(strncmp(*dbuf_heap_cstr_back(&str_dbuf), "Move me plz", BUF_SZ) == 0);
        TEST_CHECK(strncmp(*dbuf_heap_cstr_at(&str_dbuf, str_dbuf.size - 2), buf, BUF_SZ) == 0);
        TEST_CHECK(strncmp(*dbuf_heap_cstr_at(&str_dbuf, str_dbuf.size - 3), buf, BUF_SZ) == 0);

        str_vec.push_back(std::string{buf});
        str_vec.push_back(std::string{buf});
        str_vec.emplace_back("Move me plz");
    }

    TEST_CHECK(str_dbuf.size == std::ssize(str_vec));
    TEST_CHECK(str_dbuf.size == 3 * n);

    for (int i = 1; i <= 8; ++i) {
        test_iter(str_vec, &str_dbuf, i);
    }
    test_iter(str_vec, &str_dbuf, (int)str_dbuf.size);
    test_iter(str_vec, &str_dbuf, (int)str_dbuf.size - 1);
    test_iter(str_vec, &str_dbuf, (int)str_dbuf.size + 1);

    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        TEST_CHECK(str_vec.at(i) ==  *dbuf_heap_cstr_at(&str_dbuf, i));
    }

    // Insert front.
    for (ptrdiff_t i = 0; i < 16; ++i) {
        char str[] = "front";
        dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, 0);
        str_vec.insert(str_vec.begin(), std::string{str});
    }
    TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        TEST_CHECK(str_vec.at(i) ==  *dbuf_heap_cstr_at(&str_dbuf, i));
    }
    // Insert back. 
    for (ptrdiff_t i = 0; i < 16; ++i) {
        char str[] = "front";
        dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size);
        str_vec.insert(str_vec.end(), std::string{str});
    }
    TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        TEST_CHECK(str_vec.at(i) ==  *dbuf_heap_cstr_at(&str_dbuf, i));
    }

    // Insert at i. 
    char str[] = "guf";
    dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size / 2);
    str_vec.insert(str_vec.begin() + str_vec.size() / 2, str);
    dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size / 4);
    str_vec.insert(str_vec.begin() + str_vec.size() / 4, str);
    dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, 1);
    str_vec.insert(str_vec.begin() + 1, str);
    dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size - 1);
    str_vec.insert(str_vec.begin() + (str_vec.size() - 1), str);

    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        TEST_CHECK(str_vec.at(i) ==  *dbuf_heap_cstr_at(&str_dbuf, i));
    }

    guf_err err = GUF_ERR_NONE;
    dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, str_dbuf.size + 1, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, -1, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    err = GUF_ERR_NONE;
    dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, str_dbuf.size + 2, &err);
    TEST_CHECK(err == GUF_ERR_IDX_RANGE);

    TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        TEST_CHECK(str_vec.at(i) ==  *dbuf_heap_cstr_at(&str_dbuf, i));
    }

    if (str_dbuf.size) {
        dbuf_heap_cstr_erase(&str_dbuf, str_dbuf.size - 1);
        str_vec.erase(str_vec.end() - 1);
    }

    ptrdiff_t to_rem = 8;
    while (str_dbuf.size && to_rem--) {
        dbuf_heap_cstr_erase(&str_dbuf, 0);
        str_vec.erase(str_vec.begin());
        TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
        if (str_dbuf.size) {
            dbuf_heap_cstr_pop(&str_dbuf);
            str_vec.pop_back();
            TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
        }
        if (str_dbuf.size) {
            dbuf_heap_cstr_erase(&str_dbuf, str_dbuf.size / 2);
            str_vec.erase(str_vec.begin() + (str_vec.size() / 2));
            TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);
        }
    }
    
    dbuf_heap_cstr_free(&str_dbuf, NULL);
    TEST_CHECK(str_dbuf.size == 0 && str_dbuf.capacity == 0 && !str_dbuf.data);
}

void DbufCstringTest::test_find(int n)
{
    if (n < 2) {
        n = 2;
    }
    std::vector<std::string> str_vec {};

    dbuf_heap_cstr str_dbuf = {};
    dbuf_heap_cstr_init(&str_dbuf, 0, &allocator);

    for (int i = 0; i < n; ++i) {
        constexpr int BUF_SZ = 128;
        char buf[BUF_SZ]; 
        memset(buf, '\0', BUF_SZ);
        snprintf(buf, BUF_SZ, "String number %d", i);

        dbuf_heap_cstr_push_val_cpy(&str_dbuf, buf);
        str_vec.push_back(buf);
    }
    char *move_me = strdup("Moved string");
    dbuf_heap_cstr_push(&str_dbuf, &move_me, GUF_CPY_MOVE);
    GUF_ASSERT_RELEASE(move_me == NULL);
    str_vec.emplace_back("Moved string");

    TEST_CHECK(std::ssize(str_vec) == str_dbuf.size);

    for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) {
        char *needle = *dbuf_heap_cstr_at(&str_dbuf, i);
        TEST_CHECK(str_vec.at(i) == needle);

        TEST_CHECK(dbuf_heap_cstr_contains_val(&str_dbuf, needle)); 

        dbuf_heap_cstr_iter fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_end(&str_dbuf), needle);
        TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
        TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cend(), needle) != str_vec.end());

        dbuf_heap_cstr_iter begin = dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), i);
        dbuf_heap_cstr_iter end = dbuf_heap_cstr_end(&str_dbuf);
        fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, begin, end, needle);
        TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
        TEST_CHECK(std::find(str_vec.cbegin() + i, str_vec.cend(), needle) != str_vec.end());

        begin = dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), i + 1);
        end = dbuf_heap_cstr_end(&str_dbuf);
        fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, begin, end, needle);
        TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
        TEST_CHECK(std::find(str_vec.cbegin() + i + 1, str_vec.cend(), needle) == str_vec.end());

        // Reverse.
        fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_rbegin(&str_dbuf), dbuf_heap_cstr_rend(&str_dbuf), needle);
        TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
        TEST_CHECK(std::find(str_vec.crbegin(), str_vec.crend(), needle) != str_vec.rend());
    }

    char needle[] = "Definitely not inside";
    dbuf_heap_cstr_iter fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_end(&str_dbuf), needle);
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
    TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cend(), needle) == str_vec.end());

    fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_rbegin(&str_dbuf), dbuf_heap_cstr_rend(&str_dbuf), needle);
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
    TEST_CHECK(std::find(str_vec.crbegin(), str_vec.crend(), needle) == str_vec.rend());

    char *needle2 = *dbuf_heap_cstr_at(&str_dbuf, 0);
    fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), 1), dbuf_heap_cstr_end(&str_dbuf), needle2);
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
    TEST_CHECK(std::find(str_vec.cbegin() + 1, str_vec.cend(), needle2) == str_vec.end());

    needle2 = *dbuf_heap_cstr_back(&str_dbuf);
    fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), 1), dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_end(&str_dbuf), -1), needle2);
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
    TEST_CHECK(std::find(str_vec.begin(), str_vec.end() - 1, needle2) == (str_vec.end() - 1));

    needle2 = *dbuf_heap_cstr_at(&str_dbuf, 0);
    fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_begin(&str_dbuf), needle2);
    TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it));
    TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cbegin(), needle2) == str_vec.cbegin());
    
    dbuf_heap_cstr_free(&str_dbuf, NULL);
}



/*
    DbufStrTest:
*/

void DbufStrTest::run() 
{
    test_push_insert_erase(16);    
    test_push_insert_erase(16, 1);
    test_push_insert_erase(16, 15);    
    test_push_insert_erase(16, 16);    
    test_push_insert_erase(16, 97);
    test_push_insert_erase(16, 256);

    test_push_insert_erase(500);
    test_push_insert_erase(500, 1);
    test_push_insert_erase(500, 499);
    test_push_insert_erase(500, 500);
    test_push_insert_erase(500, 97);
    test_push_insert_erase(500, 256);

}


void DbufStrTest::test_push_insert_erase(size_t n, ptrdiff_t start_cap)
{
    dbuf_str strings = start_cap < 0 ? dbuf_str_new(&allocator) : dbuf_str_new_with_capacity(start_cap, &allocator); 
    std::vector<std::string> strings_cpp {};

    guf_libc_alloc_ctx str_allocator_ctx = {
        .tracker = guf_alloc_tracker_new(42, "test_push_insert_erase: local str allocator", NULL, NULL), 
        .zero_init = false
    };
    guf_allocator str_allocator = guf_libc_allocator_new(&str_allocator_ctx);

    for (size_t i = 0; i < n; ++i) {
        std::string str; 
        for (size_t c = 0; c < 512 + GUF_STR_SSO_BUF_CAP; ++c) {
            str += (char)(c % 10 + '0');
        }
        const guf_str_view sv_long = guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()};
        const guf_str_view sv_short = guf_str_view{.str = str.data(), .len = (ptrdiff_t)GUF_STR_SSO_BUF_CAP - 1};

        guf_str long_str = GUF_STR_UNINITIALISED_CPP, short_str = GUF_STR_UNINITIALISED_CPP;
        guf_str_init(&long_str, sv_long, &str_allocator); 
        guf_str_init(&short_str, sv_short, &str_allocator);

        TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 1 + (i*3));
        
        // Move
        guf_err err;
        dbuf_str_try_push(&strings, &long_str, GUF_CPY_MOVE, &err); 
        TEST_CHECK(err == GUF_ERR_NONE); 
        dbuf_str_try_push(&strings, &short_str, GUF_CPY_MOVE, &err); 
        TEST_CHECK(err == GUF_ERR_NONE); 

        strings_cpp.push_back(str.substr(0, str.size())); 
        strings_cpp.push_back(str.substr(0, GUF_STR_SSO_BUF_CAP - 1));

        TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 1 + (i*3));

        TEST_CHECK(guf_str_is_uninit(&long_str));
        TEST_CHECK(guf_str_is_uninit(&short_str));

        // Deep-copy
        guf_str_init(&long_str, sv_long, &str_allocator); 
        guf_str_init(&short_str, sv_short, &str_allocator); 

        TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 2 + (i*3));

        dbuf_str_try_push(&strings, &long_str, GUF_CPY_DEEP, &err); 
        TEST_CHECK(err == GUF_ERR_NONE); 
        dbuf_str_try_push(&strings, &short_str, GUF_CPY_DEEP, &err); 
        TEST_CHECK(err == GUF_ERR_NONE); 

        strings_cpp.push_back(str.substr(0, str.size())); 
        strings_cpp.push_back(str.substr(0, GUF_STR_SSO_BUF_CAP - 1));

        TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 + (i*3));

        TEST_CHECK(guf_str_is_valid(&long_str) && guf_str_is_valid(&short_str));
        TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(&long_str), sv_long));
        TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(&short_str), sv_short));

        guf_str_free(&long_str, NULL); 
        guf_str_free(&short_str, NULL); 

        TEST_CHECK(str_allocator_ctx.tracker.free_count == 1 + (i*1));
        TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 + (i*3));
    }

    TEST_CHECK(str_allocator_ctx.tracker.free_count == n);
    TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 * n);

    TEST_CHECK(strings.size == 4 * (ptrdiff_t)n);
    TEST_CHECK(strings.size == std::ssize(strings_cpp));

    std::string str; 
    for (size_t c = 0; c < 512 + GUF_STR_SSO_BUF_CAP; ++c) {
        str += (char)(c % 10 + '0');
    }
    const guf_str_view sv_long = guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()};
    const guf_str_view sv_short = guf_str_view{.str = str.data(), .len = (ptrdiff_t)GUF_STR_SSO_BUF_CAP - 1};
    size_t i = 0;
    GUF_CNT_FOREACH(&strings, dbuf_str, it) {
        if (TEST_CHECK(it.ptr)) {
            const guf_str *s = it.ptr;
            TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(s), i % 2 == 0 ? sv_long : sv_short));
            const guf_str_view sv_cpp = guf_str_view {.str = strings_cpp.at(i).data(), .len = (ptrdiff_t)strings_cpp.at(i).size()};
            TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(s), sv_cpp));
        }
        ++i;
    }

    GUF_CNT_FOREACH(&strings, dbuf_str, it) {
        if (TEST_CHECK(it.ptr)) {
            guf_str *s = it.ptr;
            TEST_CHECK(guf_str_append(s, GUF_CSTR_LIT_TO_VIEW_CPP("<END>")));
        }
    }
    std::vector<guf_str_view> delims = {guf_str_view{.str = "<END>", .len = 5}};
    i = 0;
    GUF_CNT_FOREACH(&strings, dbuf_str, it) {
        if (TEST_CHECK(it.ptr)) {
            const guf_str *s = it.ptr;
            guf_str_tok_state tk_state = guf_str_tok_state_new(guf_str_view_from_str(s), delims.data(), std::ssize(delims), GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); 
            size_t tok_n = 0;
            while (guf_str_tok_next(&tk_state, true)) {
                TEST_CHECK(guf_str_view_equal_val_arg(tk_state.cur_tok , i % 2 == 0 ? sv_long : sv_short));
                TEST_CHECK(guf_str_view_equal_val_arg(tk_state.cur_delim, guf_str_view{.str = "<END>", .len = 5}));
                ++tok_n; 
            }
            TEST_CHECK(tok_n == 1);
        }
        ++i;
    }

    dbuf_str_free(&strings, NULL);
    TEST_CHECK(!guf_alloc_tracker_found_leak(&str_allocator_ctx.tracker));
}