static void
test_mult_revisions(void **state)
{
struct ly_ctx *ctx = *state;
const char *sch_yang = "module main_mod {"
"namespace \"urn:cesnet:test:a\";"
"prefix \"a\";"
"include submod_r { revision-date \"2016-06-19\";}"
"include submod1;}";
const char *sch_correct_yang = "module main_mod {"
"namespace \"urn:cesnet:test:a\";"
"prefix \"a\";"
"include submod_r;"
"include submod1;}";
const char *sch_yin = "<module name=\"main_mod\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
"<namespace uri=\"urn:cesnet:test:a\"/><prefix value=\"a\"/>"
"<include module=\"submod_r\"><revision-date date=\"2016-06-19\"/></include>"
"<include module=\"submod1\"/></module>";
const char *sch_correct_yin = "<module name=\"main_mod\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
"<namespace uri=\"urn:cesnet:test:a\"/><prefix value=\"a\"/>"
"<include module=\"submod_r\"/>"
"<include module=\"submod1\"/></module>";
ly_ctx_set_searchdir(ctx, SCHEMA_FOLDER_YIN);
assert_ptr_equal(lys_parse_mem(ctx, sch_yin, LYS_IN_YIN), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, sch_correct_yin, LYS_IN_YIN), NULL);
ly_ctx_destroy(*state, NULL);
*state = ctx = ly_ctx_new(SCHEMA_FOLDER_YANG);
assert_ptr_equal(lys_parse_mem(ctx, sch_yang, LYS_IN_YANG), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, sch_correct_yang, LYS_IN_YANG), NULL);
}
static void
TEST_MODULE(void **state)
{
struct state *st = (*state);
const int schemas_fail[] = {TEST_SCHEMA_LOAD_FAIL};
const int data_files_fail[] = {TEST_DATA_FILE_LOAD_FAIL};
char buf[1024];
LYS_INFORMAT schema_format = LYS_IN_YANG;
const struct lys_module *mod;
int i, j, ret;
for (i = 0; i < 2; ++i) {
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.%s", j + 1, (schema_format == LYS_IN_YANG ? "yang" : "yin"));
mod = lys_parse_path(st->ctx, buf, schema_format);
if (schemas_fail[j]) {
assert_ptr_equal(mod, NULL);
} else {
assert_ptr_not_equal(mod, NULL);
}
}
for (j = 0; j < TEST_DATA_FILE_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/data%d.xml", j + 1);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_CONFIG);
if (data_files_fail[j]) {
assert_ptr_not_equal(st->node, NULL);
} else {
assert_ptr_equal(st->node, NULL);
}
}
if (schema_format == LYS_IN_YANG) {
/* convert the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, BUILD_DIR "/yang2yin "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yang "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1, j + 1);
ret = system(buf);
if (ret == -1) {
fprintf(stderr, "system() failed (%s).\n", strerror(errno));
fail();
} else if (WEXITSTATUS(ret) != 0) {
fprintf(stderr, "Executing command \"%s\" finished with %d.\n", buf, WEXITSTATUS(ret));
fail();
}
}
schema_format = LYS_IN_YIN;
} else {
/* remove the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1);
if (unlink(buf)) {
fprintf(stderr, "unlink() on \"%s\" failed (%s).\n", buf, strerror(errno));
}
}
}
}
}
static void
test_insert_entry_multiple(void **state)
{
struct entry *e1, *e2;
krb5_context context = *state;
krb5_data req1 = string2data("I'm a test request");
krb5_data rep1 = string2data("I'm a test response");
krb5_data req2 = string2data("I'm a different test request");
e1 = insert_entry(context, &req1, &rep1, 20);
assert_ptr_equal(k5_hashtab_get(hash_table, req1.data, req1.length), e1);
assert_ptr_equal(K5_TAILQ_FIRST(&expiration_queue), e1);
assert_true(data_eq(e1->req_packet, req1));
assert_true(data_eq(e1->reply_packet, rep1));
assert_int_equal(e1->timein, 20);
e2 = insert_entry(context, &req2, NULL, 30);
assert_ptr_equal(k5_hashtab_get(hash_table, req2.data, req2.length), e2);
assert_ptr_equal(K5_TAILQ_LAST(&expiration_queue,entry_queue), e2);
assert_true(data_eq(e2->req_packet, req2));
assert_int_equal(e2->reply_packet.length, 0);
assert_int_equal(e2->timein, 30);
}
static void
test_empty2(void **state)
{
struct state *st = (*state);
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
struct lyd_difflist *diff;
assert_ptr_not_equal((st->first = lyd_parse_mem(st->ctx, xml, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((diff = lyd_diff(st->first, NULL, 0)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_DELETED);
assert_ptr_equal(diff->first[0], st->first);
assert_ptr_equal(diff->second[0], NULL);
assert_int_equal(diff->type[1], LYD_DIFF_DELETED);
assert_ptr_equal(diff->first[1], st->first->next);
assert_ptr_equal(diff->second[1], NULL);
assert_int_equal(diff->type[2], LYD_DIFF_END);
lyd_free_diff(diff);
}
static void
test_empty3(void **state)
{
struct state *st = (*state);
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\"><foo>42</foo></df>";
struct lyd_difflist *diff;
assert_ptr_not_equal((st->first = lyd_parse_mem(st->ctx, xml, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((diff = lyd_diff(NULL, NULL, 0)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_END);
lyd_free_diff(diff);
assert_ptr_equal((diff = lyd_diff(NULL, st->first->child, 0)), NULL);
assert_int_equal(ly_errno, LY_EINVAL);
assert_ptr_not_equal((diff = lyd_diff(st->first->child, NULL, 0)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_DELETED);
assert_ptr_equal(diff->first[0], st->first->child);
assert_ptr_equal(diff->second[0], NULL);
assert_int_equal(diff->type[1], LYD_DIFF_END);
lyd_free_diff(diff);
}
void
Test_WinPacketClone_RefCountIsValidAfterMultipleClones(void **state)
{
WinPacketRawAllocateClone_Callback =
Fake_WinPacketRawAllocateClone_ReturnsNewPacket;
PWIN_PACKET packet = Fake_WinPacketAllocateNonOwned();
PWIN_PACKET cloned1 = WinPacketClone(packet);
PWIN_PACKET cloned2 = WinPacketClone(packet);
PWIN_PACKET cloned3 = WinPacketClone(packet);
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET_RAW rawCloned1 = WinPacketToRawPacket(cloned1);
PWIN_PACKET_RAW rawCloned2 = WinPacketToRawPacket(cloned2);
PWIN_PACKET_RAW rawCloned3 = WinPacketToRawPacket(cloned3);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned1), rawPacket);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned2), rawPacket);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned3), rawPacket);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 3);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned1), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned2), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned3), 0);
Fake_WinPacketFree(cloned1);
Fake_WinPacketFree(cloned2);
Fake_WinPacketFree(cloned3);
Fake_WinPacketFree(packet);
}
static void
test_wd1(void **state)
{
struct state *st = (*state);
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<foo>41</foo><dllist>4</dllist>"
"</df>";
char *str;
struct lyd_difflist *diff;
st->first = NULL;
lyd_validate(&st->first, LYD_OPT_CONFIG, st->ctx);
assert_ptr_not_equal(st->first, NULL);
assert_ptr_not_equal((st->second = lyd_parse_mem(st->ctx, xml, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((diff = lyd_diff(st->first, st->second, LYD_DIFFOPT_WITHDEFAULTS)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_CHANGED);
assert_ptr_not_equal(diff->first[0], NULL);
assert_string_equal((str = lyd_path(diff->first[0])), "/defaults:df/foo");
assert_int_equal(((struct lyd_node_leaf_list*)diff->first[0])->value.int32, 42);
free(str);
assert_ptr_not_equal(diff->second[0], NULL);
assert_string_equal((str = lyd_path(diff->second[0])), "/defaults:df/foo");
assert_int_equal(((struct lyd_node_leaf_list*)diff->second[0])->value.int32, 41);
free(str);
assert_int_equal(diff->type[1], LYD_DIFF_DELETED);
assert_ptr_not_equal(diff->first[1], NULL);
assert_string_equal((str = lyd_path(diff->first[1])), "/defaults:df/dllist[.='1']");
free(str);
assert_ptr_equal(diff->second[1], NULL);
assert_int_equal(diff->type[2], LYD_DIFF_DELETED);
assert_ptr_not_equal(diff->first[2], NULL);
assert_string_equal((str = lyd_path(diff->first[2])), "/defaults:df/dllist[.='2']");
free(str);
assert_ptr_equal(diff->second[2], NULL);
assert_int_equal(diff->type[3], LYD_DIFF_DELETED);
assert_ptr_not_equal(diff->first[3], NULL);
assert_string_equal((str = lyd_path(diff->first[3])), "/defaults:df/dllist[.='3']");
free(str);
assert_ptr_equal(diff->second[3], NULL);
assert_int_equal(diff->type[4], LYD_DIFF_CREATED);
assert_ptr_not_equal(diff->first[4], NULL);
assert_string_equal((str = lyd_path(diff->first[4])), "/defaults:df");
free(str);
assert_ptr_not_equal(diff->second[4], NULL);
assert_string_equal((str = lyd_path(diff->second[4])), "/defaults:df/dllist[.='4']");
free(str);
assert_int_equal(diff->type[5], LYD_DIFF_END);
lyd_free_diff(diff);
}
static void
test_dup_to_ctx_leafrefs(void **state)
{
struct state *st = (*state);
const struct lys_module *mod;
const char *sch = "module x {"
" namespace urn:x;"
" prefix x;"
" container x {"
" leaf a { type string; }"
" leaf b { type leafref { path ../a; } } } }";
const char *data = "<x xmlns=\"urn:x\"><b>hello</b><a>hello</a></x>";
char *printed = NULL;
mod = lys_parse_mem(st->ctx1, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
mod = lys_parse_mem(st->ctx2, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
st->dt1 = lyd_parse_mem(st->ctx1, data, LYD_XML, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt1, NULL);
st->dt2 = lyd_dup_to_ctx(st->dt1, 1, st->ctx2);
assert_ptr_not_equal(st->dt2, NULL);
/* the result is not valid - the leafref is not resolved */
assert_int_not_equal(((struct lyd_node_leaf_list *)st->dt2->child)->value_type, LY_TYPE_LEAFREF);
assert_int_equal(lyd_validate(&st->dt2, LYD_OPT_CONFIG, st->ctx2), 0);
assert_ptr_equal(((struct lyd_node_leaf_list *)st->dt2->child)->value_type, LY_TYPE_LEAFREF);
/* the values are the same, but they are stored in different contexts */
assert_string_equal(((struct lyd_node_leaf_list *)st->dt1->child)->value_str,
((struct lyd_node_leaf_list *)st->dt2->child)->value_str);
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1->child)->value_str,
((struct lyd_node_leaf_list *)st->dt2->child)->value_str);
/* check the value data */
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1->child)->value.leafref,
((struct lyd_node_leaf_list *)st->dt2->child)->value.leafref);
/* and the schema nodes are the same, but comes from a different contexts */
assert_int_equal(st->dt1->child->schema->nodetype, st->dt2->child->schema->nodetype);
assert_string_equal(st->dt1->child->schema->name, st->dt2->child->schema->name);
assert_string_equal(st->dt1->child->schema->module->name, st->dt2->child->schema->module->name);
assert_ptr_equal(st->dt1->child->schema->module->ctx, st->ctx1);
assert_ptr_equal(st->dt2->child->schema->module->ctx, st->ctx2);
/* valgrind test - remove the first context and the access the duplicated data
* supposed to be in the second context */
lyd_free(st->dt1);
ly_ctx_destroy(st->ctx1, NULL);
st->dt1 = NULL;
st->ctx1 = NULL;
lyd_print_mem(&printed, st->dt2, LYD_XML, 0);
assert_string_equal(printed, data);
free(printed);
}
static void
test_dup_to_ctx_bits(void **state)
{
struct state *st = (*state);
const struct lys_module *mod;
const char *sch = "module x {"
" namespace urn:x;"
" prefix x;"
" typedef mybits { type bits {"
" bit disable;"
" bit enable; } }"
" leaf x { type mybits; }}";
const char *data = "<x xmlns=\"urn:x\">enable</x>";
char *printed = NULL;
mod = lys_parse_mem(st->ctx1, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
mod = lys_parse_mem(st->ctx2, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
st->dt1 = lyd_parse_mem(st->ctx1, data, LYD_XML, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt1, NULL);
st->dt2 = lyd_dup_to_ctx(st->dt1, 1, st->ctx2);
assert_ptr_not_equal(st->dt2, NULL);
/* the values are the same, but they are stored in different contexts */
assert_string_equal(((struct lyd_node_leaf_list *)st->dt1)->value_str,
((struct lyd_node_leaf_list *)st->dt2)->value_str);
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1)->value_str,
((struct lyd_node_leaf_list *)st->dt2)->value_str);
/* check the value data */
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1)->value.bit,
((struct lyd_node_leaf_list *)st->dt2)->value.bit);
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1)->value.bit[1],
((struct lyd_node_leaf_list *)st->dt2)->value.bit[1]);
/* first bit is not set, so the value pointer is NULL in both cases */
assert_ptr_equal(((struct lyd_node_leaf_list *)st->dt1)->value.bit[0], NULL);
assert_ptr_equal(((struct lyd_node_leaf_list *)st->dt2)->value.bit[0], NULL);
/* and the schema nodes are the same, but comes from a different contexts */
assert_int_equal(st->dt1->schema->nodetype, st->dt2->schema->nodetype);
assert_string_equal(st->dt1->schema->name, st->dt2->schema->name);
assert_string_equal(st->dt1->schema->module->name, st->dt2->schema->module->name);
assert_ptr_equal(st->dt1->schema->module->ctx, st->ctx1);
assert_ptr_equal(st->dt2->schema->module->ctx, st->ctx2);
/* valgrind test - remove the first context and the access the duplicated data
* supposed to be in the second context */
lyd_free(st->dt1);
ly_ctx_destroy(st->ctx1, NULL);
st->dt1 = NULL;
st->ctx1 = NULL;
lyd_print_mem(&printed, st->dt2, LYD_XML, 0);
assert_string_equal(printed, data);
free(printed);
}
static void
test_mix2(void **state)
{
struct state *st = (*state);
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<llist>1</llist>"
"<llist>2</llist>"
"<llist>3</llist>"
"</df>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<llist>4</llist>"
"<llist>3</llist>"
"<llist>1</llist>"
"</df>";
char *str;
struct lyd_difflist *diff;
assert_ptr_not_equal((st->first = lyd_parse_mem(st->ctx, xml1, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((st->second = lyd_parse_mem(st->ctx, xml2, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((diff = lyd_diff(st->first, st->second, 0)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_DELETED);
assert_ptr_not_equal(diff->first[0], NULL);
assert_string_equal((str = lyd_path(diff->first[0])), "/defaults:df/llist[.='2']");
free(str);
assert_ptr_equal(diff->second[0], NULL);
assert_int_equal(diff->type[1], LYD_DIFF_MOVEDAFTER1);
assert_ptr_not_equal(diff->first[1], NULL);
assert_string_equal((str = lyd_path(diff->first[1])), "/defaults:df/llist[.='1']");
free(str);
assert_ptr_not_equal(diff->second[1], NULL);
assert_string_equal((str = lyd_path(diff->second[1])), "/defaults:df/llist[.='3']");
free(str);
assert_int_equal(diff->type[2], LYD_DIFF_CREATED);
assert_ptr_not_equal(diff->first[2], NULL);
assert_string_equal((str = lyd_path(diff->first[2])), "/defaults:df");
free(str);
assert_ptr_not_equal(diff->second[2], NULL);
assert_string_equal((str = lyd_path(diff->second[2])), "/defaults:df/llist[.='4']");
free(str);
assert_int_equal(diff->type[3], LYD_DIFF_MOVEDAFTER2);
assert_ptr_equal(diff->first[3], NULL);
assert_ptr_not_equal(diff->second[3], NULL);
assert_string_equal((str = lyd_path(diff->second[3])), "/defaults:df/llist[.='4']");
free(str);
assert_int_equal(diff->type[4], LYD_DIFF_END);
lyd_free_diff(diff);
}
void foreignptr_test(void)
{
gc_t gc = saved_gc;
HsPtr **ptr = gc_new_foreignptr(PTR1);
assert_ptr_equal(PTR1, ptr[0]);
assert_ptr_equal(NULL, ptr[1]);
assert_true(gc_add_foreignptr_finalizer((sptr_t)ptr, PTR2));
assert_bit_mask_matches(get_heap_flags(ptr), SLAB_FLAG_FINALIZER);
assert_ptr_equal(PTR1, ptr[0]);
assert_true(!!ptr[1]);
assert_ptr_equal(ptr[1][0], PTR2);
arena_sanity(arena);
}
static void
test_insert_entry_no_response(void **state)
{
struct entry *e;
krb5_context context = *state;
krb5_data req = string2data("I'm a test request");
e = insert_entry(context, &req, NULL, 10);
assert_ptr_equal(k5_hashtab_get(hash_table, req.data, req.length), e);
assert_ptr_equal(K5_TAILQ_FIRST(&expiration_queue), e);
assert_true(data_eq(e->req_packet, req));
assert_int_equal(e->reply_packet.length, 0);
assert_int_equal(e->timein, 10);
}
static void
sr_new_values_test(void **state)
{
int rc = 0;
sr_val_t *values = NULL;
rc = sr_new_values(0, &values);
assert_int_equal(SR_ERR_OK, rc);
assert_null(values);
sr_free_values(values, 0);
rc = sr_new_values(10, &values);
assert_int_equal(SR_ERR_OK, rc);
assert_non_null(values);
#ifdef USE_SR_MEM_MGMT
assert_non_null(values->_sr_mem);
assert_int_equal(1, values->_sr_mem->obj_count);
assert_true(0 < values->_sr_mem->used_total);
#else
assert_null(values->_sr_mem);
#endif
for (int i = 0; i < 10; ++i) {
#ifdef USE_SR_MEM_MGMT
if (0 < i) {
assert_ptr_equal(values[i-1]._sr_mem, values[i]._sr_mem);
}
#endif
assert_null(values[i].xpath);
assert_false(values[i].dflt);
assert_int_equal(SR_UNKNOWN_T, values[i].type);
assert_int_equal(0, values[i].data.uint64_val);
}
sr_free_values(values, 10);
}
static void
test_lydict_remove(void **state)
{
(void) state; /* unused */
char *value = NULL, *value2;
const char *str;
value = strdup("new_name");
if (!value) {
fail();
}
value2 = strdup("new_name");
if (!value2) {
fail();
}
const char *string;
string = lydict_insert_zc(ctx, value); /* 1st instance */
if (!string) {
free(value);
fail();
}
assert_string_equal("new_name", string);
str = lydict_insert(ctx, "new_name", 0); /* 2nd instance */
assert_ptr_equal(str, string);
lydict_remove(ctx, string); /* remove 2nd instance */
lydict_remove(ctx, string); /* remove 1st instance */
/* string content is supposed to be invalid since now! */
str = lydict_insert_zc(ctx, value2);
assert_ptr_not_equal(str, NULL);
assert_ptr_not_equal(str, string);
lydict_remove(ctx, str);
}
static void OS_get_window_from_listOFwindow_void_window(void **state){
OS_t * new_OS = OS_create("Jupiter");
window_t * pwindow = window_createNew(new_OS, "TESTwindow", "test");
assert_ptr_equal(OS_get_window_from_listOFwindow(new_OS), pwindow);
window_free(pwindow);
OS_free(new_OS);
}
static void
test_dependency_autodel(void **state)
{
struct state *st = (struct state *)*state;
struct lyd_node *node;
/* schema */
st->mod = lys_parse_path(st->ctx, TESTS_DIR"/data/files/when-depend.yin", LYS_IN_YIN);
assert_ptr_not_equal(st->mod, NULL);
st->dt = lyd_new_path(NULL, st->ctx, "/when-depend:top/a", "val_a", 0, 0);
assert_ptr_not_equal(st->dt, NULL);
node = lyd_new_path(st->dt, st->ctx, "/when-depend:top/b", "val_b", 0, 0);
assert_ptr_not_equal(node, NULL);
node = lyd_new_path(st->dt, st->ctx, "/when-depend:top/d", "1", 0, 0);
assert_ptr_not_equal(node, NULL);
node = lyd_new_path(st->dt, st->ctx, "/when-depend:top/d", "2", 0, 0);
assert_ptr_not_equal(node, NULL);
node = lyd_new_path(st->dt, st->ctx, "/when-depend:top/e", "val_e", 0, 0);
assert_ptr_not_equal(node, NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG, NULL), 0);
assert_ptr_equal(st->dt, NULL);
}
static void
test_parse_print_oookeys_xml(void **state)
{
struct state *st = (*state);
const char *xmlin = "<cont1 xmlns=\"urn:all\">"
"<leaf3>-1</leaf3>"
"<list1><leaf18>aaa</leaf18></list1>"
"<list1><leaf19>123</leaf19><leaf18>bbb</leaf18></list1>"
"</cont1>";
const char *xmlout = "<cont1 xmlns=\"urn:all\">"
"<leaf3>-1</leaf3>"
"<list1><leaf18>aaa</leaf18></list1>"
"<list1><leaf18>bbb</leaf18><leaf19>123</leaf19></list1>"
"</cont1>";
st->dt = NULL;
/* with strict parsing, it is error since the key is not encoded as the first child */
st->dt = lyd_parse_mem(st->ctx, xmlin, LYD_XML, LYD_OPT_CONFIG | LYD_OPT_STRICT);
assert_ptr_equal(st->dt, NULL);
assert_int_equal(ly_vecode, LYVE_INORDER);
assert_string_equal(ly_errmsg(), "Invalid position of the key \"leaf18\" in a list \"list1\".");
/* without strict, it produces only warning, but the data are correctly loaded */
st->dt = lyd_parse_mem(st->ctx, xmlin, LYD_XML, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_print_mem(&st->str1, st->dt, LYD_XML, 0), 0);
assert_string_equal(st->str1, xmlout);
}
static void
test_request_credentials_calls_drpc_call(void **state)
{
daos_iov_t creds;
memset(&creds, 0, sizeof(daos_iov_t));
dc_sec_request_creds(&creds);
/* Used the drpc conn that we previously connected to */
assert_ptr_equal(drpc_call_ctx, drpc_connect_return);
assert_int_equal(drpc_call_flags, R_SYNC); /* Synchronous */
assert_non_null(drpc_call_resp_ptr); /* Passed valid ptr for response */
assert_non_null(drpc_call_msg_ptr); /* Sent an RPC message */
/* Check if RPC message is properly initialized */
assert_true(drpc_call_msg_content.base.descriptor ==
&drpc__call__descriptor);
/* Make sure it's the correct method call */
assert_int_equal(drpc_call_msg_content.module,
DRPC_MODULE_SECURITY_AGENT);
assert_int_equal(drpc_call_msg_content.method,
DRPC_METHOD_SECURITY_AGENT_REQUEST_CREDENTIALS);
/* Check that the body has no content */
assert_int_equal(drpc_call_msg_content.body.len, 0);
daos_iov_free(&creds);
}
static void
test_kdc_remove_lookaside_multiple(void **state)
{
struct entry *e1;
krb5_context context = *state;
krb5_data req1 = string2data("I'm a test request");
krb5_data rep1 = string2data("I'm a test response");
krb5_data req2 = string2data("I'm a different test request");
e1 = insert_entry(context, &req1, &rep1, 0);
insert_entry(context, &req2, NULL, 0);
kdc_remove_lookaside(context, &req2);
assert_null(k5_hashtab_get(hash_table, req2.data, req2.length));
assert_ptr_equal(k5_hashtab_get(hash_table, req1.data, req1.length), e1);
assert_int_equal(num_entries, 1);
assert_int_equal(total_size, entry_size(&req1, &rep1));
kdc_remove_lookaside(context, &req1);
assert_null(k5_hashtab_get(hash_table, req1.data, req1.length));
assert_int_equal(num_entries, 0);
assert_int_equal(total_size, 0);
}
static void OS_set_new_window_in_listOFwindow_new_window_listOFwindow(void **state){
OS_t * new_OS = OS_create("Jupiter");
window_t * pwindow1 = window_createNew(new_OS, "TESTwindow", "test");
window_t * pwindow2 = OS_get_window_from_listOFwindow(new_OS);
assert_ptr_equal(pwindow1, pwindow2);
window_free(pwindow1);
OS_free(new_OS);
}
static void
test_invalid(void **state)
{
struct state *st = (*state);
st->set = lyd_find_xpath(st->dt, "/:interface/name");
assert_ptr_equal(st->set, NULL);
assert_int_not_equal(ly_errno, 0);
st->set = lyd_find_xpath(st->dt, "/interface/name[./]");
assert_ptr_equal(st->set, NULL);
assert_int_not_equal(ly_errno, 0);
st->set = lyd_find_xpath(st->dt, "/interface/name[./.]()");
assert_ptr_equal(st->set, NULL);
assert_int_not_equal(ly_errno, 0);
}
struct nc_server_reply *
my_get_rpc_clb(struct lyd_node *rpc, struct nc_session *session)
{
assert_string_equal(rpc->schema->name, "get");
assert_ptr_equal(session, server_session);
return nc_server_reply_ok();
}
static void
test_dup_to_ctx(void **state)
{
struct state *st = (*state);
const struct lys_module *mod;
const char *sch = "module x {"
" namespace urn:x;"
" prefix x;"
" leaf x { type string; }}";
const char *data = "<x xmlns=\"urn:x\">hello</x>";
/* case 1 - schema is only in the first context, duplicating data into the second context is supposed to
* fail because of missing schema */
mod = lys_parse_mem(st->ctx1, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
st->dt1 = lyd_parse_mem(st->ctx1, data, LYD_XML, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt1, NULL);
st->dt2 = lyd_dup_to_ctx(st->dt1, 1, st->ctx2);
assert_ptr_equal(st->dt2, NULL);
assert_int_equal(ly_errno, LY_EINVAL);
assert_string_equal(ly_errmsg(st->ctx2),
"Target context does not contain schema node for the data node being duplicated (x:x).");
/* case 2 - with the schema present in both contexts, duplication should succeed */
mod = lys_parse_mem(st->ctx2, sch, LYS_IN_YANG);
assert_ptr_not_equal(mod, NULL);
st->dt2 = lyd_dup_to_ctx(st->dt1, 1, st->ctx2);
assert_ptr_not_equal(st->dt2, NULL);
/* the values are the same, but they are stored in different contexts */
assert_string_equal(((struct lyd_node_leaf_list *)st->dt1)->value_str,
((struct lyd_node_leaf_list *)st->dt2)->value_str);
assert_ptr_not_equal(((struct lyd_node_leaf_list *)st->dt1)->value_str,
((struct lyd_node_leaf_list *)st->dt2)->value_str);
/* and the schema nodes are the same, but comes from a different contexts */
assert_int_equal(st->dt1->schema->nodetype, st->dt2->schema->nodetype);
assert_string_equal(st->dt1->schema->name, st->dt2->schema->name);
assert_string_equal(st->dt1->schema->module->name, st->dt2->schema->module->name);
assert_ptr_equal(st->dt1->schema->module->ctx, st->ctx1);
assert_ptr_equal(st->dt2->schema->module->ctx, st->ctx2);
}
void test_List_Remove(void **state)
{
struct list_node_t nodes[3];
struct list_t list = List_New(1);
List_Append(&list, &nodes[0]);
List_Append(&list, &nodes[1]);
List_Append(&list, &nodes[2]);
/* Try to remove a node not in the list. */
List_Remove(&list, &nodes[3]);
assert_ptr_equal(list.root, &nodes[0]);
assert_ptr_equal(nodes[0].next, &nodes[1]);
assert_ptr_equal(nodes[1].next, &nodes[2]);
List_Remove(&list, &nodes[1]);
assert_ptr_equal(list.root, &nodes[0]);
assert_ptr_equal(nodes[0].next, &nodes[2]);
List_Remove(&list, &nodes[0]);
assert_ptr_equal(list.root, &nodes[2]);
List_Remove(&list, &nodes[2]);
assert_null(list.root);
}
static void
test_circular_include(void **state)
{
struct ly_ctx *ctx = *state;
const char *sch_yang = "module main-mod {"
"namespace \"urn:cesnet:test:a\";"
"prefix \"a\";"
"include circ_inc1;}";
const char *sch_yin = "<module name=\"main-mod\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
"<namespace uri=\"urn:cesnet:test:a\"/><prefix value=\"a\"/>"
"<include module=\"circ_inc1\"/></module>";
ly_ctx_set_searchdir(ctx, SCHEMA_FOLDER_YIN);
assert_ptr_equal(lys_parse_mem(ctx, sch_yin, LYS_IN_YIN), NULL);
assert_int_equal(ly_vecode, LYVE_CIRC_INCLUDES);
ly_ctx_set_searchdir(ctx, SCHEMA_FOLDER_YANG);
assert_ptr_equal(lys_parse_mem(ctx, sch_yang, LYS_IN_YANG), NULL);
assert_int_equal(ly_vecode, LYVE_CIRC_INCLUDES);
}
static void
test_request_credentials_closes_socket_when_call_ok(void **state)
{
daos_iov_t creds;
memset(&creds, 0, sizeof(daos_iov_t));
dc_sec_request_creds(&creds);
assert_ptr_equal(drpc_close_ctx, drpc_connect_return);
daos_iov_free(&creds);
}
static void
test_gf_mem_set_acct_info_memory(void **state)
{
xlator_t *xl;
char *alloc_ptr;
char *temp_ptr;
size_t size;
uint32_t type;
const char *typestr = "TEST";
size = 8196;
type = 9;
// Initialize xl
xl = helper_xlator_init(10);
assert_null(xl->mem_acct.rec[type].typestr);
// Test allocation
temp_ptr = test_calloc(1, size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE);
assert_non_null(temp_ptr);
alloc_ptr = temp_ptr;
gf_mem_set_acct_info(xl, &alloc_ptr, size, type, typestr);
//Check values
assert_ptr_equal(typestr, xl->mem_acct.rec[type].typestr);
assert_int_equal(xl->mem_acct.rec[type].size, size);
assert_int_equal(xl->mem_acct.rec[type].num_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].total_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].max_size, size);
assert_int_equal(xl->mem_acct.rec[type].max_num_allocs, 1);
// Check memory
helper_check_memory_headers(temp_ptr, xl, size, type);
// Check that alloc_ptr has been moved correctly
// by gf_mem_set_acct_info
{
mem_header_t *p;
p = (mem_header_t *)temp_ptr;
p++;
p->type = 1234;
assert_int_equal(*(uint32_t *)alloc_ptr, p->type);
}
free(temp_ptr);
helper_xlator_destroy(xl);
}
static void test_insertTop(void **state)
{
const int a = 1001;
LinkedList *list = createList();
assert_non_null(list);
assert_false(insertTop(NULL, NULL));
int b = 0;
assert_false(insertTop(NULL, &b));
for (int i = 0; i < a; i++)
{
int *c = malloc(sizeof(int));
assert_true(insertTop(list, c));
assert_ptr_equal(list->head->data, c);
}
destroyList(list);
}
static void
test_diff2(void **state)
{
struct state *st = (*state);
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<list><name>a</name><value>1</value></list>"
"<list><name>b</name><value>2</value></list>"
"</df>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<list><name>b</name><value>-2</value></list>"
"<list><name>c</name><value>3</value></list>"
"</df>";
char *str;
struct lyd_difflist *diff;
assert_ptr_not_equal((st->first = lyd_parse_mem(st->ctx, xml1, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((st->second = lyd_parse_mem(st->ctx, xml2, LYD_XML, LYD_OPT_CONFIG)), NULL);
assert_ptr_not_equal((diff = lyd_diff(st->first, st->second, 0)), NULL);
assert_ptr_not_equal(diff->type, NULL);
assert_int_equal(diff->type[0], LYD_DIFF_CHANGED);
assert_ptr_not_equal(diff->first[0], NULL);
assert_string_equal((str = lyd_path(diff->first[0])), "/defaults:df/list[name=\'b\']/value");
free(str);
assert_ptr_not_equal(diff->second[0], NULL);
assert_string_equal((str = lyd_path(diff->second[0])), "/defaults:df/list[name=\'b\']/value");
free(str);
assert_int_equal(diff->type[1], LYD_DIFF_DELETED);
assert_ptr_not_equal(diff->first[1], NULL);
assert_string_equal((str = lyd_path(diff->first[1])), "/defaults:df/list[name=\'a\']");
free(str);
assert_ptr_equal(diff->second[1], NULL);
assert_int_equal(diff->type[2], LYD_DIFF_CREATED);
assert_ptr_not_equal(diff->first[2], NULL);
assert_string_equal((str = lyd_path(diff->first[2])), "/defaults:df");
free(str);
assert_ptr_not_equal(diff->second[2], NULL);
assert_string_equal((str = lyd_path(diff->second[2])), "/defaults:df/list[name=\'c\']");
free(str);
assert_int_equal(diff->type[3], LYD_DIFF_END);
lyd_free_diff(diff);
}
struct nc_server_reply *
my_getconfig_rpc_clb(struct lyd_node *rpc, struct nc_session *session)
{
struct lyd_node *data;
const struct lys_module *module;
assert_string_equal(rpc->schema->name, "get-config");
assert_ptr_equal(session, server_session);
module = ly_ctx_get_module(session->ctx, "ietf-netconf-acm", NULL);
assert_non_null(module);
data = lyd_new(NULL, module, "nacm");
assert_non_null(data);
return nc_server_reply_data(data, NC_PARAMTYPE_FREE);
}
