static void
test_df4(void **state)
{
struct state *st = (*state);
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<b1_2>x</b1_2><foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<b2>1</b2><foo ncwd:default=\"true\">42</foo>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
const char *xml3 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<s2a>1</s2a><foo ncwd:default=\"true\">42</foo>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* select2 - s2a */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "s2a", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml3);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select2 - s2b - b2 */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "b2", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml2);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select2 - s2b - b1 */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "b1_2", "x"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml1);
}
static void
test_df2(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<list><name>a</name><value>42</value></list>"
"<list><name>b</name><value>1</value></list>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* lists */
assert_ptr_not_equal(lyd_new_path(st->dt, NULL, "/defaults:df/defaults:list[name='a']", NULL, 0), NULL);
assert_ptr_not_equal((node = lyd_new_path(st->dt, NULL, "/defaults:df/defaults:list[name='b']", NULL, 0)), NULL);
assert_ptr_not_equal(lyd_new_leaf(node, NULL, "value", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
static void
test_empty_tag(void **state)
{
struct state *st = (*state);
const char *xml = "<nacm xmlns=\"urn:ietf:params:xml:ns:yang:ietf-netconf-acm\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<enable-nacm ncwd:default=\"true\">true</enable-nacm>"
"<read-default ncwd:default=\"true\">permit</read-default>"
"<write-default ncwd:default=\"true\">deny</write-default>"
"<exec-default ncwd:default=\"true\">permit</exec-default>"
"<enable-external-groups ncwd:default=\"true\">true</enable-external-groups>"
"</nacm><df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><b1_1 ncwd:default=\"true\">42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
lyd_wd_add(st->ctx, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
static void
test_df1(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<bar><ho>1</ho><hi>42</hi></bar>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* presence container */
assert_ptr_not_equal((node = lyd_new(st->dt, NULL, "bar")), NULL);
assert_int_not_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_string_equal(ly_errmsg(), "Missing required element \"ho\" in \"bar\".");
/* manadatory node in bar */
assert_ptr_not_equal(lyd_new_leaf(node, NULL, "ho", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
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_status(void **state)
{
struct state *st = (*state);
const char *xml_min = "<modules-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">"
"<module-set-id>5</module-set-id>"
"</modules-state><nacm xmlns=\"urn:ietf:params:xml:ns:yang:ietf-netconf-acm\">"
"<denied-operations>0</denied-operations>"
"<denied-data-writes>0</denied-data-writes>"
"<denied-notifications>0</denied-notifications>"
"</nacm>";
const char *xml = "<modules-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">"
"<module-set-id>5</module-set-id>"
"</modules-state><nacm xmlns=\"urn:ietf:params:xml:ns:yang:ietf-netconf-acm\">"
"<denied-operations>0</denied-operations>"
"<denied-data-writes>0</denied-data-writes>"
"<denied-notifications>0</denied-notifications>"
"</nacm><df xmlns=\"urn:libyang:tests:defaults\">"
"<b1_status>42</b1_status>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<papa>42</papa></hidden>";
assert_ptr_not_equal((st->dt = lyd_parse_mem(st->ctx, xml_min, LYD_XML, LYD_OPT_DATA | LYD_WD_EXPLICIT)), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_DATA, st->ctx), 0);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
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_df3(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<a1>1</a1>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<c><x ncwd:default=\"true\">42</x></c>"
"<foo ncwd:default=\"true\">42</foo><b1_1 ncwd:default=\"true\">42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* select - c */
assert_ptr_not_equal((node = lyd_new(st->dt, NULL, "c")), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml2);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select - a */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "a1", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml1);
}
static void
test_parse_print_oookeys_json(void **state)
{
struct state *st = (*state);
const char *in = "{\"all:cont1\":{\"leaf3\":-1,\"list1\":[{\"leaf18\":\"a\"},{\"leaf19\":123,\"leaf18\":\"b\"}]}}";
const char *out = "{\"all:cont1\":{\"leaf3\":-1,\"list1\":[{\"leaf18\":\"a\"},{\"leaf18\":\"b\",\"leaf19\":123}]}}";
st->dt = NULL;
/* in JSON, ordering does not matter, so it will succeed even with strict */
st->dt = lyd_parse_mem(st->ctx, in, LYD_JSON, LYD_OPT_CONFIG | LYD_OPT_STRICT);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_print_mem(&st->str1, st->dt, LYD_JSON, 0), 0);
assert_string_equal(st->str1, out);
}
static void
test_unlink_choice(void **state)
{
struct state *st = (struct state *)*state;
/* schema */
st->mod = lys_parse_path(st->ctx, TESTS_DIR"/data/files/when-unlink.yin", LYS_IN_YIN);
assert_ptr_not_equal(st->mod, NULL);
st->dt = lyd_new_path(NULL, st->ctx, "/when-unlink:top/cas2", NULL, 0, 0);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG, NULL), 0);
lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS);
assert_string_equal(st->xml, "<top xmlns=\"urn:libyang:tests:when-unlink\"><cas2/></top>");
}
static void
test_feature(void **state)
{
struct state *st = (*state);
const char *xml = "<nacm xmlns=\"urn:ietf:params:xml:ns:yang:ietf-netconf-acm\">"
"<enable-nacm>true</enable-nacm>"
"<read-default>permit</read-default>"
"<write-default>deny</write-default>"
"<exec-default>permit</exec-default>"
"<enable-external-groups>true</enable-external-groups>"
"</nacm><hiddenleaf xmlns=\"urn:libyang:tests:defaults\">42"
"</hiddenleaf><df xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><hiddenleaf>42</hiddenleaf><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
assert_int_equal(lys_features_enable(st->mod, "unhide"), 0);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL, st->ctx), 0);
assert_ptr_not_equal(st->dt, NULL);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
static void
TEST_RPC_OUTPUT(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;
const int data_compare_fail[] = {TEST_DATA_COMPARE_FAIL};
const char *data_compare_string[] = {TEST_DATA_COMPARE};
const char *data_rpc_name[] = {TEST_RPC_NODE};
struct lyd_node *rpc;
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/" TEST_DIR "/data%d.xml", j + 1);
rpc = lyd_new(NULL, mod, data_rpc_name[j]);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_RPCREPLY, rpc, NULL);
lyd_free(rpc);
if (data_files_fail[j]) {
assert_ptr_equal(st->node, NULL);
} else {
assert_ptr_not_equal(st->node, NULL);
lyd_print_mem(&st->s, st->node, LYD_XML, LYP_WITHSIBLINGS | LYP_FORMAT | LYP_WD_ALL);
if (data_compare_fail[j]) {
assert_ptr_equal(strstr(st->s, data_compare_string[j]), NULL);
} else {
assert_ptr_not_equal(strstr(st->s, data_compare_string[j]), NULL);
}
free(st->s);
st->s = NULL;
}
lyd_free_withsiblings(st->node);
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_multdfltvalues_yin(void **state)
{
struct ly_ctx *ctx = *state;
struct lyd_node *root;
const char *yin_cfg = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <yang-version value=\"1.1\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *yin_status_10 = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <config value=\"false\"/>"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *yin_status = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <yang-version value=\"1.1\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <config value=\"false\"/>"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *xml = "<x xmlns=\"urn:x\"><ll>a</ll><ll>a</ll></x>";
char *printed;
/* only config leaflists must be unique, so in case of default data
* the same value can be specified as default multiple times */
assert_ptr_equal(lys_parse_mem(ctx, yin_cfg, LYS_IN_YIN), NULL);
assert_ptr_equal(lys_parse_mem(ctx, yin_status_10, LYS_IN_YIN), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, yin_status, LYS_IN_YIN), NULL);
/* for validating complete data tree, we need data from ietf-yang-library */
root = ly_ctx_info(ctx);
assert_int_equal(lyd_validate(&root, LYD_OPT_DATA, ctx), 0);
assert_ptr_not_equal(root, NULL); /* ietf-yang-library */
assert_ptr_not_equal(root->next, NULL); /* added default nodes from module x */
lyd_print_mem(&printed, root->prev, LYD_XML, LYP_WD_ALL); /* print only the default nodes from module x */
assert_string_equal(printed, xml);
free(printed);
lyd_free_withsiblings(root);
}
static void
test_multdfltvalues_yang(void **state)
{
struct ly_ctx *ctx = *state;
struct lyd_node *root;
const char *yang_cfg = "module x {"
" namespace urn:x;"
" prefix x;"
" yang-version 1.1;"
" container x {"
" leaf-list ll {"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *yang_status_10 = "module x {"
" namespace urn:x;"
" prefix x;"
" container x {"
" leaf-list ll {"
" config false;"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *yang_status = "module x {"
" namespace urn:x;"
" prefix x;"
" yang-version 1.1;"
" container x {"
" leaf-list ll {"
" config false;"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *xml = "<x xmlns=\"urn:x\"><ll>a</ll><ll>a</ll></x>";
char *printed;
/* only config leaflists must be unique, so in case of default data
* the same value can be specified as default multiple times */
assert_ptr_equal(lys_parse_mem(ctx, yang_cfg, LYS_IN_YANG), NULL);
assert_ptr_equal(lys_parse_mem(ctx, yang_status_10, LYS_IN_YANG), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, yang_status, LYS_IN_YANG), NULL);
/* for validating complete data tree, we need data from ietf-yang-library */
root = ly_ctx_info(ctx);
assert_int_equal(lyd_validate(&root, LYD_OPT_DATA, ctx), 0);
assert_ptr_not_equal(root, NULL); /* ietf-yang-library */
assert_ptr_not_equal(root->next, NULL); /* added default nodes from module x */
lyd_print_mem(&printed, root->prev, LYD_XML, LYP_WD_ALL); /* print only the default nodes from module x */
assert_string_equal(printed, xml);
free(printed);
lyd_free_withsiblings(root);
}
static void
test_parse_print_json(void **state)
{
struct state *st = (*state);
struct stat s;
const struct lys_node *rpc_schema;
int fd;
const char *data = TESTS_DIR"/data/files/all-data.json";
const char *rpc = TESTS_DIR"/data/files/all-rpc.json";
const char *rpcreply = TESTS_DIR"/data/files/all-rpcreply.json";
const char *act = TESTS_DIR"/data/files/all-act.json";
const char *actreply = TESTS_DIR"/data/files/all-actreply.json";
const char *notif = TESTS_DIR"/data/files/all-notif.json";
const char *innotif = TESTS_DIR"/data/files/all-innotif.json";
/* data */
fd = open(data, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, data, LYD_JSON, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
/* rpc */
fd = open(rpc, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->rpc_act = lyd_parse_path(st->ctx, rpc, LYD_JSON, LYD_OPT_RPC, NULL);
assert_ptr_not_equal(st->rpc_act, NULL);
lyd_print_mem(&(st->str2), st->rpc_act, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
/* rpcreply */
fd = open(rpcreply, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
rpc_schema = ly_ctx_get_node(st->ctx, NULL, "/all:rpc1");
assert_ptr_not_equal(rpc_schema, NULL);
assert_int_equal(rpc_schema->nodetype, LYS_RPC);
st->dt = lyd_parse_path(st->ctx, rpcreply, LYD_JSON, LYD_OPT_RPCREPLY, st->rpc_act, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
lyd_free(st->rpc_act);
st->rpc_act = NULL;
/* act */
fd = open(act, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->rpc_act = lyd_parse_path(st->ctx, act, LYD_JSON, LYD_OPT_RPC, NULL);
assert_ptr_not_equal(st->rpc_act, NULL);
lyd_print_mem(&(st->str2), st->rpc_act, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
/* actreply */
fd = open(actreply, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
rpc_schema = ly_ctx_get_node(st->ctx, NULL, "/all:cont1/list1/act1");
assert_ptr_not_equal(rpc_schema, NULL);
assert_int_equal(rpc_schema->nodetype, LYS_ACTION);
st->dt = lyd_parse_path(st->ctx, actreply, LYD_JSON, LYD_OPT_RPCREPLY, st->rpc_act, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
lyd_free(st->rpc_act);
st->rpc_act = NULL;
/* notif */
fd = open(notif, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, notif, LYD_JSON, LYD_OPT_NOTIF, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
/* inline notif */
fd = open(innotif, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, innotif, LYD_JSON, LYD_OPT_NOTIF, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
}
