540 lines
19 KiB
C++
540 lines
19 KiB
C++
#pragma once
|
|
#include <vector>
|
|
#include "test.hpp"
|
|
|
|
extern "C"
|
|
{
|
|
#include "guf_alloc_libc.h"
|
|
#include "impls/dbuf_impl.h"
|
|
}
|
|
|
|
struct DbufIntTest : public Test
|
|
{
|
|
DbufIntTest(const std::string& name) : Test(name) {};
|
|
|
|
private:
|
|
|
|
std::vector<int> 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 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 test_insert_remove(int n)
|
|
{
|
|
dbuf_int dbuf = {};
|
|
dbuf_int_init(&dbuf, 0, &guf_allocator_libc);
|
|
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);
|
|
}
|
|
|
|
public:
|
|
|
|
bool run() override
|
|
{
|
|
if (done) {
|
|
return passed;
|
|
}
|
|
|
|
dbuf_int dbuf {};
|
|
dbuf_int_init(&dbuf, 0, &guf_allocator_libc);
|
|
|
|
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, &guf_allocator_libc);
|
|
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();
|
|
|
|
done = true;
|
|
passed = (num_failed_checks == 0);
|
|
return passed;
|
|
}
|
|
};
|
|
|
|
|
|
struct DbufCstringTest : public Test
|
|
{
|
|
DbufCstringTest(std::string name) : Test(name) {};
|
|
|
|
private:
|
|
|
|
void test_iter(std::vector<std::string>& str_vec, dbuf_heap_cstr *str_dbuf, int step = 1)
|
|
{
|
|
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 test_push_insert_erase(int n, ptrdiff_t start_cap = 0)
|
|
{
|
|
std::vector<std::string> str_vec;
|
|
dbuf_heap_cstr str_dbuf {};
|
|
dbuf_heap_cstr_init(&str_dbuf, start_cap, &guf_allocator_libc);
|
|
|
|
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, str_dbuf.size);
|
|
test_iter(str_vec, &str_dbuf, str_dbuf.size - 1);
|
|
test_iter(str_vec, &str_dbuf, 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 test_find(int n = 32)
|
|
{
|
|
if (n < 2) {
|
|
n = 2;
|
|
}
|
|
std::vector<std::string> str_vec {};
|
|
|
|
dbuf_heap_cstr str_dbuf = {};
|
|
dbuf_heap_cstr_init(&str_dbuf, 0, &guf_allocator_libc);
|
|
|
|
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);
|
|
}
|
|
|
|
public:
|
|
|
|
bool run()
|
|
{
|
|
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, &guf_allocator_libc);
|
|
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();
|
|
|
|
done = true;
|
|
passed = (num_failed_checks == 0);
|
|
return passed;
|
|
}
|
|
};
|