void ReadTest::TearDown() {
mem_buffer_clear(&m_buffer);
m_metaLib = NULL;
mem_buffer_clear(&m_metaLib_buffer);
Base::TearDown();
}
dr_metalib_source_t
dr_metalib_builder_add_file(dr_metalib_builder_t builder, const char * name, const char * file) {
dr_metalib_source_t source;
struct mem_buffer name_buffer;
size_t file_len;
const char * suffix;
dr_metalib_source_format_t format;
assert(builder);
assert(file);
suffix = file_name_suffix(file);
if (suffix == NULL) return 0;
if (strcmp(suffix, "xml") == 0) {
format = dr_metalib_source_format_xml;
}
else {
return NULL;
}
mem_buffer_init(&name_buffer, 0);
if (name == NULL) {
name = file_name_base(file, &name_buffer);
if (name == NULL) {
mem_buffer_clear(&name_buffer);
return NULL;
}
}
assert(name);
file_len = strlen(file) + 1;
source = dr_metalib_source_create(builder, name, file_len, dr_metalib_source_type_file, format, dr_metalib_source_from_user);
if (source == NULL) {
mem_buffer_clear(&name_buffer);
return NULL;
}
memcpy(source + 1, file, file_len);
mem_buffer_clear(&name_buffer);
return source;
}
const char * MergeTest::result(cfg_t cfg) {
CPE_DEF_ERROR_MONITOR(em, cpe_error_log_to_consol, NULL);
mem_buffer_clear(&m_result_buffer);
struct write_stream_buffer stream = CPE_WRITE_STREAM_BUFFER_INITIALIZER(&m_result_buffer);
EXPECT_EQ(0, cfg_write((write_stream_t)&stream, cfg, &em));
stream_putc((write_stream_t)&stream, 0);
return (const char *)mem_buffer_make_exactly(&m_result_buffer);
}
void ReadTest::installMeta(const char * def) {
m_metaLib = NULL;
mem_buffer_clear(&m_metaLib_buffer);
t_elist_clear();
EXPECT_EQ(
0,
dr_create_lib_from_xml_ex(&m_metaLib_buffer, def, strlen(def), t_em()))
<< "install meta error";
m_metaLib = (LPDRMETALIB)mem_buffer_make_exactly(&m_metaLib_buffer);
}
void dir_search(
dir_visitor_t visitor, void * ctx,
const char * path, int maxLevel,
error_monitor_t em, mem_allocrator_t talloc)
{
struct mem_buffer buffer;
mem_buffer_init(&buffer, talloc);
mem_buffer_strcat(&buffer, path);
dir_search_i(visitor, ctx, maxLevel, em, &buffer);
mem_buffer_clear(&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;
}
static int do_generate_h(cpe_dr_generate_ctx_t ctx) {
struct dr_metalib_source_it source_it;
dr_metalib_source_t source;
struct mem_buffer buffer;
struct write_stream_file stream;
int i;
FILE * fp;
int rv;
mem_buffer_init(&buffer, 0);
rv = 0;
for(i = 0; i < o_h->count; ++i) {
dr_metalib_builder_sources(&source_it, ctx->m_builder);
while((source = dr_metalib_source_next(&source_it))) {
const char * file_name;
if (dr_metalib_source_from(source) != dr_metalib_source_from_user) continue;
file_name = dr_metalib_source_file(source);
if (file_name == NULL) continue;
mem_buffer_clear_data(&buffer);
mem_buffer_strcat(&buffer, o_h->filename[i]);
mem_buffer_strcat(&buffer, "/");
file_name_append_base(&buffer, file_name);
mem_buffer_strcat(&buffer, ".h");
fp = file_stream_open((char *)mem_buffer_make_continuous(&buffer, 0), "w", ctx->m_em);
if (fp == NULL) {
rv = -1;
continue;
}
write_stream_file_init(&stream, fp, ctx->m_em);
cpe_dr_generate_h((write_stream_t)&stream, source, ctx);
file_stream_close(fp, ctx->m_em);
}
}
mem_buffer_clear(&buffer);
return rv;
}
int ReadTest::read(const char * data, const char * typeName, int policy, size_t capacity) {
LPDRMETA meta = dr_lib_find_meta_by_name(m_metaLib, typeName);
EXPECT_TRUE(meta) << "get meta " << typeName << " error!";
if (meta == 0) return -1;
if (capacity == 0) {
capacity = dr_meta_size(meta);
}
cfg_t input = t_cfg_parse(data);
EXPECT_TRUE(input) << "parse input to cfg fail!";
if (input == 0) return -1;
t_elist_clear();
mem_buffer_clear(&m_buffer);
return dr_cfg_read(
mem_buffer_alloc(&m_buffer, capacity),
capacity,
input,
meta,
policy,
t_em());
}
void WriteTest::TearDown() {
m_metaLib = NULL;
mem_buffer_clear(&m_metaLib_buffer);
Base::TearDown();
}
void MergeTest::TearDown() {
mem_buffer_clear(&m_result_buffer);
Base::TearDown();
}
void BufferTest::TearDown() {
mem_buffer_clear(&m_buffer);
Base::TearDown();
}
