TEST_F(BufferTest, strcat_to_buf) {
EXPECT_EQ((size_t)3, append_string("abc"));
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
EXPECT_EQ(-1, mem_buffer_strcat(&m_buffer, "def"));
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, set_size_small_multi_trunk) {
EXPECT_TRUE(append_trunk("aaa"));
EXPECT_TRUE(append_trunk("bbb"));
EXPECT_EQ((size_t)6, mem_buffer_size(&m_buffer));
EXPECT_EQ(0, mem_buffer_set_size(&m_buffer, 1));
EXPECT_EQ((size_t)1, mem_buffer_size(&m_buffer));
EXPECT_EQ((size_t)2, mem_buffer_trunk_count(&m_buffer));
}
TEST_F(BufferTest, make_continuous_single_trunk_with_capacity) {
char buf[5] = { 0 };
struct mem_buffer_trunk * told = append_trunk("a");
void * newDataAddr = mem_buffer_make_continuous(&m_buffer, 1024);
EXPECT_TRUE(told != trunk_at(0));
EXPECT_EQ((size_t)1, mem_buffer_size(&m_buffer));
memcpy(buf, newDataAddr, mem_buffer_size(&m_buffer));
EXPECT_STREQ("a", buf);
}
TEST_F(BufferTest, trunk_free) {
struct mem_buffer_trunk * trunk =
mem_buffer_append_trunk(&m_buffer, 5);
const char * data = "abcde";
EXPECT_EQ((size_t)3, mem_trunk_append(&m_buffer, trunk, data, 3));
EXPECT_EQ((size_t)3, trunk->m_size);
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
mem_trunk_free(&m_buffer, trunk);
EXPECT_EQ((size_t)0, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, trunk_append_twice_overflow) {
struct mem_buffer_trunk * trunk =
mem_buffer_append_trunk(&m_buffer, 5);
const char * data = "abcde";
EXPECT_EQ((size_t)3, mem_trunk_append(&m_buffer, trunk, data, 3));
EXPECT_EQ((size_t)3, trunk->m_size);
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
EXPECT_EQ((size_t)2, mem_trunk_append(&m_buffer, trunk, data, 3));
EXPECT_EQ((size_t)5, trunk->m_size);
EXPECT_EQ((size_t)5, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, trunk_free_middle) {
const char * data = "abcde";
struct mem_buffer_trunk * trunk1 =
mem_buffer_append_trunk(&m_buffer, 5);
mem_trunk_append(&m_buffer, trunk1, data, 3);
struct mem_buffer_trunk * trunk2 =
mem_buffer_append_trunk(&m_buffer, 5);
mem_trunk_append(&m_buffer, trunk2, data, 4);
EXPECT_EQ((size_t)7, mem_buffer_size(&m_buffer));
mem_trunk_free(&m_buffer, trunk2);
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, alloc_empty) {
void * p = mem_buffer_alloc(&m_buffer, 12);
EXPECT_TRUE(p);
EXPECT_EQ((size_t)12, mem_buffer_size(&m_buffer));
strncpy((char*)p, "abc", 12);
EXPECT_STREQ("abc", as_string());
}
TEST_F(BufferTest, strcat_to_str) {
EXPECT_EQ(0, mem_buffer_strcat(&m_buffer, "abc"));
EXPECT_STREQ("abc", (char*)mem_buffer_make_continuous(&m_buffer, 0));
EXPECT_EQ(0, mem_buffer_strcat(&m_buffer, "def"));
EXPECT_STREQ("abcdef", (char*)mem_buffer_make_continuous(&m_buffer, 0));
EXPECT_EQ((size_t)7, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, trunk_append_twice) {
struct mem_buffer_trunk * trunk =
mem_buffer_append_trunk(&m_buffer, 10);
const char * data = "abcde";
EXPECT_EQ((size_t)3, mem_trunk_append(&m_buffer, trunk, data, 3));
EXPECT_EQ((size_t)3, mem_trunk_append(&m_buffer, trunk, data, 3));
EXPECT_EQ((size_t)6, trunk->m_size);
EXPECT_EQ((size_t)6, mem_buffer_size(&m_buffer));
char buf = 0;
EXPECT_EQ((size_t)1, mem_trunk_append(&m_buffer, trunk, &buf, 1));
EXPECT_EQ((size_t)7, trunk->m_size);
EXPECT_EQ((size_t)7, mem_buffer_size(&m_buffer));
EXPECT_STREQ("abcabc", as_string());
}
TEST_F(BufferTest, append_empty) {
const char * data = "test_string";
EXPECT_EQ(strlen(data), append_string(data));
EXPECT_EQ((size_t)1, append_zero());
EXPECT_EQ(strlen(data) + 1, mem_buffer_size(&m_buffer));
EXPECT_STREQ(data, as_string());
}
TEST_F(BufferTest, append_multi_trunk) {
EXPECT_TRUE(append_trunk("a"));
EXPECT_TRUE(append_trunk("b"));
EXPECT_TRUE(append_trunk("c"));
append_zero();
EXPECT_EQ((size_t)4, mem_buffer_size(&m_buffer));
EXPECT_STREQ("abc", as_string());
}
TEST_F(BufferTest, make_exactly_single_trunk) {
char buf[5] = { 0 };
struct mem_buffer_trunk * told = append_trunk("a");
void * newDataAddr = mem_buffer_make_exactly(&m_buffer);
EXPECT_TRUE(told == trunk_at(0));
memcpy(buf, newDataAddr, mem_buffer_size(&m_buffer));
EXPECT_STREQ("a", buf);
}
TEST_F(BufferTest, make_exactly_multi_trunk) {
char buf[5] = { 0 };
EXPECT_TRUE(append_trunk("a"));
EXPECT_TRUE(append_trunk("b"));
EXPECT_TRUE(append_trunk("c"));
memcpy(buf,mem_buffer_make_exactly(&m_buffer), mem_buffer_size(&m_buffer));
EXPECT_STREQ("abc", buf);
}
TEST_F(BufferTest, strcat_to_str_trunk_full) {
struct mem_buffer_trunk * trunk1 =
mem_buffer_append_trunk(&m_buffer, 7);
EXPECT_EQ((size_t)4, mem_trunk_append(&m_buffer, trunk1, "abc", 4));
EXPECT_EQ(0, mem_buffer_strcat(&m_buffer, "def"));
EXPECT_STREQ("abcdef", (char*)mem_buffer_make_continuous(&m_buffer, 0));
EXPECT_EQ((size_t)7, mem_buffer_size(&m_buffer));
EXPECT_EQ((size_t)1, mem_buffer_trunk_count(&m_buffer));
}
int tools_main(error_monitor_t em) {
struct cpe_dr_generate_ctx ctx;
struct mem_buffer buffer;
int rv;
ctx.m_builder = NULL;
ctx.m_metalib = NULL;
ctx.m_em = em;
rv = 0;
ctx.m_builder = dr_metalib_builder_create(NULL, em);
if (ctx.m_builder == NULL) {
CPE_ERROR(em, "create metalib builder fail!");
return -1;
}
prepare_input(ctx.m_builder, em);
dr_metalib_builder_analize(ctx.m_builder);
mem_buffer_init(&buffer, 0);
if (dr_inbuild_build_lib(
&buffer,
dr_metalib_bilder_lib(ctx.m_builder),
em) == 0)
{
ctx.m_metalib = (LPDRMETALIB)mem_buffer_make_continuous(&buffer, 0), mem_buffer_size(&buffer);
if (ctx.m_metalib) {
if (do_validate(&ctx) != 0) rv = -1;
if (do_generate_h(&ctx) != 0) rv = -1;
if (do_generate_lib_bin(&ctx) != 0) rv = -1;
if (do_generate_lib_c(&ctx) != 0) rv = -1;
}
}
else {
rv = -1;
}
mem_buffer_clear(&buffer);
dr_metalib_builder_free(ctx.m_builder);
return rv;
}
TEST_F(BufferTest, strdup_len_basic) {
EXPECT_STREQ("ab", mem_buffer_strdup_len(&m_buffer, "abc", 2));
EXPECT_EQ((size_t)3, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, set_size_empty) {
mem_buffer_alloc(&m_buffer, 12);
EXPECT_EQ(0, mem_buffer_set_size(&m_buffer, 12));
EXPECT_EQ((size_t)12, mem_buffer_size(&m_buffer));
}
size_t BufferTest::buffer_size(void) {
return mem_buffer_size(&m_buffer);
}
TEST_F(BufferTest, set_size_bigger) {
mem_buffer_alloc(&m_buffer, 12);
EXPECT_EQ(0, mem_buffer_set_size(&m_buffer, 14));
EXPECT_EQ((size_t)14, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, set_size_small) {
mem_buffer_alloc(&m_buffer, 12);
EXPECT_EQ(0, mem_buffer_set_size(&m_buffer, 10));
EXPECT_EQ((size_t)10, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, alloc_empty_null) {
m_buffer.m_default_allocrator = mem_allocrator_null();
EXPECT_FALSE(mem_buffer_alloc(&m_buffer, 12));
EXPECT_EQ((size_t)0, mem_buffer_size(&m_buffer));
}
TEST_F(BufferTest, strdup_basic) {
EXPECT_STREQ("abc", mem_buffer_strdup(&m_buffer, "abc"));
EXPECT_EQ((size_t)4, mem_buffer_size(&m_buffer));
}
enum dir_visit_next_op
dir_search_i(
dir_visitor_t visitor, void * ctx,
int maxLevel,
error_monitor_t em,
mem_buffer_t buffer)
{
DIR * dirp;
struct dirent dbuf;
struct dirent * dp;
char * path;
int rv;
size_t bufSize;
enum dir_visit_next_op nextOp;
if (maxLevel == 0) return dir_visit_next_go;
path = (char *)mem_buffer_make_continuous(buffer, 0);
bufSize = mem_buffer_size(buffer);
dirp = dir_open(path, 0, em);
if (dirp == NULL) return dir_visit_next_go;
nextOp = dir_visit_next_go;
while((rv = readdir_r(dirp, &dbuf, &dp)) == 0 && dp) {
if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0) continue;
if (
mem_buffer_strcat(buffer, "/") != 0 ||
mem_buffer_strcat(buffer, dp->d_name) != 0) break;
if (S_ISDIR(DTTOIF(dp->d_type))) {
if (visitor->on_dir_enter) {
nextOp = visitor->on_dir_enter(
(const char *)mem_buffer_make_continuous(buffer, 0),
dp->d_name,
ctx);
if (nextOp == dir_visit_next_exit) break;
}
else {
nextOp = dir_visit_next_go;
}
if (nextOp == dir_visit_next_go) {
nextOp = dir_search_i(
visitor, ctx,
maxLevel > 0 ? maxLevel - 1 : maxLevel,
em, buffer);
if (nextOp == dir_visit_next_exit) break;
}
if (visitor->on_dir_leave) {
nextOp = visitor->on_dir_leave(
(const char *)mem_buffer_make_continuous(buffer, 0),
dp->d_name,
ctx);
if (nextOp == dir_visit_next_exit) break;
}
}
else if (S_ISREG(DTTOIF(dp->d_type))) {
if (visitor->on_file) {
nextOp = visitor->on_file(
(const char *)mem_buffer_make_continuous(buffer, 0),
dp->d_name,
ctx);
if (nextOp == dir_visit_next_exit) break;
}
}
/*restore curent path*/
mem_buffer_set_size(buffer, bufSize);
path = (char *)mem_buffer_make_continuous(buffer, 0);
if (path == NULL) {
CPE_ERROR_EX(em, ENOMEM, "no memory for dir search path");
nextOp = dir_visit_next_exit;
break;
}
path[bufSize - 1] = 0;
}
/*clear resources*/
dir_close(dirp, em);
return nextOp == dir_visit_next_exit ? dir_visit_next_exit : dir_visit_next_go;
}
