utests data REFACTOR put repetitive commands into macros
diff --git a/tests/utests/data/test_diff.c b/tests/utests/data/test_diff.c
index 84b1ac1..6964764 100644
--- a/tests/utests/data/test_diff.c
+++ b/tests/utests/data/test_diff.c
@@ -12,238 +12,245 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
-
-#include "libyang.h"
-#include "tests/config.h"
+#define _UTEST_MAIN_
#include "utests.h"
-struct state {
- struct ly_ctx *ctx;
- struct lyd_node *first;
- struct lyd_node *second;
- struct lyd_node *third;
- struct lyd_node *diff1;
- struct lyd_node *diff2;
- char *xml;
- char *xml1;
- char *xml2;
-};
+#include "libyang.h"
+
+#define CHECK_PARSE_LYD(INPUT, MODEL) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, MODEL)
+
+#define CHECK_LYD_STRING(IN_MODEL, TEXT) \
+ CHECK_LYD_STRING_PARAM(IN_MODEL, TEXT, LYD_XML, LYD_PRINT_WITHSIBLINGS)
+
+#define CHECK_PARSE_LYD_DIFF(INPUT_1, INPUT_2, OUT_MODEL) \
+ assert_int_equal(LY_SUCCESS, lyd_diff_siblings(INPUT_1, INPUT_2, 0, &OUT_MODEL));\
+ assert_non_null(OUT_MODEL)
+
+#define TEST_DIFF_3(XML_1, XML_2, XML_3, DIFF_1, DIFF_2, MERGE) \
+ { \
+ /*decladation*/\
+ struct lyd_node *model_1;\
+ struct lyd_node *model_2;\
+ struct lyd_node *model_3;\
+ /*create*/\
+ CHECK_PARSE_LYD(XML_1, model_1);\
+ CHECK_PARSE_LYD(XML_2, model_2);\
+ CHECK_PARSE_LYD(XML_3, model_3);\
+ /* diff1 */ \
+ struct lyd_node * diff1;\
+ CHECK_PARSE_LYD_DIFF(model_1, model_2, diff1); \
+ CHECK_LYD_STRING(diff1, DIFF_1); \
+ assert_int_equal(lyd_diff_apply_all(&model_1, diff1), LY_SUCCESS); \
+ CHECK_LYD(model_1, model_2); \
+ /* diff2 */ \
+ struct lyd_node * diff2;\
+ CHECK_PARSE_LYD_DIFF(model_2, model_3, diff2); \
+ CHECK_LYD_STRING(diff2, DIFF_2); \
+ assert_int_equal(lyd_diff_apply_all(&model_2, diff2), LY_SUCCESS);\
+ CHECK_LYD(model_2, model_3);\
+ /* merge */ \
+ assert_int_equal(lyd_diff_merge_all(&diff1, diff2, 0), LY_SUCCESS);\
+ CHECK_LYD_STRING(diff1, MERGE); \
+ /* CREAR ENV */ \
+ lyd_free_all(model_1);\
+ lyd_free_all(model_2);\
+ lyd_free_all(model_3);\
+ lyd_free_all(diff1);\
+ lyd_free_all(diff2);\
+ }
+
+const char *schema =
+ "module defaults {\n"
+ " yang-version 1.1;\n"
+ " namespace \"urn:libyang:tests:defaults\";\n"
+ " prefix df;\n"
+ "\n"
+ " feature unhide;\n"
+ "\n"
+ " typedef defint32 {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf hiddenleaf {\n"
+ " if-feature \"unhide\";\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " container df {\n"
+ " leaf foo {\n"
+ " type defint32;\n"
+ " }\n"
+ "\n"
+ " leaf hiddenleaf {\n"
+ " if-feature \"unhide\";\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " container bar {\n"
+ " presence \"\";\n"
+ " leaf hi {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf ho {\n"
+ " type int32;\n"
+ " mandatory true;\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " leaf-list llist {\n"
+ " type defint32;\n"
+ " ordered-by user;\n"
+ " }\n"
+ "\n"
+ " leaf-list dllist {\n"
+ " type uint8;\n"
+ " default \"1\";\n"
+ " default \"2\";\n"
+ " default \"3\";\n"
+ " }\n"
+ "\n"
+ " list list {\n"
+ " key \"name\";\n"
+ " leaf name {\n"
+ " type string;\n"
+ " }\n"
+ "\n"
+ " leaf value {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " choice select {\n"
+ " default \"a\";\n"
+ " case a {\n"
+ " choice a {\n"
+ " leaf a1 {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf a2 {\n"
+ " type int32;\n"
+ " default \"24\";\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " leaf b {\n"
+ " type string;\n"
+ " }\n"
+ "\n"
+ " container c {\n"
+ " presence \"\";\n"
+ " leaf x {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " choice select2 {\n"
+ " default \"s2b\";\n"
+ " leaf s2a {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " case s2b {\n"
+ " choice s2b {\n"
+ " default \"b1\";\n"
+ " case b1 {\n"
+ " leaf b1_1 {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf b1_2 {\n"
+ " type string;\n"
+ " }\n"
+ "\n"
+ " leaf b1_status {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " config false;\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " leaf b2 {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " container hidden {\n"
+ " leaf foo {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf baz {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " }\n"
+ "\n"
+ " leaf papa {\n"
+ " type int32;\n"
+ " default \"42\";\n"
+ " config false;\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " rpc rpc1 {\n"
+ " input {\n"
+ " leaf inleaf1 {\n"
+ " type string;\n"
+ " }\n"
+ "\n"
+ " leaf inleaf2 {\n"
+ " type string;\n"
+ " default \"def1\";\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " output {\n"
+ " leaf outleaf1 {\n"
+ " type string;\n"
+ " default \"def2\";\n"
+ " }\n"
+ "\n"
+ " leaf outleaf2 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " notification notif {\n"
+ " leaf ntfleaf1 {\n"
+ " type string;\n"
+ " default \"def3\";\n"
+ " }\n"
+ "\n"
+ " leaf ntfleaf2 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ "}\n";
static int
-setup_f(void **state)
+setup(void **state)
{
- struct state *st;
- const char *schema =
- "module defaults {\n"
- " yang-version 1.1;\n"
- " namespace \"urn:libyang:tests:defaults\";\n"
- " prefix df;\n"
- "\n"
- " feature unhide;\n"
- "\n"
- " typedef defint32 {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf hiddenleaf {\n"
- " if-feature \"unhide\";\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " container df {\n"
- " leaf foo {\n"
- " type defint32;\n"
- " }\n"
- "\n"
- " leaf hiddenleaf {\n"
- " if-feature \"unhide\";\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " container bar {\n"
- " presence \"\";\n"
- " leaf hi {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf ho {\n"
- " type int32;\n"
- " mandatory true;\n"
- " }\n"
- " }\n"
- "\n"
- " leaf-list llist {\n"
- " type defint32;\n"
- " ordered-by user;\n"
- " }\n"
- "\n"
- " leaf-list dllist {\n"
- " type uint8;\n"
- " default \"1\";\n"
- " default \"2\";\n"
- " default \"3\";\n"
- " }\n"
- "\n"
- " list list {\n"
- " key \"name\";\n"
- " leaf name {\n"
- " type string;\n"
- " }\n"
- "\n"
- " leaf value {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- " }\n"
- "\n"
- " choice select {\n"
- " default \"a\";\n"
- " case a {\n"
- " choice a {\n"
- " leaf a1 {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf a2 {\n"
- " type int32;\n"
- " default \"24\";\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " leaf b {\n"
- " type string;\n"
- " }\n"
- "\n"
- " container c {\n"
- " presence \"\";\n"
- " leaf x {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " choice select2 {\n"
- " default \"s2b\";\n"
- " leaf s2a {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " case s2b {\n"
- " choice s2b {\n"
- " default \"b1\";\n"
- " case b1 {\n"
- " leaf b1_1 {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf b1_2 {\n"
- " type string;\n"
- " }\n"
- "\n"
- " leaf b1_status {\n"
- " type int32;\n"
- " default \"42\";\n"
- " config false;\n"
- " }\n"
- " }\n"
- "\n"
- " leaf b2 {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- " }\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " container hidden {\n"
- " leaf foo {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf baz {\n"
- " type int32;\n"
- " default \"42\";\n"
- " }\n"
- "\n"
- " leaf papa {\n"
- " type int32;\n"
- " default \"42\";\n"
- " config false;\n"
- " }\n"
- " }\n"
- "\n"
- " rpc rpc1 {\n"
- " input {\n"
- " leaf inleaf1 {\n"
- " type string;\n"
- " }\n"
- "\n"
- " leaf inleaf2 {\n"
- " type string;\n"
- " default \"def1\";\n"
- " }\n"
- " }\n"
- "\n"
- " output {\n"
- " leaf outleaf1 {\n"
- " type string;\n"
- " default \"def2\";\n"
- " }\n"
- "\n"
- " leaf outleaf2 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " notification notif {\n"
- " leaf ntfleaf1 {\n"
- " type string;\n"
- " default \"def3\";\n"
- " }\n"
- "\n"
- " leaf ntfleaf2 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- "}\n";
-
- (*state) = st = calloc(1, sizeof *st);
- assert_non_null(st);
- assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &st->ctx));
- assert_non_null(ly_ctx_load_module(st->ctx, "ietf-netconf-acm", "2018-02-14", NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, schema, LYS_IN_YANG, NULL));
-
- return 0;
-}
-
-static int
-teardown_f(void **state)
-{
- struct state *st = (*state);
-
- lyd_free_siblings(st->first);
- lyd_free_siblings(st->second);
- lyd_free_siblings(st->third);
- lyd_free_siblings(st->diff1);
- lyd_free_siblings(st->diff2);
- ly_ctx_destroy(st->ctx, NULL);
- free(st->xml);
- free(st->xml1);
- free(st->xml2);
- free(st);
- (*state) = NULL;
+ UTEST_SETUP;
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
return 0;
}
@@ -251,22 +258,26 @@
static void
test_invalid(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\"><foo>42</foo></df>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- st->second = NULL;
+ struct lyd_node *model_1;
- assert_int_equal(lyd_diff_siblings(st->first, lyd_child(st->first), 0, &st->diff1), LY_EINVAL);
+ CHECK_PARSE_LYD(xml, model_1);
+ struct lyd_node *diff = NULL;
+
+ assert_int_equal(lyd_diff_siblings(model_1, lyd_child(model_1), 0, &diff), LY_EINVAL);
assert_int_equal(lyd_diff_siblings(NULL, NULL, 0, NULL), LY_EINVAL);
+
+ lyd_free_all(model_1);
+ lyd_free_all(diff);
}
static void
test_same(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml =
"<nacm xmlns=\"urn:ietf:params:xml:ns:yang:ietf-netconf-acm\">\n"
" <enable-nacm>true</enable-nacm>\n"
@@ -279,25 +290,32 @@
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>42</foo><baz>42</baz></hidden>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
+ struct lyd_node *model_1;
+ struct lyd_node *model_2;
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
- assert_null(st->diff1);
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf-acm", "2018-02-14", NULL));
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
+ CHECK_PARSE_LYD(xml, model_1);
+ CHECK_PARSE_LYD(xml, model_2);
+
+ struct lyd_node *diff = NULL;
+
+ assert_int_equal(lyd_diff_siblings(model_1, model_2, 0, &diff), LY_SUCCESS);
+ assert_null(diff);
+ assert_int_equal(lyd_diff_apply_all(&model_1, diff), LY_SUCCESS);
+ CHECK_LYD(model_1, model_2);
+
+ lyd_free_all(model_1);
+ lyd_free_all(model_2);
+ lyd_free_all(diff);
}
static void
test_empty1(void **state)
{
- struct state *st = (*state);
- const char *xml =
+ (void) state;
+ const char *xml_in =
"<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>42</foo>\n"
" <b1_1>42</b1_1>\n"
@@ -307,15 +325,15 @@
" <baz>42</baz>\n"
"</hidden>\n";
- st->first = NULL;
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
+ struct lyd_node *model_1 = NULL;
+ struct lyd_node *model_2;
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
+ CHECK_PARSE_LYD(xml_in, model_2);
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ struct lyd_node *diff;
+
+ CHECK_PARSE_LYD_DIFF(model_1, model_2, diff);
+ CHECK_LYD_STRING(diff,
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">\n"
" <foo>42</foo>\n"
" <b1_1>42</b1_1>\n"
@@ -324,16 +342,18 @@
" <foo>42</foo>\n"
" <baz>42</baz>\n"
"</hidden>\n");
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
+ assert_int_equal(lyd_diff_apply_all(&model_1, diff), LY_SUCCESS);
+ CHECK_LYD(model_1, model_2);
+
+ lyd_free_all(model_1);
+ lyd_free_all(model_2);
+ lyd_free_all(diff);
}
static void
test_empty2(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>42</foo>\n"
" <b1_1>42</b1_1>\n"
@@ -342,15 +362,14 @@
" <baz>42</baz>\n"
"</hidden>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- st->second = NULL;
+ struct lyd_node *model_1;
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
+ CHECK_PARSE_LYD(xml, model_1);
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ struct lyd_node *diff;
+
+ CHECK_PARSE_LYD_DIFF(model_1, NULL, diff);
+ CHECK_LYD_STRING(diff,
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">\n"
" <foo>42</foo>\n"
" <b1_1>42</b1_1>\n"
@@ -360,47 +379,53 @@
" <baz>42</baz>\n"
"</hidden>\n");
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- assert_ptr_equal(st->first, st->second);
+ assert_int_equal(lyd_diff_apply_all(&model_1, diff), LY_SUCCESS);
+ assert_ptr_equal(model_1, NULL);
+
+ lyd_free_all(diff);
+ lyd_free_all(model_1);
}
static void
test_empty_nested(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\"><foo>42</foo></df>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- st->second = NULL;
+ struct lyd_node *model_1;
- assert_int_equal(lyd_diff_siblings(NULL, NULL, 0, &st->diff1), LY_SUCCESS);
- assert_null(st->diff1);
+ CHECK_PARSE_LYD(xml, model_1);
- assert_int_equal(lyd_diff_siblings(NULL, lyd_child(st->first), 0, &st->diff1), LY_SUCCESS);
+ struct lyd_node *diff = NULL;
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ assert_int_equal(lyd_diff_siblings(NULL, NULL, 0, &diff), LY_SUCCESS);
+ assert_null(diff);
+
+ struct lyd_node *diff1;
+
+ CHECK_PARSE_LYD_DIFF(NULL, lyd_child(model_1), diff1);
+ CHECK_LYD_STRING(diff1,
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"create\">42</foo>\n"
"</df>\n");
- free(st->xml);
- assert_int_equal(lyd_diff_siblings(lyd_child(st->first), NULL, 0, &st->diff2), LY_SUCCESS);
+ struct lyd_node *diff2;
- assert_non_null(st->diff2);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ CHECK_PARSE_LYD_DIFF(lyd_child(model_1), NULL, diff2);
+ CHECK_LYD_STRING(diff2,
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"delete\">42</foo>\n"
"</df>\n");
+
+ lyd_free_all(model_1);
+ lyd_free_all(diff1);
+ lyd_free_all(diff2);
}
static void
test_leaf(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml1 =
"<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>42</foo>\n"
@@ -421,20 +446,7 @@
"<hidden xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>40</foo>\n"
"</hidden>\n";
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml1, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, LYD_PARSE_ONLY, 0, &st->third));
- assert_non_null(st->third);
-
- /* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
-
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_diff_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"42\">41</foo>\n"
" <b1_1 yang:operation=\"create\">42</b1_1>\n"
@@ -442,54 +454,32 @@
"<hidden xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">\n"
" <foo>42</foo>\n"
" <baz>42</baz>\n"
- "</hidden>\n");
+ "</hidden>\n";
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, 0, &st->diff2), LY_SUCCESS);
-
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
- "<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
+ const char *out_diff_2 = "<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"41\">40</foo>\n"
" <b1_1 yang:operation=\"delete\">42</b1_1>\n"
"</df>\n"
"<hidden xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">\n"
" <foo>40</foo>\n"
- "</hidden>\n");
+ "</hidden>\n";
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
-
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_merge =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"42\">40</foo>\n"
"</df>\n"
"<hidden xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-value=\"42\" yang:orig-default=\"false\">40</foo>\n"
" <baz yang:operation=\"delete\">42</baz>\n"
- "</hidden>\n");
+ "</hidden>\n";
+
+ TEST_DIFF_3(xml1, xml2, xml3, out_diff_1, out_diff_2, out_merge);
}
static void
test_list(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <list>\n"
" <name>a</name>\n"
@@ -521,19 +511,7 @@
" </list>\n"
"</df>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml1, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, LYD_PARSE_ONLY, 0, &st->third));
- assert_non_null(st->third);
-
- /* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
-
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_diff_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <list yang:operation=\"delete\">\n"
" <name>a</name>\n"
@@ -547,19 +525,8 @@
" <name>c</name>\n"
" <value>3</value>\n"
" </list>\n"
- "</df>\n");
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, 0, &st->diff2), LY_SUCCESS);
-
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_diff_2 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <list yang:operation=\"delete\">\n"
" <name>c</name>\n"
@@ -569,20 +536,8 @@
" <name>a</name>\n"
" <value>2</value>\n"
" </list>\n"
- "</df>\n");
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
-
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_merge =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <list yang:operation=\"none\">\n"
" <name>a</name>\n"
@@ -592,13 +547,15 @@
" <name>b</name>\n"
" <value yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"2\">-2</value>\n"
" </list>\n"
- "</df>\n");
+ "</df>\n";
+
+ TEST_DIFF_3(xml1, xml2, xml3, out_diff_1, out_diff_2, out_merge);
}
static void
test_userord_llist(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml1 =
"<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <llist>1</llist>\n"
@@ -623,66 +580,31 @@
" <llist>2</llist>\n"
"</df>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml1, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, LYD_PARSE_ONLY, 0, &st->third));
- assert_non_null(st->third);
-
- /* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
-
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_diff_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"1\">4</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"2\" yang:value=\"4\">3</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, 0, &st->diff2), LY_SUCCESS);
-
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_diff_2 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"delete\" yang:orig-value=\"\">1</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"2\" yang:value=\"\">5</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
-
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_merge =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"1\">4</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"2\" yang:value=\"4\">3</llist>\n"
" <llist yang:orig-value=\"\" yang:operation=\"delete\">1</llist>\n"
" <llist yang:orig-default=\"false\" yang:orig-value=\"2\" yang:value=\"\" yang:operation=\"replace\">5</llist>\n"
- "</df>\n");
+ "</df>\n";
+
+ TEST_DIFF_3(xml1, xml2, xml3, out_diff_1, out_diff_2, out_merge);
}
static void
test_userord_llist2(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml1 =
"<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <llist>1</llist>\n"
@@ -707,63 +629,28 @@
" <llist>3</llist>\n"
"</df>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml1, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, LYD_PARSE_ONLY, 0, &st->third));
- assert_non_null(st->third);
-
- /* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
-
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_diff_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"2\">4</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, 0, &st->diff2), LY_SUCCESS);
-
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_diff_2 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"delete\" yang:orig-value=\"1\">2</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"1\" yang:value=\"\">4</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
-
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_merge =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"\">4</llist>\n"
" <llist yang:orig-value=\"1\" yang:operation=\"delete\">2</llist>\n"
- "</df>\n");
+ "</df>\n";
+
+ TEST_DIFF_3(xml1, xml2, xml3, out_diff_1, out_diff_2, out_merge);
}
static void
test_userord_mix(void **state)
{
- struct state *st = (*state);
+ (void) state;
const char *xml1 =
"<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <llist>1</llist>\n"
@@ -782,66 +669,31 @@
" <llist>3</llist>\n"
"</df>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml1, LYD_XML, LYD_PARSE_ONLY, 0, &st->first));
- assert_non_null(st->first);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, LYD_PARSE_ONLY, 0, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, LYD_PARSE_ONLY, 0, &st->third));
- assert_non_null(st->third);
-
- /* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, 0, &st->diff1), LY_SUCCESS);
-
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ const char *out_diff_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"delete\" yang:orig-value=\"1\">2</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"1\" yang:value=\"\">3</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, 0, &st->diff2), LY_SUCCESS);
-
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_diff_2 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"\">1</llist>\n"
" <llist yang:operation=\"create\" yang:value=\"1\">4</llist>\n"
- "</df>\n");
-
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
-
- /* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
-
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml,
+ "</df>\n";
+ const char *out_merge =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <llist yang:operation=\"delete\" yang:orig-value=\"1\">2</llist>\n"
" <llist yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"1\" yang:value=\"\">3</llist>\n"
" <llist yang:orig-default=\"false\" yang:orig-value=\"3\" yang:value=\"\" yang:operation=\"replace\">1</llist>\n"
" <llist yang:value=\"1\" yang:operation=\"create\">4</llist>\n"
- "</df>\n");
+ "</df>\n";
+
+ TEST_DIFF_3(xml1, xml2, xml3, out_diff_1, out_diff_2, out_merge);
}
static void
test_wd(void **state)
{
- struct state *st = (*state);
+ (void) state;
const struct lys_module *mod;
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\">\n"
" <foo>41</foo>\n"
@@ -853,85 +705,89 @@
" <dllist>1</dllist>\n"
"</df>\n";
- mod = ly_ctx_get_module_implemented(st->ctx, "defaults");
+ mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "defaults");
assert_non_null(mod);
- st->first = NULL;
- assert_int_equal(lyd_validate_module(&st->first, mod, 0, NULL), LY_SUCCESS);
- assert_ptr_not_equal(st->first, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->second));
- assert_non_null(st->second);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, xml3, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->third));
- assert_non_null(st->third);
+ struct lyd_node *model_1 = NULL;
+
+ assert_int_equal(lyd_validate_module(&model_1, mod, 0, NULL), LY_SUCCESS);
+ assert_ptr_not_equal(model_1, NULL);
+
+ struct lyd_node *model_2;
+ struct lyd_node *model_3;
+
+ CHECK_PARSE_LYD_PARAM(xml2, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, model_2);
+ CHECK_PARSE_LYD_PARAM(xml3, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, model_3);
/* diff1 */
- assert_int_equal(lyd_diff_siblings(st->first, st->second, LYD_DIFF_DEFAULTS, &st->diff1), LY_SUCCESS);
+ struct lyd_node *diff1 = NULL;
- assert_non_null(st->diff1);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL);
- assert_string_equal(st->xml,
+ assert_int_equal(lyd_diff_siblings(model_1, model_2, LYD_DIFF_DEFAULTS, &diff1), LY_SUCCESS);
+ assert_non_null(diff1);
+
+ const char *diff1_out_1 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-default=\"true\" yang:orig-value=\"42\">41</foo>\n"
" <dllist yang:operation=\"delete\">1</dllist>\n"
" <dllist yang:operation=\"delete\">2</dllist>\n"
" <dllist yang:operation=\"delete\">3</dllist>\n"
" <dllist yang:operation=\"create\">4</dllist>\n"
- "</df>\n");
+ "</df>\n";
- assert_int_equal(lyd_diff_apply_all(&st->first, st->diff1), LY_SUCCESS);
- lyd_print_mem(&st->xml1, st->first, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- lyd_print_mem(&st->xml2, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
+ CHECK_LYD_STRING_PARAM(diff1, diff1_out_1, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL);
+ assert_int_equal(lyd_diff_apply_all(&model_1, diff1), LY_SUCCESS);
+ CHECK_LYD(model_1, model_2);
/* diff2 */
- assert_int_equal(lyd_diff_siblings(st->second, st->third, LYD_DIFF_DEFAULTS, &st->diff2), LY_SUCCESS);
+ struct lyd_node *diff2;
- assert_non_null(st->diff2);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff2, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL);
- assert_string_equal(st->xml,
+ assert_int_equal(lyd_diff_siblings(model_2, model_3, LYD_DIFF_DEFAULTS, &diff2), LY_SUCCESS);
+ assert_non_null(diff2);
+ CHECK_LYD_STRING(diff2,
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:operation=\"replace\" yang:orig-default=\"false\" yang:orig-value=\"41\">42</foo>\n"
" <dllist yang:operation=\"create\">1</dllist>\n"
"</df>\n");
- assert_int_equal(lyd_diff_apply_all(&st->second, st->diff2), LY_SUCCESS);
- free(st->xml1);
- lyd_print_mem(&st->xml1, st->second, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- free(st->xml2);
- lyd_print_mem(&st->xml2, st->third, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(st->xml1, st->xml2);
+ assert_int_equal(lyd_diff_apply_all(&model_2, diff2), LY_SUCCESS);
+ CHECK_LYD(model_2, model_3);
/* merge */
- assert_int_equal(lyd_diff_merge_all(&st->diff1, st->diff2, 0), LY_SUCCESS);
+ assert_int_equal(lyd_diff_merge_all(&diff1, diff2, 0), LY_SUCCESS);
- free(st->xml);
- lyd_print_mem(&st->xml, st->diff1, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL);
- assert_string_equal(st->xml,
+ const char *diff1_out_2 =
"<df xmlns=\"urn:libyang:tests:defaults\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
" <foo yang:orig-default=\"true\" yang:operation=\"none\">42</foo>\n"
" <dllist yang:operation=\"none\" yang:orig-default=\"true\">1</dllist>\n"
" <dllist yang:operation=\"delete\">2</dllist>\n"
" <dllist yang:operation=\"delete\">3</dllist>\n"
" <dllist yang:operation=\"create\">4</dllist>\n"
- "</df>\n");
+ "</df>\n";
+
+ CHECK_LYD_STRING_PARAM(diff1, diff1_out_2, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL);
+
+ lyd_free_all(model_1);
+ lyd_free_all(model_2);
+ lyd_free_all(model_3);
+ lyd_free_all(diff1);
+ lyd_free_all(diff2);
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_invalid, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_same, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_empty1, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_empty2, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_empty_nested, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_leaf, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_list, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_userord_llist, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_userord_llist2, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_userord_mix, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_wd, setup_f, teardown_f),
+ UTEST(test_invalid, setup),
+ UTEST(test_same, setup),
+ UTEST(test_empty1, setup),
+ UTEST(test_empty2, setup),
+ UTEST(test_empty_nested, setup),
+ UTEST(test_leaf, setup),
+ UTEST(test_list, setup),
+ UTEST(test_userord_llist, setup),
+ UTEST(test_userord_llist2, setup),
+ UTEST(test_userord_mix, setup),
+ UTEST(test_wd, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_lyb.c b/tests/utests/data/test_lyb.c
index 7730381..59ab85c 100644
--- a/tests/utests/data/test_lyb.c
+++ b/tests/utests/data/test_lyb.c
@@ -11,220 +11,23 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include "hash_table.h"
#include "libyang.h"
-#include "tests/config.h"
-#include "utests.h"
-struct state {
- struct ly_ctx *ctx;
- struct lyd_node *dt1, *dt2;
- char *mem;
-};
+#define CHECK_PARSE_LYD(INPUT, MODEL) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0,LY_SUCCESS, MODEL)
-static void
-check_data_tree_next(struct lyd_node **start, struct lyd_node **next, struct lyd_node **elem)
-{
- if (*elem) {
- goto loop_next;
- }
-
-loop_begin:
- /* LYD_TREE_DFS_BEGIN */
- for (*elem = *next = *start; *elem; *elem = *next) {
- return;
-loop_next:
- /* LYD_TREE_DFS_END */
-
- /* select element for the next run - children first */
- *next = lyd_child(*elem);
- if (!*next) {
- /* no children */
- if (*elem == *start) {
- /* we are done, (START) has no children */
- break;
- }
- /* try siblings */
- *next = (*elem)->next;
- }
- while (!*next) {
- /* parent is already processed, go to its sibling */
- *elem = (struct lyd_node *)(*elem)->parent;
- /* no siblings, go back through parents */
- if ((*elem)->parent == (*start)->parent) {
- /* we are done, no next element to process */
- break;
- }
- *next = (*elem)->next;
- }
- }
-
- if (!*next) {
- /* top-level siblings */
- *start = (*start)->next;
- if (!(*start)) {
- *elem = NULL;
- return;
- }
- goto loop_begin;
- }
-
- return;
-}
-
-static void
-check_data_tree(struct lyd_node *root1, struct lyd_node *root2)
-{
- struct lyd_node *next1, *next2, *elem1 = NULL, *elem2 = NULL, *iter;
- struct lyd_meta *meta1, *meta2;
- struct lyd_node_inner *in1, *in2;
- uint32_t i1, i2;
-
- for (check_data_tree_next(&root1, &next1, &elem1), check_data_tree_next(&root2, &next2, &elem2);
- elem1 && elem2;
- check_data_tree_next(&root1, &next1, &elem1), check_data_tree_next(&root2, &next2, &elem2)) {
-
- if (elem1->schema != elem2->schema) {
- fprintf(stderr, "Schema mismatch (\"%s\" and \"%s\").\n", elem1->schema->name, elem2->schema->name);
- fail();
- }
-
- /* check common data node attributes */
- if (elem1->flags != elem2->flags) {
- fprintf(stderr, "\"%s\": flags mismatch (\"%u\" and \"%u\").\n", elem1->schema->name, elem1->flags, elem2->flags);
- fail();
- }
-
- /* check data node attributes */
- for (meta1 = elem1->meta, meta2 = elem2->meta; meta1 && meta2; meta1 = meta1->next, meta2 = meta2->next) {
- if (meta1->annotation != meta2->annotation) {
- fprintf(stderr, "\"%s\": meta annotation mismatch.\n", elem1->schema->name);
- fail();
- }
- if (strcmp(meta1->name, meta2->name)) {
- fprintf(stderr, "\"%s\": meta name mismatch (\"%s\" and \"%s\").\n", elem1->schema->name, meta1->name, meta2->name);
- fail();
- }
- if (lyd_compare_meta(meta1, meta2)) {
- fprintf(stderr, "\"%s\": meta value mismatch.\n", elem1->schema->name);
- fail();
- }
- }
- if (meta1) {
- fprintf(stderr, "\"%s\": meta mismatch (\"%s\" and \"NULL\").\n", elem1->schema->name, meta1->name);
- fail();
- }
- if (meta2) {
- fprintf(stderr, "\"%s\": meta mismatch (\"NULL\" and \"%s\").\n", elem1->schema->name, meta2->name);
- fail();
- }
-
- /* check specific data node attributes */
- switch (elem1->schema->nodetype) {
- case LYS_CONTAINER:
- case LYS_LIST:
- case LYS_RPC:
- case LYS_ACTION:
- case LYS_NOTIF:
- in1 = (struct lyd_node_inner *)elem1;
- in2 = (struct lyd_node_inner *)elem2;
-
- i1 = 0;
- LY_LIST_FOR(in1->child, iter) {
- ++i1;
- }
-
- i2 = 0;
- LY_LIST_FOR(in2->child, iter) {
- ++i2;
- }
-
- if (i1 != i2) {
- fprintf(stderr, "\"%s\": child count mismatch (%u and %u).\n", elem1->schema->name, i1, i2);
- fail();
- }
-
- if (i1 >= LYD_HT_MIN_ITEMS) {
- if (!in1->children_ht || !in2->children_ht) {
- fprintf(stderr, "\"%s\": missing hash table (%p and %p).\n", elem1->schema->name, in1->children_ht,
- in2->children_ht);
- fail();
- }
-
- LY_LIST_FOR(in1->child, iter) {
- if (lyht_find(in1->children_ht, &iter, iter->hash, NULL)) {
- fprintf(stderr, "\"%s\": missing child \"%s\" in the hash table 1.\n", elem1->schema->name, iter->schema->name);
- fail();
- }
- }
- LY_LIST_FOR(in2->child, iter) {
- if (lyht_find(in2->children_ht, &iter, iter->hash, NULL)) {
- fprintf(stderr, "\"%s\": missing child \"%s\" in the hash table 2.\n", elem1->schema->name, iter->schema->name);
- fail();
- }
- }
- }
- break;
- case LYS_LEAF:
- case LYS_LEAFLIST:
- case LYS_ANYDATA:
- case LYS_ANYXML:
- if (lyd_compare_single(elem1, elem2, 0)) {
- fprintf(stderr, "\"%s\": value mismatch.\n", elem1->schema->name);
- fail();
- }
- break;
- default:
- fprintf(stderr, "Unexpected data node type.\n");
- fail();
- }
-
- if (!elem1->hash) {
- fprintf(stderr, "\"%s\": hash not calculated.\n", elem1->schema->name);
- fail();
- }
- if (elem1->hash != elem2->hash) {
- fprintf(stderr, "\"%s\": hashes do not match (%u and %u).\n", elem1->schema->name, elem1->hash, elem2->hash);
- fail();
- }
- }
-
- if (elem1) {
- fprintf(stderr, "Schema mismatch (\"%s\" and \"NULL\").\n", elem1->schema->name);
- fail();
- }
- if (elem2) {
- fprintf(stderr, "Schema mismatch (\"NULL\" and \"%s\").\n", elem2->schema->name);
- fail();
- }
-}
+#define CHECK_LYD_STRING(MODEL, TEXT) \
+ CHECK_LYD_STRING_PARAM(MODEL, TEXT, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK)
static int
-setup_f(void **state)
+setup(void **state)
{
- struct state *st;
-
- (*state) = st = calloc(1, sizeof *st);
- assert_non_null(st);
-
- /* libyang context */
- assert_int_equal(ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &st->ctx), LY_SUCCESS);
-
- return 0;
-}
-
-static int
-teardown_f(void **state)
-{
- struct state *st = (*state);
-
- lyd_free_siblings(st->dt1);
- lyd_free_siblings(st->dt2);
- ly_ctx_destroy(st->ctx, NULL);
- free(st->mem);
- free(st);
- (*state) = NULL;
+ UTEST_SETUP;
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
return 0;
}
@@ -232,8 +35,6 @@
static void
test_ietf_interfaces(void **state)
{
- struct state *st = (*state);
- int ret;
const char *data_xml =
"<interfaces xmlns=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">\n"
" <interface>\n"
@@ -271,27 +72,32 @@
" <enabled>false</enabled>\n"
" </interface>\n"
"</interfaces>\n";
+ struct lyd_node *tree_1;
+ struct lyd_node *tree_2;
+ char *xml_out; /* tree_2 */
- assert_non_null(ly_ctx_load_module(st->ctx, "ietf-ip", NULL, NULL));
- assert_non_null(ly_ctx_load_module(st->ctx, "iana-if-type", NULL, NULL));
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-ip", NULL, NULL));
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "iana-if-type", NULL, NULL));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, data_xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->dt1));
- assert_ptr_not_equal(st->dt1, NULL);
+ CHECK_PARSE_LYD(data_xml, tree_1);
- ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYD_PRINT_WITHSIBLINGS);
- assert_int_equal(ret, 0);
+ assert_int_equal(lyd_print_mem(&xml_out, tree_1, LYD_LYB, LYD_PRINT_WITHSIBLINGS), 0);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, st->mem, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &st->dt2));
- assert_ptr_not_equal(st->dt2, NULL);
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, xml_out, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree_2));
+ assert_non_null(tree_2);
- check_data_tree(st->dt1, st->dt2);
+ /* compare models */
+ CHECK_LYD(tree_1, tree_2);
+
+ /* clean */
+ free(xml_out);
+ lyd_free_all(tree_1);
+ lyd_free_all(tree_2);
}
static void
test_origin(void **state)
{
- struct state *st = (*state);
- int ret;
const char *origin_yang =
"module test-origin {"
" namespace \"urn:test-origin\";"
@@ -318,27 +124,32 @@
" <leaf2>value2</leaf2>\n"
" <leaf3 xmlns:or=\"urn:ietf:params:xml:ns:yang:ietf-origin\" or:origin=\"or:system\">125</leaf3>\n"
"</cont>\n";
+ struct lyd_node *tree_1;
+ struct lyd_node *tree_2;
+ char *xml_out; /* tree_2 */
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, origin_yang, LYS_IN_YANG, NULL));
- lys_set_implemented(ly_ctx_get_module_latest(st->ctx, "ietf-origin"), NULL);
+ UTEST_ADD_MODULE(origin_yang, LYS_IN_YANG, NULL, NULL);
+ assert_int_equal(LY_SUCCESS, lys_set_implemented(ly_ctx_get_module_latest(UTEST_LYCTX, "ietf-origin"), NULL));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, data_xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->dt1));
- assert_ptr_not_equal(st->dt1, NULL);
+ CHECK_PARSE_LYD(data_xml, tree_1);
- ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYD_PRINT_WITHSIBLINGS);
- assert_int_equal(ret, 0);
+ assert_int_equal(lyd_print_mem(&xml_out, tree_1, LYD_LYB, LYD_PRINT_WITHSIBLINGS), 0);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, st->mem, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &st->dt2));
- assert_ptr_not_equal(st->dt2, NULL);
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, xml_out, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree_2));
+ assert_non_null(tree_2);
- check_data_tree(st->dt1, st->dt2);
+ /* compare models */
+ CHECK_LYD(tree_1, tree_2);
+
+ /* clean */
+ free(xml_out);
+ lyd_free_all(tree_1);
+ lyd_free_all(tree_2);
}
static void
test_statements(void **state)
{
- struct state *st = (*state);
- int ret;
const char *links_yang =
"module links {\n"
" yang-version 1.1;\n"
@@ -526,312 +337,324 @@
" <lref>reference leaf</lref>\n"
" <iref>random-identity</iref>\n"
"</random>\n";
+ struct lyd_node *tree_1;
+ struct lyd_node *tree_2;
+ char *xml_out; /* tree_2 */
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, links_yang, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, statements_yang, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(links_yang, LYS_IN_YANG, NULL, NULL);
+ UTEST_ADD_MODULE(statements_yang, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, data_xml, LYD_XML, LYD_PARSE_ONLY, 0, &st->dt1));
+ CHECK_PARSE_LYD(data_xml, tree_1);
+
+ assert_int_equal(lyd_print_mem(&xml_out, tree_1, LYD_LYB, LYD_PRINT_WITHSIBLINGS), 0);
+
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, xml_out, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree_2));
+ assert_non_null(tree_2);
+
+ /* compare models */
+ CHECK_LYD(tree_1, tree_2);
+
+ /* clean */
+ free(xml_out);
+ lyd_free_all(tree_1);
+ lyd_free_all(tree_2);
+}
+
+#if 0
+
+static void
+test_types(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "types", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/types.xml", LYD_XML, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt1, NULL);
- ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYD_PRINT_WITHSIBLINGS);
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
assert_int_equal(ret, 0);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, st->mem, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &st->dt2));
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
assert_ptr_not_equal(st->dt2, NULL);
check_data_tree(st->dt1, st->dt2);
}
-// static void
-// test_types(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "types", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/types.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_annotations(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/annotations.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_similar_annot_names(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/similar-annot-names.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_many_child_annot(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/many-childs-annot.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_union(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "union", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/union.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_union2(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "statements", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/union2.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_collisions(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/collisions.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_anydata(void **state)
-// {
-// struct state *st = (*state);
-// const struct lys_module *mod;
-// int ret;
-// const char *test_anydata =
-// "module test-anydata {"
-// " namespace \"urn:test-anydata\";"
-// " prefix ya;"
-// ""
-// " container cont {"
-// " anydata ntf;"
-// " }"
-// "}";
-//
-// assert_non_null(ly_ctx_load_module(st->ctx, "ietf-netconf-notifications", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/ietf-netconf-notifications.json", LYD_JSON, LYD_OPT_NOTIF | LYD_OPT_TRUSTED, NULL);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-/// * get notification in LYB format to set as anydata content */
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// lyd_free_withsiblings(st->dt1);
-// st->dt1 = NULL;
-//
-/// * now comes the real test, test anydata */
-// mod = lys_parse_mem(st->ctx, test_anydata, LYS_YANG);
-// assert_non_null(mod);
-//
-// st->dt1 = lyd_new(NULL, mod, "cont");
-// assert_non_null(st->dt1);
-//
-// assert_non_null(lyd_new_anydata(st->dt1, NULL, "ntf", st->mem, LYD_ANYDATA_LYBD));
-// st->mem = NULL;
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// ret = lyd_validate(&st->dt1, LYD_OPT_CONFIG, NULL);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-//
-/// * and also test the embedded notification itself */
-// free(st->mem);
-// ret = lyd_lyb_data_length(((struct lyd_node_anydata *)st->dt1->child)->value.mem);
-// st->mem = malloc(ret);
-// memcpy(st->mem, ((struct lyd_node_anydata *)st->dt1->child)->value.mem, ret);
-//
-// lyd_free_withsiblings(st->dt2);
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_NOTIF | LYD_OPT_STRICT | LYD_OPT_NOEXTDEPS, NULL);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-/// * parse the JSON again for this comparison */
-// lyd_free_withsiblings(st->dt1);
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/ietf-netconf-notifications.json", LYD_JSON, LYD_OPT_NOTIF | LYD_OPT_TRUSTED, NULL);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_submodule_feature(void **state)
-// {
-// struct state *st = (*state);
-// const struct lys_module *mod;
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// mod = ly_ctx_load_module(st->ctx, "feature-submodule-main", NULL);
-// assert_non_null(mod);
-// assert_int_equal(lys_features_enable(mod, "test-submodule-feature"), 0);
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/test-submodule-feature.json", LYD_JSON, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_coliding_augments(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "augment-target", NULL));
-// assert_non_null(ly_ctx_load_module(st->ctx, "augment0", NULL));
-// assert_non_null(ly_ctx_load_module(st->ctx, "augment1", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/augment.xml", LYD_XML, LYD_OPT_CONFIG);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
-//
-// static void
-// test_leafrefs(void **state)
-// {
-// struct state *st = (*state);
-// int ret;
-//
-// ly_ctx_set_searchdir(st->ctx, TESTS_DIR"/data/files");
-// assert_non_null(ly_ctx_load_module(st->ctx, "leafrefs2", NULL));
-//
-// st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR"/data/files/leafrefs2.json", LYD_JSON, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt1, NULL);
-//
-// ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
-// assert_int_equal(ret, 0);
-//
-// st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
-// assert_ptr_not_equal(st->dt2, NULL);
-//
-// check_data_tree(st->dt1, st->dt2);
-// }
+static void
+test_annotations(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/annotations.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_similar_annot_names(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/similar-annot-names.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_many_child_annot(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/many-childs-annot.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_union(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "union", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/union.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_union2(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "statements", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/union2.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_collisions(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "annotations", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/collisions.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_anydata(void **state)
+{
+ struct state *st = (*state);
+ const struct lys_module *mod;
+ int ret;
+ const char *test_anydata =
+ "module test-anydata {"
+ " namespace \"urn:test-anydata\";"
+ " prefix ya;"
+ ""
+ " container cont {"
+ " anydata ntf;"
+ " }"
+ "}";
+
+ assert_non_null(ly_ctx_load_module(st->ctx, "ietf-netconf-notifications", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/ietf-netconf-notifications.json", LYD_JSON, LYD_OPT_NOTIF | LYD_OPT_TRUSTED, NULL);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ / *get notification in LYB format to set as anydata content * /
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ lyd_free_withsiblings(st->dt1);
+ st->dt1 = NULL;
+
+ / *now comes the real test, test anydata * /
+ mod = lys_parse_mem(st->ctx, test_anydata, LYS_YANG);
+ assert_non_null(mod);
+
+ st->dt1 = lyd_new(NULL, mod, "cont");
+ assert_non_null(st->dt1);
+
+ assert_non_null(lyd_new_anydata(st->dt1, NULL, "ntf", st->mem, LYD_ANYDATA_LYBD));
+ st->mem = NULL;
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ ret = lyd_validate(&st->dt1, LYD_OPT_CONFIG, NULL);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+
+ /* and also test the embedded notification itself */
+ free(st->mem);
+ ret = lyd_lyb_data_length(((struct lyd_node_anydata *)st->dt1->child)->value.mem);
+ st->mem = malloc(ret);
+ memcpy(st->mem, ((struct lyd_node_anydata *)st->dt1->child)->value.mem, ret);
+
+ lyd_free_withsiblings(st->dt2);
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_NOTIF | LYD_OPT_STRICT | LYD_OPT_NOEXTDEPS, NULL);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ /* parse the JSON again for this comparison */
+ lyd_free_withsiblings(st->dt1);
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/ietf-netconf-notifications.json", LYD_JSON, LYD_OPT_NOTIF | LYD_OPT_TRUSTED, NULL);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_submodule_feature(void **state)
+{
+ struct state *st = (*state);
+ const struct lys_module *mod;
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ mod = ly_ctx_load_module(st->ctx, "feature-submodule-main", NULL);
+ assert_non_null(mod);
+ assert_int_equal(lys_features_enable(mod, "test-submodule-feature"), 0);
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/test-submodule-feature.json", LYD_JSON, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_coliding_augments(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "augment-target", NULL));
+ assert_non_null(ly_ctx_load_module(st->ctx, "augment0", NULL));
+ assert_non_null(ly_ctx_load_module(st->ctx, "augment1", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/augment.xml", LYD_XML, LYD_OPT_CONFIG);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+static void
+test_leafrefs(void **state)
+{
+ struct state *st = (*state);
+ int ret;
+
+ ly_ctx_set_searchdir(st->ctx, TESTS_DIR "/data/files");
+ assert_non_null(ly_ctx_load_module(st->ctx, "leafrefs2", NULL));
+
+ st->dt1 = lyd_parse_path(st->ctx, TESTS_DIR "/data/files/leafrefs2.json", LYD_JSON, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt1, NULL);
+
+ ret = lyd_print_mem(&st->mem, st->dt1, LYD_LYB, LYP_WITHSIBLINGS);
+ assert_int_equal(ret, 0);
+
+ st->dt2 = lyd_parse_mem(st->ctx, st->mem, LYD_LYB, LYD_OPT_CONFIG | LYD_OPT_STRICT);
+ assert_ptr_not_equal(st->dt2, NULL);
+
+ check_data_tree(st->dt1, st->dt2);
+}
+
+#endif
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_ietf_interfaces, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_origin, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_statements, setup_f, teardown_f),
- /*cmocka_unit_test_setup_teardown(test_types, setup_f, teardown_f),
+ UTEST(test_ietf_interfaces, setup),
+ UTEST(test_origin, setup),
+ UTEST(test_statements, setup),
+#if 0
+ cmocka_unit_test_setup_teardown(test_types, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_annotations, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_similar_annot_names, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_many_child_annot, setup_f, teardown_f),
@@ -841,7 +664,8 @@
cmocka_unit_test_setup_teardown(test_anydata, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_submodule_feature, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_coliding_augments, setup_f, teardown_f),
- cmocka_unit_test_setup_teardown(test_leafrefs, setup_f, teardown_f),*/
+ cmocka_unit_test_setup_teardown(test_leafrefs, setup_f, teardown_f),
+#endif
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_merge.c b/tests/utests/data/test_merge.c
index 20df92a..0c429a4 100644
--- a/tests/utests/data/test_merge.c
+++ b/tests/utests/data/test_merge.c
@@ -11,66 +11,23 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
-
-#include "libyang.h"
+#define _UTEST_MAIN_
#include "utests.h"
-struct state {
- struct ly_ctx *ctx;
- struct lyd_node *source;
- struct lyd_node *target;
- struct lyd_node *result;
-};
+#include "libyang.h"
-static int
-setup_dflt(void **state)
-{
- struct state *st;
+#define LYD_TREE_CREATE(INPUT, MODEL) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, MODEL)
- (*state) = st = calloc(1, sizeof *st);
- if (!st) {
- fprintf(stderr, "Memory allocation error.\n");
- return -1;
- }
+#define CONTEXT_CREATE \
+ CONTEXT_CREATE_PATH(NULL)
- /* libyang context */
- if (ly_ctx_new(NULL, 0, &st->ctx)) {
- fprintf(stderr, "Failed to create context.\n");
- goto error;
- }
-
- return 0;
-
-error:
- ly_ctx_destroy(st->ctx, NULL);
- free(st);
- (*state) = NULL;
-
- return -1;
-}
-
-static int
-teardown_dflt(void **state)
-{
- struct state *st = (*state);
-
- lyd_free_siblings(st->target);
- lyd_free_siblings(st->source);
- lyd_free_siblings(st->result);
- ly_ctx_destroy(st->ctx, NULL);
- free(st);
- (*state) = NULL;
-
- return 0;
-}
+#define LYD_TREE_CHECK_CHAR(MODEL, TEXT, PARAMS) \
+ CHECK_LYD_STRING_PARAM(MODEL, TEXT, LYD_XML, LYD_PRINT_WITHSIBLINGS | PARAMS)
static void
test_batch(void **state)
{
- struct state *st = (*state);
- uint32_t i;
- char *str;
-
const char *start =
"<modules-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"
" <module>\n"
@@ -215,32 +172,25 @@
" <conformance-type>implement</conformance-type>\n"
" </module>\n"
"</modules-state>\n";
- struct ly_in *in = NULL;
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(start, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_data(st->ctx, in, LYD_XML, LYD_PARSE_ONLY, 0, &st->target));
- assert_non_null(st->target);
+ struct lyd_node *target;
- for (i = 0; i < 11; ++i) {
- ly_in_memory(in, data[i]);
- assert_int_equal(LY_SUCCESS, lyd_parse_data(st->ctx, in, LYD_XML, LYD_PARSE_ONLY, 0, &st->source));
- assert_non_null(st->source);
+ CHECK_PARSE_LYD_PARAM(start, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, target);
- assert_int_equal(LY_SUCCESS, lyd_merge_siblings(&st->target, st->source, LYD_MERGE_DESTRUCT));
- st->source = NULL;
+ for (int32_t i = 0; i < 11; ++i) {
+ struct lyd_node *source;
+ CHECK_PARSE_LYD_PARAM(data[i], LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, source);
+ assert_int_equal(LY_SUCCESS, lyd_merge_siblings(&target, source, LYD_MERGE_DESTRUCT));
}
- lyd_print_mem(&str, st->target, LYD_XML, 0);
- assert_string_equal(str, output_template);
+ LYD_TREE_CHECK_CHAR(target, output_template, 0);
- ly_in_free(in, 0);
- free(str);
+ lyd_free_all(target);
}
static void
test_leaf(void **state)
{
- struct state *st = (*state);
const char *sch = "module x {"
" namespace urn:x;"
" prefix x;"
@@ -254,30 +204,27 @@
const char *trg = "<A xmlns=\"urn:x\"> <f1>block</f1> </A>";
const char *src = "<A xmlns=\"urn:x\"> <f1>aa</f1> <B> <f2>bb</f2> </B> </A>";
const char *result = "<A xmlns=\"urn:x\"><f1>aa</f1><B><f2>bb</f2></B></A>";
- char *printed = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
/* merge them */
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&st->target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
/* check the result */
- lyd_print_mem(&printed, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK);
- assert_string_equal(printed, result);
- free(printed);
+ LYD_TREE_CHECK_CHAR(target, result, LYD_PRINT_SHRINK);
+
+ lyd_free_all(target);
+ lyd_free_all(source);
}
static void
test_container(void **state)
{
- struct state *st = (*state);
const char *sch =
"module A {\n"
" namespace \"aa:A\";\n"
@@ -296,30 +243,28 @@
const char *trg = "<A xmlns=\"aa:A\"> <B> <f2>aaa</f2> </B> </A>";
const char *src = "<A xmlns=\"aa:A\"> <C> <f3>bbb</f3> </C> </A>";
const char *result = "<A xmlns=\"aa:A\"><B><f2>aaa</f2></B><C><f3>bbb</f3></C></A>";
- char *printed = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
/* merge them */
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&st->target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
/* check the result */
- lyd_print_mem(&printed, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK);
- assert_string_equal(printed, result);
- free(printed);
+ LYD_TREE_CHECK_CHAR(target, result, LYD_PRINT_SHRINK);
+
+ /* destroy */
+ lyd_free_all(source);
+ lyd_free_all(target);
}
static void
test_list(void **state)
{
- struct state *st = (*state);
const char *sch =
"module merge {\n"
" namespace \"http://test/merge\";\n"
@@ -365,30 +310,27 @@
" <p3>true</p3>\n"
" </b-list1>\n"
"</inner1>\n";
- char *printed = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
/* merge them */
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&st->target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
/* check the result */
- lyd_print_mem(&printed, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(printed, result);
- free(printed);
+ LYD_TREE_CHECK_CHAR(target, result, 0);
+
+ lyd_free_all(target);
+ lyd_free_all(source);
}
static void
test_list2(void **state)
{
- struct state *st = (*state);
const char *sch =
"module merge {\n"
" namespace \"http://test/merge\";\n"
@@ -443,30 +385,27 @@
" </inner2>\n"
" </b-list1>\n"
"</inner1>\n";
- char *printed = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
/* merge them */
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&st->target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
/* check the result */
- lyd_print_mem(&printed, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(printed, result);
- free(printed);
+ LYD_TREE_CHECK_CHAR(target, result, 0);
+
+ lyd_free_all(source);
+ lyd_free_all(target);
}
static void
test_case(void **state)
{
- struct state *st = (*state);
const char *sch =
"module merge {\n"
" namespace \"http://test/merge\";\n"
@@ -501,30 +440,27 @@
"<cont xmlns=\"http://test/merge\">\n"
" <p1>1</p1>\n"
"</cont>\n";
- char *printed = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
/* merge them */
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&st->target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
/* check the result */
- lyd_print_mem(&printed, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS);
- assert_string_equal(printed, result);
- free(printed);
+ LYD_TREE_CHECK_CHAR(target, result, 0);
+
+ lyd_free_all(source);
+ lyd_free_all(target);
}
static void
test_dflt(void **state)
{
- struct state *st = (*state);
const char *sch =
"module merge-dflt {\n"
" namespace \"urn:merge-dflt\";\n"
@@ -542,28 +478,32 @@
" }\n"
" }\n"
"}\n";
+ struct lyd_node *target = NULL;
+ struct lyd_node *source = NULL;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(lyd_new_path(NULL, st->ctx, "/merge-dflt:top/c", "c_dflt", 0, &st->target), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&(st->target), NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(NULL, UTEST_LYCTX, "/merge-dflt:top/c", "c_dflt", 0, &target), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
- assert_int_equal(lyd_new_path(NULL, st->ctx, "/merge-dflt:top/a", "a_val", 0, &st->source), LY_SUCCESS);
- assert_int_equal(lyd_new_path(st->source, st->ctx, "/merge-dflt:top/b", "b_val", 0, NULL), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&(st->source), NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(NULL, UTEST_LYCTX, "/merge-dflt:top/a", "a_val", 0, &source), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(source, UTEST_LYCTX, "/merge-dflt:top/b", "b_val", 0, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&source, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, LYD_MERGE_DESTRUCT | LYD_MERGE_DEFAULTS), LY_SUCCESS);
- st->source = NULL;
+ assert_int_equal(lyd_merge_siblings(&target, source, LYD_MERGE_DESTRUCT | LYD_MERGE_DEFAULTS), LY_SUCCESS);
+ source = NULL;
/* c should be replaced and now be default */
- assert_string_equal(lyd_child(st->target)->prev->schema->name, "c");
- assert_true(lyd_child(st->target)->prev->flags & LYD_DEFAULT);
+ assert_string_equal(lyd_child(target)->prev->schema->name, "c");
+ assert_true(lyd_child(target)->prev->flags & LYD_DEFAULT);
+
+ lyd_free_all(target);
+ lyd_free_all(source);
}
static void
test_dflt2(void **state)
{
- struct state *st = (*state);
const char *sch =
"module merge-dflt {\n"
" namespace \"urn:merge-dflt\";\n"
@@ -581,26 +521,30 @@
" }\n"
" }\n"
"}\n";
+ struct lyd_node *target;
+ struct lyd_node *source;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(lyd_new_path(NULL, st->ctx, "/merge-dflt:top/c", "c_dflt", 0, &st->target), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&(st->target), NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(NULL, UTEST_LYCTX, "/merge-dflt:top/c", "c_dflt", 0, &target), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&target, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
- assert_int_equal(lyd_new_path(NULL, st->ctx, "/merge-dflt:top/a", "a_val", 0, &st->source), LY_SUCCESS);
- assert_int_equal(lyd_new_path(st->source, st->ctx, "/merge-dflt:top/b", "b_val", 0, NULL), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&(st->source), NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(NULL, UTEST_LYCTX, "/merge-dflt:top/a", "a_val", 0, &source), LY_SUCCESS);
+ assert_int_equal(lyd_new_path(source, UTEST_LYCTX, "/merge-dflt:top/b", "b_val", 0, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&source, NULL, LYD_VALIDATE_PRESENT, NULL), LY_SUCCESS);
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
/* c should not be replaced, so c remains not default */
- assert_false(lyd_child(st->target)->flags & LYD_DEFAULT);
+ assert_false(lyd_child(target)->flags & LYD_DEFAULT);
+
+ lyd_free_all(target);
+ lyd_free_all(source);
}
static void
test_leafrefs(void **state)
{
- struct state *st = (*state);
const char *sch = "module x {"
" namespace urn:x;"
" prefix x;"
@@ -616,36 +560,34 @@
const char *res = "<l xmlns=\"urn:x\"><n>a</n><t>*</t></l>"
"<l xmlns=\"urn:x\"><n>b</n><r>a</r></l>"
"<l xmlns=\"urn:x\"><n>c</n><r>a</r></l>";
- char *prt = NULL;
+ struct lyd_node *source, *target;
- assert_int_equal(LY_SUCCESS, lys_parse_mem(st->ctx, sch, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(sch, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, src, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->source));
- assert_non_null(st->source);
+ LYD_TREE_CREATE(src, source);
+ LYD_TREE_CREATE(trg, target);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(st->ctx, trg, LYD_XML, 0, LYD_VALIDATE_PRESENT, &st->target));
- assert_non_null(st->target);
+ assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS);
- assert_int_equal(lyd_merge_siblings(&st->target, st->source, 0), LY_SUCCESS);
+ LYD_TREE_CHECK_CHAR(target, res, LYD_PRINT_SHRINK);
- lyd_print_mem(&prt, st->target, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK);
- assert_string_equal(prt, res);
- free(prt);
+ lyd_free_all(source);
+ lyd_free_all(target);
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_batch, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_leaf, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_container, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_list, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_list2, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_case, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_dflt, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_dflt2, setup_dflt, teardown_dflt),
- cmocka_unit_test_setup_teardown(test_leafrefs, setup_dflt, teardown_dflt),
+ UTEST(test_batch),
+ UTEST(test_leaf),
+ UTEST(test_container),
+ UTEST(test_list),
+ UTEST(test_list2),
+ UTEST(test_case),
+ UTEST(test_dflt),
+ UTEST(test_dflt2),
+ UTEST(test_leafrefs),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_new.c b/tests/utests/data/test_new.c
index 58ccb1c..12155a6 100644
--- a/tests/utests/data/test_new.c
+++ b/tests/utests/data/test_new.c
@@ -11,118 +11,85 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
-
-#include "libyang.h"
+#define _UTEST_MAIN_
#include "utests.h"
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
+#include "libyang.h"
-struct ly_ctx *ctx; /* context for tests */
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
-
-static int
-setup(void **state)
-{
- (void) state; /* unused */
-
- const char *schema_a = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;"
- "list l1 { key \"a b\"; leaf a {type string;} leaf b {type string;} leaf c {type string;}}"
- "leaf foo { type uint16;}"
- "leaf-list ll { type string;}"
- "container c {leaf-list x {type string;}}"
- "anydata any {config false;}"
- "list l2 {config false; container c{leaf x {type string;}}}"
- "rpc oper {input {leaf param {type string;}} output {leaf param {type int8;}}}}";
-
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
-
- assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_a, LYS_IN_YANG, NULL));
-
- return 0;
-}
-
-static int
-teardown(void **state)
-{
-#if ENABLE_LOGGER_CHECKING
- if (*state) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#else
- (void) state; /* unused */
-#endif
-
- ly_ctx_destroy(ctx, NULL);
- ctx = NULL;
-
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
+/* common module for the tests */
+const char *schema_a = "module a {\n"
+ " namespace urn:tests:a;\n"
+ " prefix a;yang-version 1.1;\n"
+ " list l1 {\n"
+ " key \"a b\";\n"
+ " leaf a {\n"
+ " type string;\n"
+ " }\n"
+ " leaf b {\n"
+ " type string;\n"
+ " }\n"
+ " leaf c {\n"
+ " type string;}\n"
+ " }\n"
+ " leaf foo {\n"
+ " type uint16;\n"
+ " }\n"
+ " leaf-list ll {\n"
+ " type string;\n"
+ " }\n"
+ " container c {\n"
+ " leaf-list x {\n"
+ " type string;\n"
+ " }\n"
+ " }"
+ " anydata any {\n"
+ " config false;\n"
+ " }"
+ " list l2 {\n"
+ " config false;\n"
+ " container c {\n"
+ " leaf x {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " rpc oper {\n"
+ " input {\n"
+ " leaf param {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " output {\n"
+ " leaf param {\n"
+ " type int8;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "}\n";
static void
test_top_level(void **state)
{
- *state = test_top_level;
-
const struct lys_module *mod;
struct lyd_node *node, *rpc;
- /* we need the module first */
- mod = ly_ctx_get_module_implemented(ctx, "a");
- assert_non_null(mod);
+ UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, &mod);
/* list */
assert_int_equal(lyd_new_list(NULL, mod, "l1", 0, &node, "val_a", "val_b"), LY_SUCCESS);
lyd_free_tree(node);
assert_int_equal(lyd_new_list2(NULL, mod, "l1", "[]", 0, &node), LY_EVALID);
- logbuf_assert("Unexpected XPath token \"]\" (\"]\").");
+ CHECK_LOG_CTX("Unexpected XPath token \"]\" (\"]\").", NULL);
assert_int_equal(lyd_new_list2(NULL, mod, "l1", "[key1='a'][key2='b']", 0, &node), LY_ENOTFOUND);
- logbuf_assert("Not found node \"key1\" in path.");
+ CHECK_LOG_CTX("Not found node \"key1\" in path.", NULL);
assert_int_equal(lyd_new_list2(NULL, mod, "l1", "[a='a'][b='b'][c='c']", 0, &node), LY_EVALID);
- logbuf_assert("Key expected instead of leaf \"c\" in path. /a:l1/c");
+ CHECK_LOG_CTX("Key expected instead of leaf \"c\" in path.", "/a:l1/c");
assert_int_equal(lyd_new_list2(NULL, mod, "c", "[a='a'][b='b']", 0, &node), LY_ENOTFOUND);
- logbuf_assert("List node \"c\" not found.");
+ CHECK_LOG_CTX("List node \"c\" not found.", NULL);
assert_int_equal(lyd_new_list2(NULL, mod, "l1", "[a='a'][b='b']", 0, &node), LY_SUCCESS);
lyd_free_tree(node);
@@ -138,10 +105,10 @@
/* leaf */
assert_int_equal(lyd_new_term(NULL, mod, "foo", "[a='a'][b='b'][c='c']", 0, &node), LY_EVALID);
- logbuf_assert("Invalid uint16 value \"[a='a'][b='b'][c='c']\". /a:foo");
+ CHECK_LOG_CTX("Invalid uint16 value \"[a='a'][b='b'][c='c']\".", "/a:foo");
assert_int_equal(lyd_new_term(NULL, mod, "c", "value", 0, &node), LY_ENOTFOUND);
- logbuf_assert("Term node \"c\" not found.");
+ CHECK_LOG_CTX("Term node \"c\" not found.", NULL);
assert_int_equal(lyd_new_term(NULL, mod, "foo", "256", 0, &node), LY_SUCCESS);
lyd_free_tree(node);
@@ -155,10 +122,10 @@
lyd_free_tree(node);
assert_int_equal(lyd_new_inner(NULL, mod, "l1", 0, &node), LY_ENOTFOUND);
- logbuf_assert("Inner node (and not a list) \"l1\" not found.");
+ CHECK_LOG_CTX("Inner node (and not a list) \"l1\" not found.", NULL);
assert_int_equal(lyd_new_inner(NULL, mod, "l2", 0, &node), LY_ENOTFOUND);
- logbuf_assert("Inner node (and not a list) \"l2\" not found.");
+ CHECK_LOG_CTX("Inner node (and not a list) \"l2\" not found.", NULL);
/* anydata */
assert_int_equal(lyd_new_any(NULL, mod, "any", "some-value", LYD_ANYDATA_STRING, 0, &node), LY_SUCCESS);
@@ -166,7 +133,7 @@
/* key-less list */
assert_int_equal(lyd_new_list2(NULL, mod, "l2", "[a='a'][b='b']", 0, &node), LY_EVALID);
- logbuf_assert("List predicate defined for keyless list \"l2\" in path.");
+ CHECK_LOG_CTX("List predicate defined for keyless list \"l2\" in path.", NULL);
assert_int_equal(lyd_new_list2(NULL, mod, "l2", "", 0, &node), LY_SUCCESS);
lyd_free_tree(node);
@@ -184,19 +151,17 @@
assert_int_equal(lyd_new_term(rpc, mod, "param", "22", 1, &node), LY_SUCCESS);
assert_int_equal(LY_TYPE_INT8, ((struct lysc_node_leaf *)node->schema)->type->basetype);
lyd_free_tree(rpc);
-
- *state = NULL;
}
static void
test_opaq(void **state)
{
- *state = test_opaq;
-
struct lyd_node *root, *node;
struct lyd_node_opaq *opq;
- assert_int_equal(lyd_new_opaq(NULL, ctx, "node1", NULL, "my-module", &root), LY_SUCCESS);
+ UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, NULL);
+
+ assert_int_equal(lyd_new_opaq(NULL, UTEST_LYCTX, "node1", NULL, "my-module", &root), LY_SUCCESS);
assert_null(root->schema);
opq = (struct lyd_node_opaq *)root;
assert_string_equal(opq->name.name, "node1");
@@ -212,20 +177,18 @@
assert_ptr_equal(opq->parent, root);
lyd_free_tree(root);
-
- *state = NULL;
}
static void
test_path(void **state)
{
- *state = test_path;
-
LY_ERR ret;
struct lyd_node *root, *node, *parent;
+ UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, NULL);
+
/* create 2 nodes */
- ret = lyd_new_path2(NULL, ctx, "/a:c/x[.='val']", "vvv", 0, 0, &root, &node);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:c/x[.='val']", "vvv", 0, 0, &root, &node);
assert_int_equal(ret, LY_SUCCESS);
assert_non_null(root);
assert_string_equal(root->schema->name, "c");
@@ -250,22 +213,22 @@
lyd_free_tree(root);
/* try LYD_NEWOPT_OPAQ */
- ret = lyd_new_path2(NULL, ctx, "/a:l1", NULL, 0, 0, NULL, NULL);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:l1", NULL, 0, 0, NULL, NULL);
assert_int_equal(ret, LY_EINVAL);
- logbuf_assert("Predicate missing for list \"l1\" in path.");
+ CHECK_LOG_CTX("Predicate missing for list \"l1\" in path.", NULL);
- ret = lyd_new_path2(NULL, ctx, "/a:l1", NULL, 0, LYD_NEW_PATH_OPAQ, NULL, &root);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:l1", NULL, 0, LYD_NEW_PATH_OPAQ, NULL, &root);
assert_int_equal(ret, LY_SUCCESS);
assert_non_null(root);
assert_null(root->schema);
lyd_free_tree(root);
- ret = lyd_new_path2(NULL, ctx, "/a:foo", NULL, 0, 0, NULL, NULL);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:foo", NULL, 0, 0, NULL, NULL);
assert_int_equal(ret, LY_EVALID);
- logbuf_assert("Invalid empty uint16 value. /a:foo");
+ CHECK_LOG_CTX("Invalid empty uint16 value.", "/a:foo");
- ret = lyd_new_path2(NULL, ctx, "/a:foo", NULL, 0, LYD_NEW_PATH_OPAQ, NULL, &root);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:foo", NULL, 0, LYD_NEW_PATH_OPAQ, NULL, &root);
assert_int_equal(ret, LY_SUCCESS);
assert_non_null(root);
assert_null(root->schema);
@@ -273,7 +236,7 @@
lyd_free_tree(root);
/* try LYD_NEWOPT_UPDATE */
- ret = lyd_new_path2(NULL, ctx, "/a:l2[1]/c/x", "val", 0, 0, &root, &node);
+ ret = lyd_new_path2(NULL, UTEST_LYCTX, "/a:l2[1]/c/x", "val", 0, 0, &root, &node);
assert_int_equal(ret, LY_SUCCESS);
assert_non_null(root);
assert_string_equal(node->schema->name, "x");
@@ -293,17 +256,15 @@
assert_string_equal("val2", LYD_CANON_VALUE(node));
lyd_free_tree(root);
-
- *state = NULL;
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_top_level, setup, teardown),
- cmocka_unit_test_setup_teardown(test_opaq, setup, teardown),
- cmocka_unit_test_setup_teardown(test_path, setup, teardown),
+ UTEST(test_top_level),
+ UTEST(test_opaq),
+ UTEST(test_path),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_parser_json.c b/tests/utests/data/test_parser_json.c
index 12a5d87..77c8677 100644
--- a/tests/utests/data/test_parser_json.c
+++ b/tests/utests/data/test_parser_json.c
@@ -11,6 +11,8 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include "context.h"
#include "in.h"
@@ -20,42 +22,11 @@
#include "tests/config.h"
#include "tree_data_internal.h"
#include "tree_schema.h"
-#include "utests.h"
-
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
-
-struct ly_ctx *ctx; /* context for tests */
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
static int
setup(void **state)
{
- (void) state; /* unused */
-
- const char *schema_a = "module a {namespace urn:tests:a;prefix a;yang-version 1.1; import ietf-yang-metadata {prefix md;}"
+ const char *schema = "module a {namespace urn:tests:a;prefix a;yang-version 1.1; import ietf-yang-metadata {prefix md;}"
"md:annotation hint { type int8;}"
"list l1 { key \"a b c\"; leaf a {type string;} leaf b {type string;} leaf c {type int16;} leaf d {type string;}}"
"leaf foo { type string;}"
@@ -70,107 +41,74 @@
"leaf foo2 { type string; default \"default-val\"; }"
"leaf foo3 { type uint32; }"
"notification n2;}";
- const struct lys_module *mod;
- const char *feats[] = {"writable-running", NULL};
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
+ UTEST_SETUP;
- assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &ctx));
- assert_non_null((mod = ly_ctx_load_module(ctx, "ietf-netconf", "2011-06-01", feats)));
- assert_non_null(ly_ctx_load_module(ctx, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_a, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
return 0;
}
-static int
-teardown(void **state)
-{
-#if ENABLE_LOGGER_CHECKING
- if (*state) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#else
- (void) state; /* unused */
-#endif
+#define CHECK_PARSE_LYD(INPUT, PARSE_OPTION, VALIDATE_OPTION, TREE) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_JSON, PARSE_OPTION, VALIDATE_OPTION, LY_SUCCESS, TREE)
- ly_ctx_destroy(ctx, NULL);
- ctx = NULL;
+#define PARSER_CHECK_ERROR(INPUT, PARSE_OPTION, VALIDATE_OPTION, MODEL, RET_VAL, ERR_MESSAGE, ERR_PATH) \
+ assert_int_equal(RET_VAL, lyd_parse_data_mem(UTEST_LYCTX, INPUT, LYD_JSON, PARSE_OPTION, VALIDATE_OPTION, &MODEL));\
+ CHECK_LOG_CTX(ERR_MESSAGE, ERR_PATH);\
+ assert_null(MODEL)
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
+#define CHECK_LYD_STRING(IN_MODEL, PRINT_OPTION, TEXT) \
+ CHECK_LYD_STRING_PARAM(IN_MODEL, TEXT, LYD_JSON, PRINT_OPTION)
static void
test_leaf(void **state)
{
- *state = test_leaf;
-
- const char *data = "{\"a:foo\":\"foo value\"}";
struct lyd_node *tree;
struct lyd_node_term *leaf;
+ const char *data;
- char *printed;
- struct ly_out *out;
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo", tree->schema->name);
+ data = "{\"a:foo\":\"foo value\"}";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "foo", 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("foo value", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "foo value");
- assert_int_equal(LYS_LEAF, tree->next->next->schema->nodetype);
- assert_string_equal("foo2", tree->next->next->schema->name);
+ CHECK_LYSC_NODE(tree->next->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree->next->next;
- assert_string_equal("default-val", leaf->value.canonical);
+
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_true(leaf->flags & LYD_DEFAULT);
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* make foo2 explicit */
data = "{\"a:foo2\":\"default-val\"}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo2", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("default-val", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_false(leaf->flags & LYD_DEFAULT);
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* parse foo2 but make it implicit */
data = "{\"a:foo2\":\"default-val\",\"@a:foo2\":{\"ietf-netconf-with-defaults:default\":true}}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo2", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("default-val", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_true(leaf->flags & LYD_DEFAULT);
/* TODO default values
@@ -182,461 +120,315 @@
/* multiple meatadata hint and unknown metadata xxx supposed to be skipped since it is from missing schema */
data = "{\"@a:foo\":{\"a:hint\":1,\"a:hint\":2,\"x:xxx\":{\"value\":\"/x:no/x:yes\"}},\"a:foo\":\"xxx\"}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo", tree->schema->name);
- assert_non_null(tree->meta);
- assert_string_equal("hint", tree->meta->name);
- assert_int_equal(LY_TYPE_INT8, tree->meta->value.realtype->basetype);
- assert_string_equal("1", tree->meta->value.canonical);
- assert_int_equal(1, tree->meta->value.int8);
- assert_ptr_equal(tree, tree->meta->parent);
- assert_non_null(tree->meta->next);
- assert_string_equal("hint", tree->meta->next->name);
- assert_int_equal(LY_TYPE_INT8, tree->meta->next->value.realtype->basetype);
- assert_string_equal("2", tree->meta->next->value.canonical);
- assert_int_equal(2, tree->meta->next->value.int8);
- assert_ptr_equal(tree, tree->meta->next->parent);
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "foo", 1, LYS_LEAF, 0, 0, NULL, 0);
+ CHECK_LYD_META(tree->meta, 1, "hint", 1, 1, INT8, "1", 1);
+ CHECK_LYD_META(tree->meta->next, 1, "hint", 0, 1, INT8, "2", 2);
assert_null(tree->meta->next->next);
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, "{\"a:foo\":\"xxx\",\"@a:foo\":{\"a:hint\":1,\"a:hint\":2}}");
- ly_out_free(out, NULL, 1);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS,
+ "{\"a:foo\":\"xxx\",\"@a:foo\":{\"a:hint\":1,\"a:hint\":2}}");
lyd_free_all(tree);
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Unknown (or not implemented) YANG module \"x\" for metadata \"x:xxx\". /a:foo");
+ PARSER_CHECK_ERROR(data, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Unknown (or not implemented) YANG module \"x\" for metadata \"x:xxx\".", "/a:foo");
/* missing referenced metadata node */
- data = "{\"@a:foo\" : { \"a:hint\" : 1 }}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Missing JSON data instance to be coupled with @a:foo metadata. /");
+ PARSER_CHECK_ERROR("{\"@a:foo\" : { \"a:hint\" : 1 }}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Missing JSON data instance to be coupled with @a:foo metadata.", "/");
/* missing namespace for meatadata*/
- data = "{\"a:foo\" : \"value\", \"@a:foo\" : { \"hint\" : 1 }}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Metadata in JSON must be namespace-qualified, missing prefix for \"hint\". /a:foo");
-
- *state = NULL;
+ PARSER_CHECK_ERROR("{\"a:foo\" : \"value\", \"@a:foo\" : { \"hint\" : 1 }}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Metadata in JSON must be namespace-qualified, missing prefix for \"hint\".", "/a:foo");
}
static void
test_leaflist(void **state)
{
- *state = test_leaflist;
-
- const char *data = "{\"a:ll1\":[10,11]}";
+ const char *data;
struct lyd_node *tree;
struct lyd_node_term *ll;
- char *printed;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ data = "{\"a:ll1\":[10,11]}";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAFLIST, tree->schema->nodetype);
- assert_string_equal("ll1", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree;
- assert_string_equal("10", ll->value.canonical);
+ CHECK_LYD_VALUE(ll->value, UINT8, "10", 10);
assert_non_null(tree->next);
- assert_int_equal(LYS_LEAFLIST, tree->next->schema->nodetype);
- assert_string_equal("ll1", tree->next->schema->name);
+ CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree->next;
- assert_string_equal("11", ll->value.canonical);
+ CHECK_LYD_VALUE(ll->value, UINT8, "11", 11);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* simple metadata */
data = "{\"a:ll1\":[10,11],\"@a:ll1\":[null,{\"a:hint\":2}]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAFLIST, tree->schema->nodetype);
- assert_string_equal("ll1", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree;
- assert_string_equal("10", ll->value.canonical);
+ CHECK_LYD_VALUE(ll->value, UINT8, "10", 10);
assert_null(ll->meta);
assert_non_null(tree->next);
- assert_int_equal(LYS_LEAFLIST, tree->next->schema->nodetype);
- assert_string_equal("ll1", tree->next->schema->name);
+ CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree->next;
- assert_string_equal("11", ll->value.canonical);
- assert_non_null(ll->meta);
- assert_string_equal("2", ll->meta->value.canonical);
+ CHECK_LYD_VALUE(ll->value, UINT8, "11", 11);
+ CHECK_LYD_META(ll->meta, 1, "hint", 0, 1, INT8, "2", 2);
assert_null(ll->meta->next);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* multiple meatadata hint and unknown metadata xxx supposed to be skipped since it is from missing schema */
- data = "{\"@a:ll1\" : [{\"a:hint\" : 1, \"x:xxx\" : { \"value\" : \"/x:no/x:yes\" }, \"a:hint\" : 10},null,{\"a:hint\" : 3}], \"a:ll1\" : [1,2,3]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ data = "{\"@a:ll1\" : [{\"a:hint\" : 1, \"x:xxx\" : { \"value\" : \"/x:no/x:yes\" }, "
+ "\"a:hint\" : 10},null,{\"a:hint\" : 3}], \"a:ll1\" : [1,2,3]}";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAFLIST, tree->schema->nodetype);
- assert_string_equal("ll1", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree;
- assert_string_equal("1", ll->value.canonical);
- assert_non_null(ll->meta);
- assert_string_equal("hint", ll->meta->name);
- assert_int_equal(LY_TYPE_INT8, ll->meta->value.realtype->basetype);
- assert_string_equal("1", ll->meta->value.canonical);
- assert_int_equal(1, ll->meta->value.int8);
- assert_ptr_equal(ll, ll->meta->parent);
- assert_non_null(ll->meta->next);
- assert_string_equal("hint", ll->meta->next->name);
- assert_int_equal(LY_TYPE_INT8, ll->meta->next->value.realtype->basetype);
- assert_string_equal("10", ll->meta->next->value.canonical);
- assert_int_equal(10, ll->meta->next->value.int8);
- assert_ptr_equal(ll, ll->meta->next->parent);
- assert_null(ll->meta->next->next);
+ CHECK_LYD_VALUE(ll->value, UINT8, "1", 1);
+ CHECK_LYD_META(ll->meta, 1, "hint", 1, 1, INT8, "1", 1);
+ CHECK_LYD_META(ll->meta->next, 1, "hint", 0, 1, INT8, "10", 10);
assert_non_null(tree->next);
- assert_int_equal(LYS_LEAFLIST, tree->next->schema->nodetype);
- assert_string_equal("ll1", tree->next->schema->name);
+ CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree->next;
- assert_string_equal("2", ll->value.canonical);
+ CHECK_LYD_VALUE(ll->value, UINT8, "2", 2);
assert_null(ll->meta);
assert_non_null(tree->next->next);
- assert_int_equal(LYS_LEAFLIST, tree->next->next->schema->nodetype);
- assert_string_equal("ll1", tree->next->next->schema->name);
+ CHECK_LYSC_NODE(tree->next->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "ll1",
+ 1, LYS_LEAFLIST, 0, 0, NULL, 0);
ll = (struct lyd_node_term *)tree->next->next;
- assert_string_equal("3", ll->value.canonical);
- assert_non_null(ll->meta);
- assert_string_equal("hint", ll->meta->name);
- assert_int_equal(LY_TYPE_INT8, ll->meta->value.realtype->basetype);
- assert_string_equal("3", ll->meta->value.canonical);
- assert_int_equal(3, ll->meta->value.int8);
- assert_ptr_equal(ll, ll->meta->parent);
+ CHECK_LYD_VALUE(ll->value, UINT8, "3", 3);
+ CHECK_LYD_META(ll->meta, 1, "hint", 0, 1, INT8, "3", 3);
assert_null(ll->meta->next);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, "{\"a:ll1\":[1,2,3],\"@a:ll1\":[{\"a:hint\":1,\"a:hint\":10},null,{\"a:hint\":3}]}");
- ly_out_free(out, NULL, 1);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS,
+ "{\"a:ll1\":[1,2,3],\"@a:ll1\":[{\"a:hint\":1,\"a:hint\":10},null,{\"a:hint\":3}]}");
lyd_free_all(tree);
/* missing referenced metadata node */
- data = "{\"@a:ll1\":[{\"a:hint\":1}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Missing JSON data instance to be coupled with @a:ll1 metadata. /");
+ PARSER_CHECK_ERROR("{\"@a:ll1\":[{\"a:hint\":1}]}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Missing JSON data instance to be coupled with @a:ll1 metadata.", "/");
- data = "{\"a:ll1\":[1],\"@a:ll1\":[{\"a:hint\":1},{\"a:hint\":2}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Missing JSON data instance no. 2 of a:ll1 to be coupled with metadata. /");
+ PARSER_CHECK_ERROR("{\"a:ll1\":[1],\"@a:ll1\":[{\"a:hint\":1},{\"a:hint\":2}]}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Missing JSON data instance no. 2 of a:ll1 to be coupled with metadata.", "/");
- data = "{\"@a:ll1\":[{\"a:hint\":1},{\"a:hint\":2},{\"a:hint\":3}],\"a:ll1\" : [1, 2]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Missing 3rd JSON data instance to be coupled with @a:ll1 metadata. /");
-
- *state = NULL;
+ PARSER_CHECK_ERROR("{\"@a:ll1\":[{\"a:hint\":1},{\"a:hint\":2},{\"a:hint\":3}],\"a:ll1\" : [1, 2]}", 0, LYD_VALIDATE_PRESENT,
+ tree, LY_EVALID, "Missing 3rd JSON data instance to be coupled with @a:ll1 metadata.", "/");
}
static void
test_anydata(void **state)
{
- *state = test_anydata;
-
const char *data;
- char *str;
struct lyd_node *tree;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
data = "{\"a:any\":{\"x:element1\":{\"element2\":\"/a:some/a:path\",\"list\":[{},{\"key\":\"a\"}]}}}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_ANYDATA, tree->schema->nodetype);
- assert_string_equal("any", tree->schema->name);
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
-
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_SET_ENUM | LYS_CONFIG_R | LYS_YIN_ARGUMENT, 1, "any",
+ 1, LYS_ANYDATA, 0, 0, NULL, 0);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_list(void **state)
{
- *state = test_list;
-
- const char *data = "{\"a:l1\":[{\"a\":\"one\",\"b\":\"one\",\"c\":1}]}";
+ const char *data;
struct lyd_node *tree, *iter;
struct lyd_node_inner *list;
struct lyd_node_term *leaf;
- char *printed;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
-
/* check hashes */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ data = "{\"a:l1\":[{\"a\":\"one\",\"b\":\"one\",\"c\":1}]}";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1",
+ 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
LY_LIST_FOR(list->child, iter) {
assert_int_not_equal(0, iter->hash);
}
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* missing keys */
- data = "{ \"a:l1\": [ {\"c\" : 1, \"b\" : \"b\"}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"a\". /a:l1[b='b'][c='1']");
+ PARSER_CHECK_ERROR("{ \"a:l1\": [ {\"c\" : 1, \"b\" : \"b\"}]}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"a\".", "/a:l1[b='b'][c='1']");
- data = "{ \"a:l1\": [ {\"a\" : \"a\"}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"b\". /a:l1[a='a']");
+ PARSER_CHECK_ERROR("{ \"a:l1\": [ {\"a\" : \"a\"}]}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"b\".", "/a:l1[a='a']");
- data = "{ \"a:l1\": [ {\"b\" : \"b\", \"a\" : \"a\"}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"c\". /a:l1[a='a'][b='b']");
+ PARSER_CHECK_ERROR("{ \"a:l1\": [ {\"b\" : \"b\", \"a\" : \"a\"}]}", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"c\".", "/a:l1[a='a'][b='b']");
/* key duplicate */
- data = "{ \"a:l1\": [ {\"c\" : 1, \"b\" : \"b\", \"a\" : \"a\", \"c\" : 1}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Duplicate instance of \"c\". /a:l1[a='a'][b='b'][c='1'][c='1']/c");
+ PARSER_CHECK_ERROR("{ \"a:l1\": [ {\"c\" : 1, \"b\" : \"b\", \"a\" : \"a\", \"c\" : 1}]}", 0, LYD_VALIDATE_PRESENT,
+ tree, LY_EVALID, "Duplicate instance of \"c\".", "/a:l1[a='a'][b='b'][c='1'][c='1']/c");
/* keys order, in contrast to XML, JSON accepts keys in any order even in strict mode */
- logbuf_clean();
- data = "{ \"a:l1\": [ {\"d\" : \"d\", \"a\" : \"a\", \"c\" : 1, \"b\" : \"b\"}]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ CHECK_PARSE_LYD("{ \"a:l1\": [ {\"d\" : \"d\", \"a\" : \"a\", \"c\" : 1, \"b\" : \"b\"}]}", 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1",
+ 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
assert_non_null(leaf = (struct lyd_node_term *)list->child);
- assert_string_equal("a", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("b", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "b", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("c", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "c", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("d", leaf->schema->name);
- logbuf_assert("");
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "d", 0, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LOG_CTX(NULL, NULL);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, "{\"a:l1\":[{\"a\":\"a\",\"b\":\"b\",\"c\":1,\"d\":\"d\"}]}");
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS,
+ "{\"a:l1\":[{\"a\":\"a\",\"b\":\"b\",\"c\":1,\"d\":\"d\"}]}");
lyd_free_all(tree);
/* */
- data = "{\"a:l1\":[{\"c\":1,\"b\":\"b\",\"a\":\"a\"}]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ CHECK_PARSE_LYD("{\"a:l1\":[{\"c\":1,\"b\":\"b\",\"a\":\"a\"}]}", LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1",
+ 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
assert_non_null(leaf = (struct lyd_node_term *)list->child);
- assert_string_equal("a", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "a",
+ 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("b", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "b",
+ 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("c", leaf->schema->name);
- logbuf_assert("");
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "c",
+ 1, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LOG_CTX(NULL, NULL);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, "{\"a:l1\":[{\"a\":\"a\",\"b\":\"b\",\"c\":1}]}");
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS,
+ "{\"a:l1\":[{\"a\":\"a\",\"b\":\"b\",\"c\":1}]}");
lyd_free_all(tree);
data = "{\"a:cp\":{\"@\":{\"a:hint\":1}}}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
- assert_string_equal("cp", tree->schema->name);
- assert_non_null(tree->meta);
- assert_string_equal("hint", tree->meta->name);
- assert_string_equal("1", tree->meta->value.canonical);
- assert_ptr_equal(tree, tree->meta->parent);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
+ CHECK_LYD_META(tree->meta, 1, "hint", 0, 1, INT8, "1", 1);
assert_null(tree->meta->next);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_free(out, NULL, 1);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
-
- *state = NULL;
}
static void
test_container(void **state)
{
- *state = test_container;
-
- const char *data = "{\"a:c\":{}}";
+ const char *data;
struct lyd_node *tree;
struct lyd_node_inner *cont;
- char *printed;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
- assert_string_equal("c", tree->schema->name);
+ CHECK_PARSE_LYD("{\"a:c\":{}}", 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
cont = (struct lyd_node_inner *)tree;
assert_true(cont->flags & LYD_DEFAULT);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, "{}");
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, "{}");
lyd_free_all(tree);
data = "{\"a:cp\":{}}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
- assert_string_equal("cp", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
cont = (struct lyd_node_inner *)tree;
assert_false(cont->flags & LYD_DEFAULT);
- lyd_print_all(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(printed, data);
- ly_out_free(out, NULL, 1);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
-
- *state = NULL;
}
static void
test_opaq(void **state)
{
- *state = test_opaq;
-
const char *data;
- char *str;
struct lyd_node *tree;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
/* invalid value, no flags */
data = "{\"a:foo3\":[null]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Invalid non-number-encoded uint32 value \"\". /a:foo3");
- assert_null(tree);
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Invalid non-number-encoded uint32 value \"\".", "/a:foo3");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "foo3");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_PREF_JSON, "foo3", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* missing key, no flags */
data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\",\"d\":\"val_d\"}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"c\". /a:l1[a='val_a'][b='val_b']");
- assert_null(tree);
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"c\".", "/a:l1[a='val_a'][b='val_b']");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* invalid key, no flags */
data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\",\"c\":\"val_c\"}]}";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Invalid non-number-encoded int16 value \"val_c\". /a:l1/c");
- assert_null(tree);
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Invalid non-number-encoded int16 value \"val_c\".", "/a:l1/c");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\",\"c\":{\"val\":\"val_c\"}}]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\"}]}";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_JSON, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_rpc(void **state)
{
- *state = test_rpc;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *op;
const struct lyd_node *node;
+ const char *dsc = "The <edit-config> operation loads all or part of a specified\n"
+ "configuration to the specified target configuration.";
+ const char *ref = "RFC 6241, Section 7.2";
+ const char *feats[] = {"writable-running", NULL};
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
+ assert_non_null((ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf", "2011-06-01", feats)));
data = "{\"ietf-netconf:rpc\":{\"edit-config\":{"
"\"target\":{\"running\":[null]},"
@@ -644,177 +436,129 @@
"\"a:l1\":[{\"@\":{\"ietf-netconf:operation\":\"replace\"},\"a\":\"val_a\",\"b\":\"val_b\",\"c\":\"val_c\"}]}"
"}}}";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_JSON, &tree, &op));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_JSON, &tree, &op));
ly_in_free(in, 0);
assert_non_null(op);
- assert_string_equal(op->schema->name, "edit-config");
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc");
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, dsc, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "edit-config", LYS_RPC,
+ 0, 0, 0, 0, 0, ref, 0);
+
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "rpc", 0, 0, NULL, 0, "");
/* TODO support generic attributes in JSON ?
assert_non_null(((struct lyd_node_opaq *)tree)->attr);
*/
+
node = lyd_child(tree);
- assert_string_equal(node->schema->name, "edit-config");
+ CHECK_LYSC_ACTION((struct lysc_action *)node->schema, dsc, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "edit-config", LYS_RPC,
+ 0, 0, 0, 0, 0, ref, 0);
node = lyd_child(node)->next;
- assert_string_equal(node->schema->name, "config");
+ CHECK_LYSC_NODE(node->schema, "Inline Config content.", 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "config",
+ 0, LYS_ANYXML, 1, 0, NULL, 0);
node = ((struct lyd_node_any *)node)->value.tree;
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "cp");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
node = lyd_child(node);
/* z has no value */
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "z");
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_PREF_JSON, "z", 0, 0, NULL, 0, "");
node = node->parent->next;
/* l1 key c has invalid value so it is at the end */
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "l1");
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL, 0, "");
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_action(void **state)
{
- *state = test_action;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *op;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
data = "{\"ietf-netconf:rpc\":{\"yang:action\":{\"a:c\":{\"act\":{\"al\":\"value\"}}}}}";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_JSON, &tree, &op));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_JSON, &tree, &op));
ly_in_free(in, 0);
assert_non_null(op);
- assert_string_equal(op->schema->name, "act");
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, NULL, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "act", LYS_ACTION,
+ 1, 0, 0, 1, 0, NULL, 0);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc");
- assert_null(((struct lyd_node_opaq *)tree)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "rpc", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "action");
- assert_null(((struct lyd_node_opaq *)node)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0, 0x1, LY_PREF_JSON, "action", 0, 0, NULL, 0, "");
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_notification(void **state)
{
- *state = test_notification;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *ntf;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
data = "{\"ietf-restconf:notification\":{\"eventTime\":\"2037-07-08T00:01:00Z\",\"a:c\":{\"n1\":{\"nl\":\"value\"}}}}";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_notif(ctx, in, LYD_JSON, &tree, &ntf));
+ assert_int_equal(LY_SUCCESS, lyd_parse_notif(UTEST_LYCTX, in, LYD_JSON, &tree, &ntf));
ly_in_free(in, 0);
assert_non_null(ntf);
- assert_string_equal(ntf->schema->name, "n1");
+ CHECK_LYSC_NOTIF((struct lysc_notif *)ntf->schema, 1, NULL, 0, 0x4, 1, 0, "n1", 1, 0, NULL, 0);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "notification");
- assert_null(((struct lyd_node_opaq *)tree)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "notification", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "eventTime");
- assert_string_equal(((struct lyd_node_opaq *)node)->value, "2037-07-08T00:01:00Z");
- assert_null(((struct lyd_node_opaq *)node)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0, 0, LY_PREF_JSON, "eventTime", 0, 0, NULL, 0, "2037-07-08T00:01:00Z");
node = node->next;
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "c");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0);
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* top-level notif without envelope */
data = "{\"a:n2\":{}}";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_notif(ctx, in, LYD_JSON, &tree, &ntf));
+ assert_int_equal(LY_SUCCESS, lyd_parse_notif(UTEST_LYCTX, in, LYD_JSON, &tree, &ntf));
ly_in_free(in, 0);
assert_non_null(ntf);
- assert_string_equal(ntf->schema->name, "n2");
+ CHECK_LYSC_NOTIF((struct lysc_notif *)ntf->schema, 0, NULL, 0, 0x4, 1, 0, "n2", 0, 0, NULL, 0);
assert_non_null(tree);
assert_ptr_equal(ntf, tree);
- lyd_print_tree(out, tree, LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_reply(void **state)
{
- *state = test_reply;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *request, *tree, *op;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
data = "{\"a:c\":{\"act\":{\"al\":\"value\"}}}";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_JSON, &request, NULL));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_JSON, &request, NULL));
ly_in_free(in, 0);
data = "{\"ietf-netconf:rpc-reply\":{\"a:al\":25}}";
@@ -824,50 +568,39 @@
lyd_free_all(request);
assert_non_null(op);
- assert_string_equal(op->schema->name, "act");
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, NULL, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "act", LYS_ACTION,
+ 1, 0, 0, 1, 0, NULL, 0);
node = lyd_child(op);
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "al");
- assert_true(node->schema->flags & LYS_CONFIG_R);
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_R | LYS_STATUS_CURR, 1, "al", 0, LYS_LEAF, 1, 0, NULL, 0);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc-reply");
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "rpc-reply", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "c");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0);
/* TODO print only rpc-reply node and then output subtree */
- lyd_print_tree(out, lyd_child(op), LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, "{\"a:al\":25}");
- ly_out_reset(out);
- lyd_print_tree(out, lyd_child(tree), LYD_JSON, LYD_PRINT_SHRINK);
- assert_string_equal(str, "{\"a:c\":{\"act\":{\"al\":25}}}");
- ly_out_reset(out);
+ CHECK_LYD_STRING(lyd_child(op), LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, "{\"a:al\":25}");
+ CHECK_LYD_STRING(lyd_child(tree), LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, "{\"a:c\":{\"act\":{\"al\":25}}}");
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_leaf, setup, teardown),
- cmocka_unit_test_setup_teardown(test_leaflist, setup, teardown),
- cmocka_unit_test_setup_teardown(test_anydata, setup, teardown),
- cmocka_unit_test_setup_teardown(test_list, setup, teardown),
- cmocka_unit_test_setup_teardown(test_container, setup, teardown),
- cmocka_unit_test_setup_teardown(test_opaq, setup, teardown),
- cmocka_unit_test_setup_teardown(test_rpc, setup, teardown),
- cmocka_unit_test_setup_teardown(test_action, setup, teardown),
- cmocka_unit_test_setup_teardown(test_notification, setup, teardown),
- cmocka_unit_test_setup_teardown(test_reply, setup, teardown),
+ UTEST(test_leaf, setup),
+ UTEST(test_leaflist, setup),
+ UTEST(test_anydata, setup),
+ UTEST(test_list, setup),
+ UTEST(test_container, setup),
+ UTEST(test_opaq, setup),
+ UTEST(test_rpc, setup),
+ UTEST(test_action, setup),
+ UTEST(test_notification, setup),
+ UTEST(test_reply, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_parser_xml.c b/tests/utests/data/test_parser_xml.c
index 2fe71c6..ba06db6 100644
--- a/tests/utests/data/test_parser_xml.c
+++ b/tests/utests/data/test_parser_xml.c
@@ -3,7 +3,7 @@
* @author: Radek Krejci <rkrejci@cesnet.cz>
* @brief unit tests for functions from parser_xml.c
*
- * Copyright (c) 2019 CESNET, z.s.p.o.
+ * Copyright (c) 2019-2020 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
@@ -11,51 +11,21 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include "context.h"
#include "in.h"
#include "out.h"
#include "parser_data.h"
#include "printer_data.h"
-#include "tests/config.h"
#include "tree_data_internal.h"
#include "tree_schema.h"
-#include "utests.h"
-
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
-
-struct ly_ctx *ctx; /* context for tests */
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
static int
setup(void **state)
{
- (void) state; /* unused */
-
- const char *schema_a =
+ const char *schema =
"module a {\n"
" namespace urn:tests:a;\n"
" prefix a;\n"
@@ -76,160 +46,119 @@
" leaf foo2 { type string; default \"default-val\"; }\n"
" leaf foo3 { type uint32; }\n"
" notification n2;}";
- const struct lys_module *mod;
- const char *feats[] = {"writable-running", NULL};
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
+ UTEST_SETUP;
- assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &ctx));
- assert_non_null((mod = ly_ctx_load_module(ctx, "ietf-netconf", "2011-06-01", feats)));
- assert_non_null(ly_ctx_load_module(ctx, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_a, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
return 0;
}
-static int
-teardown(void **state)
-{
-#if ENABLE_LOGGER_CHECKING
- if (*state) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#else
- (void) state; /* unused */
-#endif
+#define CHECK_PARSE_LYD(INPUT, PARSE_OPTION, VALIDATE_OPTION, TREE) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, PARSE_OPTION, VALIDATE_OPTION, LY_SUCCESS, TREE)
- ly_ctx_destroy(ctx, NULL);
- ctx = NULL;
+#define PARSER_CHECK_ERROR(INPUT, PARSE_OPTION, VALIDATE_OPTION, MODEL, RET_VAL, ERR_MESSAGE, ERR_PATH) \
+ assert_int_equal(RET_VAL, lyd_parse_data_mem(UTEST_LYCTX, INPUT, LYD_XML, PARSE_OPTION, VALIDATE_OPTION, &MODEL));\
+ CHECK_LOG_CTX(ERR_MESSAGE, ERR_PATH);\
+ assert_null(MODEL)
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
+#define CHECK_LYD_STRING(IN_MODEL, PRINT_OPTION, TEXT) \
+ CHECK_LYD_STRING_PARAM(IN_MODEL, TEXT, LYD_XML, PRINT_OPTION)
static void
test_leaf(void **state)
{
- *state = test_leaf;
-
const char *data = "<foo xmlns=\"urn:tests:a\">foo value</foo>";
struct lyd_node *tree;
struct lyd_node_term *leaf;
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("foo value", leaf->value.canonical);
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LYS_LEAF, tree->next->next->schema->nodetype);
- assert_string_equal("foo2", tree->next->next->schema->name);
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "foo", 1, LYS_LEAF, 0, 0, NULL, 0);
+ leaf = (struct lyd_node_term *)tree;
+ CHECK_LYD_VALUE(leaf->value, STRING, "foo value");
+
+ CHECK_LYSC_NODE(tree->next->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree->next->next;
- assert_string_equal("default-val", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_true(leaf->flags & LYD_DEFAULT);
lyd_free_all(tree);
/* make foo2 explicit */
data = "<foo2 xmlns=\"urn:tests:a\">default-val</foo2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo2", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("default-val", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_false(leaf->flags & LYD_DEFAULT);
lyd_free_all(tree);
/* parse foo2 but make it implicit, skip metadata xxx from missing schema */
- data = "<foo2 xmlns=\"urn:tests:a\" xmlns:wd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" wd:default=\"true\" xmlns:x=\"urn:x\" x:xxx=\"false\">default-val</foo2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ data = "<foo2 xmlns=\"urn:tests:a\" xmlns:wd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" "
+ "wd:default=\"true\" xmlns:x=\"urn:x\" x:xxx=\"false\">default-val</foo2>";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("foo2", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_SET_DFLT, 1, "foo2",
+ 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("default-val", leaf->value.canonical);
+ CHECK_LYD_VALUE(leaf->value, STRING, "default-val");
assert_true(leaf->flags & LYD_DEFAULT);
lyd_free_all(tree);
-
- *state = NULL;
}
static void
test_anydata(void **state)
{
- *state = test_anydata;
-
const char *data;
- char *str;
struct lyd_node *tree;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
- data =
- "<any xmlns=\"urn:tests:a\">\n"
+ data = "<any xmlns=\"urn:tests:a\">\n"
" <element1>\n"
" <x:element2 x:attr2=\"test\" xmlns:a=\"urn:tests:a\" xmlns:x=\"urn:x\">a:data</x:element2>\n"
" </element1>\n"
" <element1a/>\n"
"</any>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_ANYDATA, tree->schema->nodetype);
- assert_string_equal("any", tree->schema->name);
-
- lyd_print_tree(out, tree, LYD_XML, 0);
- assert_string_equal(str,
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_R | LYS_STATUS_CURR | LYS_SET_CONFIG, 1, "any",
+ 1, LYS_ANYDATA, 0, 0, NULL, 0);
+ const char *data_expected =
"<any xmlns=\"urn:tests:a\">\n"
" <element1>\n"
" <element2 xmlns=\"urn:x\" xmlns:x=\"urn:x\" x:attr2=\"test\" xmlns:a=\"urn:tests:a\">a:data</element2>\n"
" </element1>\n"
" <element1a/>\n"
- "</any>\n");
- ly_out_reset(out);
+ "</any>\n";
+
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data_expected);
lyd_free_all(tree);
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_list(void **state)
{
- *state = test_list;
-
- const char *data = "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b><c>1</c></l1>";
+ const char *data;
struct lyd_node *tree, *iter;
struct lyd_node_inner *list;
struct lyd_node_term *leaf;
/* check hashes */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ data = "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b><c>1</c></l1>";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1",
+ 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
LY_LIST_FOR(list->child, iter) {
assert_int_not_equal(0, iter->hash);
@@ -237,187 +166,146 @@
lyd_free_all(tree);
/* missing keys */
- data = "<l1 xmlns=\"urn:tests:a\"><c>1</c><b>b</b></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"a\". /a:l1[b='b'][c='1']");
+ PARSER_CHECK_ERROR("<l1 xmlns=\"urn:tests:a\"><c>1</c><b>b</b></l1>", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"a\".", "/a:l1[b='b'][c='1']");
- data = "<l1 xmlns=\"urn:tests:a\"><a>a</a></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"b\". /a:l1[a='a']");
+ PARSER_CHECK_ERROR("<l1 xmlns=\"urn:tests:a\"><a>a</a></l1>", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"b\".", "/a:l1[a='a']");
- data = "<l1 xmlns=\"urn:tests:a\"><b>b</b><a>a</a></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"c\". /a:l1[a='a'][b='b']");
+ PARSER_CHECK_ERROR("<l1 xmlns=\"urn:tests:a\"><b>b</b><a>a</a></l1>", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"c\".", "/a:l1[a='a'][b='b']");
/* key duplicate */
- data = "<l1 xmlns=\"urn:tests:a\"><c>1</c><b>b</b><a>a</a><c>1</c></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Duplicate instance of \"c\". /a:l1[a='a'][b='b'][c='1'][c='1']/c");
+ PARSER_CHECK_ERROR("<l1 xmlns=\"urn:tests:a\"><c>1</c><b>b</b><a>a</a><c>1</c></l1>", 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Duplicate instance of \"c\".", "/a:l1[a='a'][b='b'][c='1'][c='1']/c");
/* keys order */
- data = "<l1 xmlns=\"urn:tests:a\"><d>d</d><a>a</a><c>1</c><b>b</b></l1>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ CHECK_PARSE_LYD("<l1 xmlns=\"urn:tests:a\"><d>d</d><a>a</a><c>1</c><b>b</b></l1>", 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1",
+ 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
assert_non_null(leaf = (struct lyd_node_term *)list->child);
- assert_string_equal("a", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("b", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "b", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("c", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "c", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("d", leaf->schema->name);
- logbuf_assert("Invalid position of the key \"b\" in a list.");
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "d", 0, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LOG_CTX("Invalid position of the key \"b\" in a list.", NULL);
lyd_free_all(tree);
data = "<l1 xmlns=\"urn:tests:a\"><c>1</c><b>b</b><a>a</a></l1>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_LIST, tree->schema->nodetype);
- assert_string_equal("l1", tree->schema->name);
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM, 1, "l1", 1, LYS_LIST, 0, 0, NULL, 0);
list = (struct lyd_node_inner *)tree;
assert_non_null(leaf = (struct lyd_node_term *)list->child);
- assert_string_equal("a", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("b", leaf->schema->name);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "b", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = (struct lyd_node_term *)leaf->next);
- assert_string_equal("c", leaf->schema->name);
- logbuf_assert("Invalid position of the key \"a\" in a list.");
- logbuf_clean();
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_KEY, 1, "c", 1, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LOG_CTX("Invalid position of the key \"a\" in a list.", NULL);
lyd_free_all(tree);
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_STRICT, 0, &tree));
- logbuf_assert("Invalid position of the key \"b\" in a list. Line number 1.");
-
- *state = NULL;
+ PARSER_CHECK_ERROR(data, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Invalid position of the key \"b\" in a list.", "Line number 1.");
}
static void
test_container(void **state)
{
- *state = test_container;
-
- const char *data = "<c xmlns=\"urn:tests:a\"/>";
struct lyd_node *tree;
struct lyd_node_inner *cont;
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
- assert_string_equal("c", tree->schema->name);
+ CHECK_PARSE_LYD("<c xmlns=\"urn:tests:a\"/>", 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0);
cont = (struct lyd_node_inner *)tree;
assert_true(cont->flags & LYD_DEFAULT);
lyd_free_all(tree);
- data = "<cp xmlns=\"urn:tests:a\"/>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD("<cp xmlns=\"urn:tests:a\"/>", 0, LYD_VALIDATE_PRESENT, tree);
assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
- assert_string_equal("cp", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
cont = (struct lyd_node_inner *)tree;
assert_false(cont->flags & LYD_DEFAULT);
lyd_free_all(tree);
-
- *state = NULL;
}
static void
test_opaq(void **state)
{
- *state = test_opaq;
-
const char *data;
- char *str;
struct lyd_node *tree;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
/* invalid value, no flags */
data = "<foo3 xmlns=\"urn:tests:a\"/>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Invalid empty uint32 value. /a:foo3");
- assert_null(tree);
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Invalid empty uint32 value.", "/a:foo3");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "foo3");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_XML, LYD_PRINT_SHRINK);
- assert_string_equal(str, "<foo3 xmlns=\"urn:tests:a\"/>");
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_PREF_XML, "foo3", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, "<foo3 xmlns=\"urn:tests:a\"/>\n");
lyd_free_all(tree);
/* missing key, no flags */
- data = "<l1 xmlns=\"urn:tests:a\"><a>val_a</a><b>val_b</b><d>val_d</d></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("List instance is missing its key \"c\". /a:l1[a='val_a'][b='val_b']");
- assert_null(tree);
+ data = "<l1 xmlns=\"urn:tests:a\">\n"
+ " <a>val_a</a>\n"
+ " <b>val_b</b>\n"
+ " <d>val_d</d>\n"
+ "</l1>\n";
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "List instance is missing its key \"c\".", "/a:l1[a='val_a'][b='val_b']");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_XML, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_XML, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* invalid key, no flags */
- data = "<l1 xmlns=\"urn:tests:a\"><a>val_a</a><b>val_b</b><c>val_c</c></l1>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Invalid int16 value \"val_c\". /a:l1/c");
- assert_null(tree);
+ data = "<l1 xmlns=\"urn:tests:a\">\n"
+ " <a>val_a</a>\n"
+ " <b>val_b</b>\n"
+ " <c>val_c</c>\n"
+ "</l1>\n";
+ PARSER_CHECK_ERROR(data, 0, LYD_VALIDATE_PRESENT, tree, LY_EVALID,
+ "Invalid int16 value \"val_c\".", "/a:l1/c");
/* opaq flag */
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "l1");
- assert_string_equal(((struct lyd_node_opaq *)tree)->value, "");
-
- lyd_print_tree(out, tree, LYD_XML, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_XML, "l1", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* opaq flag and fail */
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, "<a xmlns=\"ns\"><b>x</b><c xml:id=\"D\">1</c></a>", LYD_XML,
- LYD_PARSE_OPAQ, LYD_VALIDATE_PRESENT, &tree));
- logbuf_assert("Unknown XML prefix \"xml\". Line number 1.");
- assert_null(tree);
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
+ assert_int_equal(LY_EVALID, lyd_parse_data_mem(UTEST_LYCTX,
+ "<a xmlns=\"ns\">\n"
+ " <b>x</b>\n"
+ " <c xml:id=\"D\">1</c>\n"
+ "</a>\n",
+ LYD_XML, LYD_PARSE_OPAQ, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_LOG_CTX("Unknown XML prefix \"xml\".", "Line number 3.");
}
static void
test_rpc(void **state)
{
- *state = test_rpc;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *op;
const struct lyd_node *node;
+ const char *dsc = "The <edit-config> operation loads all or part of a specified\n"
+ "configuration to the specified target configuration.";
+ const char *ref = "RFC 6241, Section 7.2";
+ const char *feats[] = {"writable-running", NULL};
- struct ly_out *out;
+ assert_non_null((ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf", "2011-06-01", feats)));
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
- data =
- "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
+ data = "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
" <edit-config>\n"
" <target>\n"
" <running/>\n"
@@ -435,35 +323,39 @@
" </edit-config>\n"
"</rpc>\n";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_XML, &tree, &op));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_XML, &tree, &op));
ly_in_free(in, 0);
assert_non_null(op);
- assert_string_equal(op->schema->name, "edit-config");
+
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, dsc, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "edit-config", LYS_RPC,
+ 0, 0, 0, 0, 0, ref, 0);
assert_non_null(tree);
assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc");
- assert_non_null(((struct lyd_node_opaq *)tree)->attr);
+
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0x1, 0x1, LY_PREF_XML, "rpc", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_string_equal(node->schema->name, "edit-config");
+ CHECK_LYSC_ACTION((struct lysc_action *)node->schema, dsc, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "edit-config", LYS_RPC,
+ 0, 0, 0, 0, 0, ref, 0);
node = lyd_child(node)->next;
- assert_string_equal(node->schema->name, "config");
+ dsc = "Inline Config content.";
+ CHECK_LYSC_NODE(node->schema, dsc, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "config", 0, LYS_ANYXML, 1, 0, NULL, 0);
node = ((struct lyd_node_any *)node)->value.tree;
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "cp");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp",
+ 1, LYS_CONTAINER, 0, 0, NULL, 0);
+
node = lyd_child(node);
/* z has no value */
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "z");
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_PREF_XML, "z", 0, 0, NULL, 0, "");
node = node->parent->next;
/* l1 key c has invalid value so it is at the end */
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "l1");
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_PREF_XML, "l1", 0, 0, NULL, 0, "");
- lyd_print_tree(out, tree, LYD_XML, 0);
- assert_string_equal(str,
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS,
"<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
" <edit-config>\n"
" <target>\n"
@@ -481,34 +373,22 @@
" </config>\n"
" </edit-config>\n"
"</rpc>\n");
- ly_out_reset(out);
+
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_action(void **state)
{
- *state = test_action;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *op;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
- data =
- "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
+ data = "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
" <action xmlns=\"urn:ietf:params:xml:ns:yang:1\">\n"
" <c xmlns=\"urn:tests:a\">\n"
" <act>\n"
@@ -518,23 +398,18 @@
" </action>\n"
"</rpc>\n";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_XML, &tree, &op));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_XML, &tree, &op));
ly_in_free(in, 0);
assert_non_null(op);
- assert_string_equal(op->schema->name, "act");
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, NULL, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "act", LYS_ACTION,
+ 1, 0, 0, 1, 0, NULL, 0);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc");
- assert_non_null(((struct lyd_node_opaq *)tree)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0x1, 0x1, LY_PREF_XML, "rpc", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "action");
- assert_null(((struct lyd_node_opaq *)node)->attr);
-
- lyd_print_tree(out, tree, LYD_XML, 0);
- assert_string_equal(str,
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x0, 0x1, LY_PREF_XML, "action", 0, 0, NULL, 0, "");
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS,
"<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n"
" <action xmlns=\"urn:ietf:params:xml:ns:yang:1\">\n"
" <c xmlns=\"urn:tests:a\">\n"
@@ -544,34 +419,22 @@
" </c>\n"
" </action>\n"
"</rpc>\n");
- ly_out_reset(out);
+
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_notification(void **state)
{
- *state = test_notification;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *tree, *ntf;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
- data =
- "<notification xmlns=\"urn:ietf:params:xml:ns:netconf:notification:1.0\">\n"
+ data = "<notification xmlns=\"urn:ietf:params:xml:ns:netconf:notification:1.0\">\n"
" <eventTime>2037-07-08T00:01:00Z</eventTime>\n"
" <c xmlns=\"urn:tests:a\">\n"
" <n1>\n"
@@ -580,70 +443,48 @@
" </c>\n"
"</notification>\n";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_notif(ctx, in, LYD_XML, &tree, &ntf));
+ assert_int_equal(LY_SUCCESS, lyd_parse_notif(UTEST_LYCTX, in, LYD_XML, &tree, &ntf));
ly_in_free(in, 0);
assert_non_null(ntf);
- assert_string_equal(ntf->schema->name, "n1");
+ CHECK_LYSC_NOTIF((struct lysc_notif *)ntf->schema, 1, NULL, 0, 0x4, 1, 0, "n1", 1, 0, NULL, 0);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "notification");
- assert_null(((struct lyd_node_opaq *)tree)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0x0, 0x1, LY_PREF_XML, "notification", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_null(node->schema);
- assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "eventTime");
- assert_string_equal(((struct lyd_node_opaq *)node)->value, "2037-07-08T00:01:00Z");
- assert_null(((struct lyd_node_opaq *)node)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x0, 0, LY_PREF_XML, "eventTime", 0, 0, NULL, 0, "2037-07-08T00:01:00Z");
node = node->next;
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "c");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0);
- lyd_print_tree(out, tree, LYD_XML, 0);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* top-level notif without envelope */
- data = "<n2 xmlns=\"urn:tests:a\"/>";
+ data = "<n2 xmlns=\"urn:tests:a\"/>\n";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_notif(ctx, in, LYD_XML, &tree, &ntf));
+ assert_int_equal(LY_SUCCESS, lyd_parse_notif(UTEST_LYCTX, in, LYD_XML, &tree, &ntf));
ly_in_free(in, 0);
assert_non_null(ntf);
- assert_string_equal(ntf->schema->name, "n2");
+ CHECK_LYSC_NOTIF((struct lysc_notif *)ntf->schema, 0, NULL, 0, 0x4, 1, 0, "n2", 0, 0, NULL, 0);
assert_non_null(tree);
assert_ptr_equal(ntf, tree);
- lyd_print_tree(out, tree, LYD_XML, LYD_PRINT_SHRINK);
- assert_string_equal(str, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
static void
test_reply(void **state)
{
- *state = test_reply;
-
const char *data;
struct ly_in *in;
- char *str;
struct lyd_node *request, *tree, *op;
const struct lyd_node *node;
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
data =
"<c xmlns=\"urn:tests:a\">\n"
" <act>\n"
@@ -651,7 +492,7 @@
" </act>\n"
"</c>\n";
assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_XML, &request, NULL));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_XML, &request, NULL));
ly_in_free(in, 0);
data =
@@ -664,47 +505,39 @@
lyd_free_all(request);
assert_non_null(op);
- assert_string_equal(op->schema->name, "act");
+
+ CHECK_LYSC_ACTION((struct lysc_action *)op->schema, NULL, 0, LYS_STATUS_CURR,
+ 1, 0, 0, 1, "act", LYS_ACTION,
+ 1, 0, 0, 1, 0, NULL, 0);
node = lyd_child(op);
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "al");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_R | LYS_STATUS_CURR, 1, "al", 0, LYS_LEAF, 1, 0, NULL, 0);
assert_true(node->schema->flags & LYS_CONFIG_R);
- assert_non_null(tree);
- assert_null(tree->schema);
- assert_string_equal(((struct lyd_node_opaq *)tree)->name.name, "rpc-reply");
- assert_non_null(((struct lyd_node_opaq *)tree)->attr);
+ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0x1, 0x1, LY_PREF_XML, "rpc-reply", 0, 0, NULL, 0, "");
node = lyd_child(tree);
- assert_non_null(node->schema);
- assert_string_equal(node->schema->name, "c");
+ CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0);
/* TODO print only rpc-reply node and then output subtree */
- lyd_print_tree(out, lyd_child(op), LYD_XML, LYD_PRINT_SHRINK);
- assert_string_equal(str, "<al xmlns=\"urn:tests:a\">25</al>");
- ly_out_reset(out);
+ CHECK_LYD_STRING(lyd_child(op), LYD_PRINT_WITHSIBLINGS, "<al xmlns=\"urn:tests:a\">25</al>\n");
lyd_free_all(tree);
/* wrong namespace, element name, whatever... */
/* TODO */
-
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_leaf, setup, teardown),
- cmocka_unit_test_setup_teardown(test_anydata, setup, teardown),
- cmocka_unit_test_setup_teardown(test_list, setup, teardown),
- cmocka_unit_test_setup_teardown(test_container, setup, teardown),
- cmocka_unit_test_setup_teardown(test_opaq, setup, teardown),
- cmocka_unit_test_setup_teardown(test_rpc, setup, teardown),
- cmocka_unit_test_setup_teardown(test_action, setup, teardown),
- cmocka_unit_test_setup_teardown(test_notification, setup, teardown),
- cmocka_unit_test_setup_teardown(test_reply, setup, teardown),
+ UTEST(test_leaf, setup),
+ UTEST(test_anydata, setup),
+ UTEST(test_list, setup),
+ UTEST(test_container, setup),
+ UTEST(test_opaq, setup),
+ UTEST(test_rpc, setup),
+ UTEST(test_action, setup),
+ UTEST(test_notification, setup),
+ UTEST(test_reply, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_printer_xml.c b/tests/utests/data/test_printer_xml.c
index 7a4af1a..521f0d6 100644
--- a/tests/utests/data/test_printer_xml.c
+++ b/tests/utests/data/test_printer_xml.c
@@ -3,7 +3,7 @@
* @author: Radek Krejci <rkrejci@cesnet.cz>
* @brief unit tests for functions from printer_yang.c
*
- * Copyright (c) 2019 CESNET, z.s.p.o.
+ * Copyright (c) 2019-2020 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
@@ -11,6 +11,8 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include <string.h>
@@ -20,46 +22,13 @@
#include "printer_data.h"
#include "tests/config.h"
#include "tree_schema.h"
-#include "utests.h"
-
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
-
-struct state_s {
- void *func;
- struct ly_ctx *ctx;
-};
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
static int
setup(void **state)
{
- struct state_s *s;
- const char *schema_a = "module defs {namespace urn:tests:defs;prefix d;yang-version 1.1;"
+ const char *schema_defs = "module defs {namespace urn:tests:defs;prefix d;yang-version 1.1;"
"identity crypto-alg; identity interface-type; identity ethernet {base interface-type;} identity fast-ethernet {base ethernet;}}";
- const char *schema_b = "module types {namespace urn:tests:types;prefix t;yang-version 1.1; import defs {prefix defs;}"
+ const char *schema_types = "module types {namespace urn:tests:types;prefix t;yang-version 1.1; import defs {prefix defs;}"
"feature f; identity gigabit-ethernet { base defs:ethernet;}"
"container cont {leaf leaftarget {type empty;}"
" list listtarget {key id; max-elements 5;leaf id {type uint8;} leaf value {type string;}"
@@ -99,7 +68,7 @@
" type string {length 1..20;}}}"
"anydata any;"
"rpc sum {input {leaf x {type uint8;} leaf y {type uint8;}} output {leaf result {type uint16;}}}}";
- const char *schema_c =
+ const char *schema_defaults =
"module defaults {\n"
" namespace \"urn:defaults\";\n"
" prefix d;\n"
@@ -118,110 +87,53 @@
" }\n"
"}";
- s = calloc(1, sizeof *s);
- assert_non_null(s);
+ UTEST_SETUP;
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
-
- assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &s->ctx));
- assert_non_null(ly_ctx_load_module(s->ctx, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema_a, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema_b, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema_c, LYS_IN_YANG, NULL));
-
- *state = s;
+ UTEST_ADD_MODULE(schema_defs, LYS_IN_YANG, NULL, NULL);
+ UTEST_ADD_MODULE(schema_types, LYS_IN_YANG, NULL, NULL);
+ UTEST_ADD_MODULE(schema_defaults, LYS_IN_YANG, NULL, NULL);
return 0;
}
-static int
-teardown(void **state)
-{
- struct state_s *s = (struct state_s *)(*state);
+#define CHECK_PARSE_LYD(INPUT, PARSE_OPTION, VALIDATE_OPTION, TREE) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, PARSE_OPTION, VALIDATE_OPTION, LY_SUCCESS, TREE)
-#if ENABLE_LOGGER_CHECKING
- if (s->func) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#endif
-
- ly_ctx_destroy(s->ctx, NULL);
- free(s);
-
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
+#define CHECK_LYD_STRING(IN_MODEL, PRINT_OPTION, TEXT) \
+ CHECK_LYD_STRING_PARAM(IN_MODEL, TEXT, LYD_XML, PRINT_OPTION)
static void
test_leaf(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
struct lyd_node *tree;
- const char *data;
- const char *result;
- char *printed;
- struct ly_out *out;
-
- s->func = test_leaf;
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
+ const char *data, *result;
data = "<int8 xmlns=\"urn:tests:types\">\n 15 \t\n </int8>";
result = "<int8 xmlns=\"urn:tests:types\">15</int8>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_int_equal(LY_SUCCESS, lyd_print_tree(out, tree->next, LYD_XML, LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, result);
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, result);
lyd_free_all(tree);
-
- ly_out_free(out, NULL, 1);
- s->func = NULL;
}
static void
test_anydata(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
struct lyd_node *tree;
const char *data;
- char *printed;
- struct ly_out *out;
-
- s->func = test_anydata;
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
data = "<any xmlns=\"urn:tests:types\"><somexml xmlns:x=\"url:x\" xmlns=\"example.com\"><x:x/></somexml></any>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_int_equal(LY_SUCCESS, lyd_print_tree(out, tree->next, LYD_XML, LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
/* canonized */
data = "<any xmlns=\"urn:tests:types\"><somexml xmlns=\"example.com\"><x xmlns=\"url:x\"/></somexml></any>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
data = "<any xmlns=\"urn:tests:types\"/>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_int_equal(LY_SUCCESS, lyd_print_tree(out, tree->next, LYD_XML, LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
- data =
- "<any xmlns=\"urn:tests:types\">\n"
+ data = "<any xmlns=\"urn:tests:types\">\n"
" <cont>\n"
" <defs:elem1 xmlns:defs=\"urn:tests:defs\">\n"
" <elem2 xmlns:defaults=\"urn:defaults\" defs:attr1=\"defaults:val\" attr2=\"/defaults:node/defs:node2\">\n"
@@ -229,16 +141,17 @@
" </defs:elem1>\n"
" </cont>\n"
"</any>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- /* cont should be normally parsed */
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_string_equal(tree->schema->name, "any");
- assert_int_equal(((struct lyd_node_any *)tree)->value_type, LYD_ANYDATA_DATATREE);
- assert_string_equal(((struct lyd_node_any *)tree)->value.tree->schema->name, "cont");
+ /* cont should be normally parsed */
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "any", 0, LYS_ANYDATA, 0, 0, NULL, 0);
+ CHECK_LYD_NODE_ANY((struct lyd_node_any *)tree, 0, 0, 0, LYD_ANYDATA_DATATREE);
+ struct lyd_node *tree_tmp = ((struct lyd_node_any *)tree)->value.tree;
+
+ CHECK_LYSC_NODE(tree_tmp->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "cont", 1, LYS_CONTAINER, 0, 0, NULL, 0);
/* but its children not */
- assert_null(((struct lyd_node_inner *)(((struct lyd_node_any *)tree)->value.tree))->child->schema);
- assert_int_equal(LY_SUCCESS, lyd_print_tree(out, tree, LYD_XML, 0));
- assert_int_equal(strlen(printed), ly_out_printed(out));
+ assert_null(((struct lyd_node_inner *)tree_tmp)->child->schema);
/* canonized */
data =
"<any xmlns=\"urn:tests:types\">\n"
@@ -249,122 +162,68 @@
" </elem1>\n"
" </cont>\n"
"</any>\n";
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
-
- ly_out_free(out, NULL, 1);
- s->func = NULL;
}
static void
test_defaults(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
struct lyd_node *tree;
const char *data;
- char *printed;
- struct ly_out *out;
+ const char *data_trim;
+ const char *data_all;
+ const char *data_all_tag;
+ const char *data_impl_tag;
- s->func = test_defaults;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&printed, 0, &out));
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf-with-defaults", "2011-06-01", NULL));
/* standard default value */
data = "<c xmlns=\"urn:defaults\">aa</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
data = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
data = "<a xmlns=\"urn:defaults\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\""
" ncwd:default=\"true\" xmlns:d=\"urn:defaults\">/d:b</a>"
"<c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
data = "<a xmlns=\"urn:defaults\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\""
" ncwd:default=\"true\" xmlns:d=\"urn:defaults\">/d:b</a>"
"<c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* string value equal to the default but default is an unresolved instance-identifier, so they are not considered equal */
data = "<a xmlns=\"urn:defaults\">/d:b</a><c xmlns=\"urn:defaults\">aa</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
lyd_free_all(tree);
/* instance-identifier value equal to the default, should be considered equal */
data = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(s->ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- data = "<b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- data = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- data = "<a xmlns=\"urn:defaults\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\""
+ data_trim = "<b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
+ data_all = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
+ data_all_tag = "<a xmlns=\"urn:defaults\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\""
" ncwd:default=\"true\" xmlns:d=\"urn:defaults\">/d:b</a>"
"<b xmlns=\"urn:defaults\">val</b>"
"<c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
+ data_impl_tag = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
- assert_int_equal(LY_SUCCESS, lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK));
- assert_int_equal(strlen(printed), ly_out_printed(out));
- data = "<a xmlns=\"urn:defaults\" xmlns:d=\"urn:defaults\">/d:b</a><b xmlns=\"urn:defaults\">val</b><c xmlns=\"urn:defaults\">aa</c>";
- assert_string_equal(printed, data);
- ly_out_reset(out);
-
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_TRIM | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data_trim);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data_all);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_ALL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data_all_tag);
+ CHECK_LYD_STRING(tree, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data_impl_tag);
lyd_free_all(tree);
- ly_out_free(out, NULL, 1);
-
- s->func = NULL;
}
#if 0
@@ -456,9 +315,9 @@
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_leaf, setup, teardown),
- cmocka_unit_test_setup_teardown(test_anydata, setup, teardown),
- cmocka_unit_test_setup_teardown(test_defaults, setup, teardown),
+ UTEST(test_leaf, setup),
+ UTEST(test_anydata, setup),
+ UTEST(test_defaults, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_tree_data.c b/tests/utests/data/test_tree_data.c
index e1507f4..1aab6fc 100644
--- a/tests/utests/data/test_tree_data.c
+++ b/tests/utests/data/test_tree_data.c
@@ -11,47 +11,18 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include "common.h"
#include "libyang.h"
#include "path.h"
-#include "utests.h"
#include "xpath.h"
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
-
-struct ly_ctx *ctx; /* context for tests */
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
-
static int
setup(void **state)
{
- (void) state; /* unused */
-
- const char *schema_a = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;"
+ const char *schema = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;"
"leaf bar {type string;}"
"list l1 { key \"a b\"; leaf a {type string;} leaf b {type string;} leaf c {type string;}}"
"leaf foo { type string;}"
@@ -62,59 +33,29 @@
" container c{leaf x {type string;} leaf-list d {type string;}}"
"}}";
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
+ UTEST_SETUP;
- assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_a, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
return 0;
}
-static int
-teardown(void **state)
-{
-#if ENABLE_LOGGER_CHECKING
- if (*state) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#else
- (void) state; /* unused */
-#endif
-
- ly_ctx_destroy(ctx, NULL);
- ctx = NULL;
-
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
+#define CHECK_PARSE_LYD(INPUT, PARSE_OPTION, VALIDATE_OPTION, TREE) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, PARSE_OPTION, VALIDATE_OPTION, LY_SUCCESS, TREE)
static void
test_compare(void **state)
{
- *state = test_compare;
-
struct lyd_node *tree1, *tree2;
-
- const char *data1 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
- const char *data2 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>y</c></l1>";
+ const char *data1;
+ const char *data2;
assert_int_equal(LY_SUCCESS, lyd_compare_single(NULL, NULL, 0));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ data1 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
+ data2 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>y</c></l1>";
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
assert_int_equal(LY_ENOT, lyd_compare_single(((struct lyd_node_inner *)tree1)->child, tree2, 0));
@@ -123,8 +64,8 @@
data1 = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
data2 = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_ENOT, lyd_compare_single(tree1->next, tree2->next, 0));
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next->next, tree2->next, 0));
lyd_free_all(tree1);
@@ -132,8 +73,8 @@
data1 = "<ll xmlns=\"urn:tests:a\">a</ll><ll xmlns=\"urn:tests:a\">b</ll>";
data2 = "<ll xmlns=\"urn:tests:a\">b</ll>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
assert_int_equal(LY_ENOT, lyd_compare_single(NULL, tree2, 0));
assert_int_equal(LY_ENOT, lyd_compare_single(tree1, NULL, 0));
@@ -143,8 +84,8 @@
data1 = "<c xmlns=\"urn:tests:a\"><x>x</x></c>";
data2 = "<c xmlns=\"urn:tests:a\"><x>y</x></c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
@@ -152,8 +93,8 @@
data1 = "<c xmlns=\"urn:tests:a\"><x>x</x></c>";
data2 = "<c xmlns=\"urn:tests:a\"><x>x</x><x>y</x></c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
@@ -161,29 +102,26 @@
data1 = "<any xmlns=\"urn:tests:a\"><x>x</x></any>";
data2 = "<any xmlns=\"urn:tests:a\"><x>x</x><x>y</x></any>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data2, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree2));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
+ CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
assert_int_equal(LY_ENOT, lyd_compare_single(tree1->next, tree2->next, 0));
lyd_free_all(tree1);
data1 = "<any xmlns=\"urn:tests:a\"><x>x</x><x>y</x></any>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data1, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
lyd_free_all(tree1);
lyd_free_all(tree2);
-
- *state = NULL;
}
static void
test_dup(void **state)
{
- *state = test_dup;
-
struct lyd_node *tree1, *tree2;
const char *result;
- const char *data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
+ const char *data;
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, LYD_DUP_RECURSIVE, &tree2));
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
@@ -191,64 +129,65 @@
data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
result = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b></l1>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
lyd_free_all(tree1);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, result, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
lyd_free_all(tree2);
data = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
result = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_siblings(tree1, NULL, LYD_DUP_RECURSIVE, &tree2));
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2->next, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree2);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, LYD_DUP_RECURSIVE, &tree2));
lyd_free_all(tree1);
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, result, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree2);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
lyd_free_all(tree1);
result = "<l2 xmlns=\"urn:tests:a\"/>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, result, LYD_XML, LYD_PARSE_ONLY, 0, &tree1));
+ CHECK_PARSE_LYD_PARAM(result, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree1);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
lyd_free_all(tree2);
data = "<any xmlns=\"urn:tests:a\"><c><a>a</a></c></any>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
lyd_free_all(tree2);
data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)((struct lyd_node_inner *)tree1->next)->child)->child, NULL,
LYD_DUP_WITH_PARENTS, &tree2));
- assert_string_equal("x", tree2->schema->name);
- assert_non_null(tree2->parent);
+ int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM;
+
+ CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "x", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, (struct lyd_node *)tree2->parent->parent,
LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
lyd_free_all(tree2);
data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>c</c></l1>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev, NULL,
LYD_DUP_WITH_PARENTS, &tree2));
- assert_string_equal("c", tree2->schema->name);
- assert_non_null(tree2->parent);
+ flag = LYS_CONFIG_W | LYS_SET_ENUM;
+ CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "c", 0, LYS_LEAF, 1, 0, NULL, 0);
assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, (struct lyd_node *)tree2->parent, LYD_COMPARE_FULL_RECURSION));
lyd_free_all(tree1);
lyd_free_all(tree2);
data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)((struct lyd_node_inner *)tree1->next)->child)->child,
(struct lyd_node_inner *)tree2, LYD_DUP_WITH_PARENTS, NULL));
@@ -258,19 +197,15 @@
/* invalid */
data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>c</c></l1><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree1));
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
assert_int_equal(LY_EINVAL, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev,
(struct lyd_node_inner *)tree1->next, LYD_DUP_WITH_PARENTS, NULL));
lyd_free_all(tree1);
-
- *state = NULL;
}
static void
test_target(void **state)
{
- *state = test_target;
-
const struct lyd_node_term *term;
struct lyd_node *tree;
struct lyxp_expr *exp;
@@ -289,29 +224,27 @@
"<l2 xmlns=\"urn:tests:a\"><c>"
"</c></l2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_int_equal(LY_SUCCESS, ly_path_parse(ctx, NULL, path_str, strlen(path_str), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
+ CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
+ assert_int_equal(LY_SUCCESS, ly_path_parse(UTEST_LYCTX, NULL, path_str, strlen(path_str), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp));
- assert_int_equal(LY_SUCCESS, ly_path_compile(ctx, NULL, NULL, exp, LY_PATH_LREF_FALSE, LY_PATH_OPER_INPUT,
+ assert_int_equal(LY_SUCCESS, ly_path_compile(UTEST_LYCTX, NULL, NULL, exp, LY_PATH_LREF_FALSE, LY_PATH_OPER_INPUT,
LY_PATH_TARGET_SINGLE, LY_PREF_JSON, NULL, NULL, &path));
term = lyd_target(path, tree);
- assert_string_equal(term->schema->name, "d");
+ const int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM | LYS_ORDBY_SYSTEM;
+
+ CHECK_LYSC_NODE(term->schema, NULL, 0, flag, 1, "d", 0, LYS_LEAFLIST, 1, 0, NULL, 0);
assert_string_equal(LYD_CANON_VALUE(term), "b");
assert_string_equal(LYD_CANON_VALUE(term->prev), "b");
lyd_free_all(tree);
- ly_path_free(ctx, path);
- lyxp_expr_free(ctx, exp);
-
- *state = NULL;
+ ly_path_free(UTEST_LYCTX, path);
+ lyxp_expr_free(UTEST_LYCTX, exp);
}
static void
test_list_pos(void **state)
{
- *state = test_list_pos;
-
const char *data;
struct lyd_node *tree;
@@ -319,7 +252,7 @@
"<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b></l1>"
"<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
"<foo xmlns=\"urn:tests:a\">test</foo>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
assert_int_equal(0, lyd_list_pos(tree));
assert_int_equal(1, lyd_list_pos(tree->next));
assert_int_equal(2, lyd_list_pos(tree->next->next));
@@ -329,7 +262,7 @@
data = "<ll xmlns=\"urn:tests:a\">one</ll>"
"<ll xmlns=\"urn:tests:a\">two</ll>"
"<ll xmlns=\"urn:tests:a\">three</ll>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
assert_int_equal(1, lyd_list_pos(tree));
assert_int_equal(2, lyd_list_pos(tree->next));
assert_int_equal(3, lyd_list_pos(tree->next->next));
@@ -341,7 +274,7 @@
"<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
"<ll xmlns=\"urn:tests:a\">three</ll>"
"<l1 xmlns=\"urn:tests:a\"><a>three</a><b>three</b></l1>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
assert_string_equal("l1", tree->schema->name);
assert_int_equal(1, lyd_list_pos(tree));
assert_int_equal(2, lyd_list_pos(tree->next));
@@ -351,15 +284,11 @@
assert_int_equal(2, lyd_list_pos(tree->next->next->next->next));
assert_int_equal(3, lyd_list_pos(tree->next->next->next->next->next));
lyd_free_all(tree);
-
- *state = NULL;
}
static void
test_first_sibling(void **state)
{
- *state = test_first_sibling;
-
const char *data;
struct lyd_node *tree;
struct lyd_node_inner *parent;
@@ -367,7 +296,7 @@
data = "<bar xmlns=\"urn:tests:a\">test</bar>"
"<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b><c>one</c></l1>"
"<foo xmlns=\"urn:tests:a\">test</foo>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
+ assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
assert_ptr_equal(tree, lyd_first_sibling(tree->next));
assert_ptr_equal(tree, lyd_first_sibling(tree));
assert_ptr_equal(tree, lyd_first_sibling(tree->prev));
@@ -377,19 +306,17 @@
assert_ptr_equal(parent->child, lyd_first_sibling(parent->child));
assert_ptr_equal(parent->child, lyd_first_sibling(parent->child->prev));
lyd_free_all(tree);
-
- *state = NULL;
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_compare, setup, teardown),
- cmocka_unit_test_setup_teardown(test_dup, setup, teardown),
- cmocka_unit_test_setup_teardown(test_target, setup, teardown),
- cmocka_unit_test_setup_teardown(test_list_pos, setup, teardown),
- cmocka_unit_test_setup_teardown(test_first_sibling, setup, teardown),
+ UTEST(test_compare, setup),
+ UTEST(test_dup, setup),
+ UTEST(test_target, setup),
+ UTEST(test_list_pos, setup),
+ UTEST(test_first_sibling, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_types.c b/tests/utests/data/test_types.c
index f8316c6..a711c16 100644
--- a/tests/utests/data/test_types.c
+++ b/tests/utests/data/test_types.c
@@ -3,7 +3,7 @@
* @author: Radek Krejci <rkrejci@cesnet.cz>
* @brief unit tests for support of YANG data types
*
- * Copyright (c) 2019 CESNET, z.s.p.o.
+ * Copyright (c) 2019-2020 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
@@ -11,684 +11,484 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
+
+#include <stdio.h>
+#include <string.h>
#include "libyang.h"
#include "path.h"
#include "plugins_types.h"
-#include "utests.h"
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
-
-struct state_s {
- void *func;
- struct ly_ctx *ctx;
- const struct lys_module *mod_types;
- const struct lys_module *mod_defs;
-};
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
-static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
-{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
+const char *schema_a = "module defs {namespace urn:tests:defs;prefix d;yang-version 1.1;"
+ "identity crypto-alg; identity interface-type; identity ethernet {base interface-type;} identity fast-ethernet {base ethernet;}"
+ "typedef iref {type identityref {base interface-type;}}}";
+const char *schema_b = "module types {namespace urn:tests:types;prefix t;yang-version 1.1; import defs {prefix defs;}"
+ "feature f; identity gigabit-ethernet { base defs:ethernet;}"
+ "typedef tboolean {type boolean;}"
+ "typedef tempty {type empty;}"
+ "container cont {leaf leaftarget {type empty;}"
+ " list listtarget {key id; max-elements 5;leaf id {type uint8;} leaf value {type string;}}"
+ " leaf-list leaflisttarget {type uint8; max-elements 5;}}"
+ "list list {key id; leaf id {type string;} leaf value {type string;} leaf-list targets {type string;}}"
+ "list list2 {key \"id value\"; leaf id {type string;} leaf value {type string;}}"
+ "list list_inst {key id; leaf id {type instance-identifier {require-instance true;}} leaf value {type string;}}"
+ "list list_ident {key id; leaf id {type identityref {base defs:interface-type;}} leaf value {type string;}}"
+ "list list_keyless {config \"false\"; leaf id {type string;} leaf value {type string;}}"
+ "leaf-list leaflisttarget {type string;}"
+ "leaf binary {type binary {length 5 {error-message \"This base64 value must be of length 5.\";}}}"
+ "leaf binary-norestr {type binary;}"
+ "leaf int8 {type int8 {range 10..20;}}"
+ "leaf uint8 {type uint8 {range 150..200;}}"
+ "leaf int16 {type int16 {range -20..-10;}}"
+ "leaf uint16 {type uint16 {range 150..200;}}"
+ "leaf int32 {type int32;}"
+ "leaf uint32 {type uint32;}"
+ "leaf int64 {type int64;}"
+ "leaf uint64 {type uint64;}"
+ "leaf bits {type bits {bit zero; bit one {if-feature f;} bit two;}}"
+ "leaf enums {type enumeration {enum white; enum yellow {if-feature f;}}}"
+ "leaf dec64 {type decimal64 {fraction-digits 1; range 1.5..10;}}"
+ "leaf dec64-norestr {type decimal64 {fraction-digits 18;}}"
+ "leaf str {type string {length 8..10; pattern '[a-z ]*';}}"
+ "leaf str-norestr {type string;}"
+ "leaf str-utf8 {type string{length 2..5; pattern '€*';}}"
+ "leaf bool {type boolean;}"
+ "leaf tbool {type tboolean;}"
+ "leaf empty {type empty;}"
+ "leaf tempty {type tempty;}"
+ "leaf ident {type identityref {base defs:interface-type;}}"
+ "leaf iref {type defs:iref;}"
+ "leaf inst {type instance-identifier {require-instance true;}}"
+ "leaf inst-noreq {type instance-identifier {require-instance false;}}"
+ "leaf lref {type leafref {path /leaflisttarget; require-instance true;}}"
+ "leaf lref2 {type leafref {path \"../list[id = current()/../str-norestr]/targets\"; require-instance true;}}"
+ "leaf un1 {type union {"
+ " type leafref {path /int8; require-instance true;}"
+ " type union { type identityref {base defs:interface-type;} type instance-identifier {require-instance true;} }"
+ " type string {length 1..20;}}}}";
static int
setup(void **state)
{
- struct state_s *s;
- const char *schema_a = "module defs {namespace urn:tests:defs;prefix d;yang-version 1.1;"
- "identity crypto-alg; identity interface-type; identity ethernet {base interface-type;} identity fast-ethernet {base ethernet;}"
- "typedef iref {type identityref {base interface-type;}}}";
- const char *schema_b = "module types {namespace urn:tests:types;prefix t;yang-version 1.1; import defs {prefix defs;}"
- "feature f; identity gigabit-ethernet { base defs:ethernet;}"
- "typedef tboolean {type boolean;}"
- "typedef tempty {type empty;}"
- "container cont {leaf leaftarget {type empty;}"
- " list listtarget {key id; max-elements 5;leaf id {type uint8;} leaf value {type string;}}"
- " leaf-list leaflisttarget {type uint8; max-elements 5;}}"
- "list list {key id; leaf id {type string;} leaf value {type string;} leaf-list targets {type string;}}"
- "list list2 {key \"id value\"; leaf id {type string;} leaf value {type string;}}"
- "list list_inst {key id; leaf id {type instance-identifier {require-instance true;}} leaf value {type string;}}"
- "list list_ident {key id; leaf id {type identityref {base defs:interface-type;}} leaf value {type string;}}"
- "list list_keyless {config \"false\"; leaf id {type string;} leaf value {type string;}}"
- "leaf-list leaflisttarget {type string;}"
- "leaf binary {type binary {length 5 {error-message \"This base64 value must be of length 5.\";}}}"
- "leaf binary-norestr {type binary;}"
- "leaf int8 {type int8 {range 10..20;}}"
- "leaf uint8 {type uint8 {range 150..200;}}"
- "leaf int16 {type int16 {range -20..-10;}}"
- "leaf uint16 {type uint16 {range 150..200;}}"
- "leaf int32 {type int32;}"
- "leaf uint32 {type uint32;}"
- "leaf int64 {type int64;}"
- "leaf uint64 {type uint64;}"
- "leaf bits {type bits {bit zero; bit one {if-feature f;} bit two;}}"
- "leaf enums {type enumeration {enum white; enum yellow {if-feature f;}}}"
- "leaf dec64 {type decimal64 {fraction-digits 1; range 1.5..10;}}"
- "leaf dec64-norestr {type decimal64 {fraction-digits 18;}}"
- "leaf str {type string {length 8..10; pattern '[a-z ]*';}}"
- "leaf str-norestr {type string;}"
- "leaf str-utf8 {type string{length 2..5; pattern '€*';}}"
- "leaf bool {type boolean;}"
- "leaf tbool {type tboolean;}"
- "leaf empty {type empty;}"
- "leaf tempty {type tempty;}"
- "leaf ident {type identityref {base defs:interface-type;}}"
- "leaf iref {type defs:iref;}"
- "leaf inst {type instance-identifier {require-instance true;}}"
- "leaf inst-noreq {type instance-identifier {require-instance false;}}"
- "leaf lref {type leafref {path /leaflisttarget; require-instance true;}}"
- "leaf lref2 {type leafref {path \"../list[id = current()/../str-norestr]/targets\"; require-instance true;}}"
- "leaf un1 {type union {"
- " type leafref {path /int8; require-instance true;}"
- " type union { type identityref {base defs:interface-type;} type instance-identifier {require-instance true;} }"
- " type string {length 1..20;}}}}";
-
- s = calloc(1, sizeof *s);
- assert_non_null(s);
-
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
-
- assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &s->ctx));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema_a, LYS_IN_YANG, &s->mod_defs));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema_b, LYS_IN_YANG, &s->mod_types));
-
- *state = s;
+ UTEST_SETUP;
+ UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, NULL);
+ UTEST_ADD_MODULE(schema_b, LYS_IN_YANG, NULL, NULL);
return 0;
}
-static int
-teardown(void **state)
-{
- struct state_s *s = (struct state_s *)(*state);
+#define CHECK_PARSE_LYD(INPUT, MODEL) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, MODEL)
-#if ENABLE_LOGGER_CHECKING
- if (s->func) {
- fprintf(stderr, "%s\n", logbuf);
+#define TEST_PATTERN_1(INPUT, SCHEMA_NAME, SCHEMA_NEXT, VALUE_TYPE, ...) \
+ { \
+ struct lyd_node_term *leaf; \
+ struct lyd_value value = {0}; \
+ /* create model */ \
+ CHECK_LYSC_NODE((INPUT)->schema, NULL, 0, 0x5, 1, SCHEMA_NAME, SCHEMA_NEXT, LYS_LEAF, 0, 0, NULL, 0); \
+ /* CHECK_LYSC_NODE((INPUT)->schema, LYS_LEAF, SCHEMA_NAME); */ \
+ leaf = (struct lyd_node_term*)(INPUT); \
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 0, 1, VALUE_TYPE, ## __VA_ARGS__); \
+ /* copy value */ \
+ assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(UTEST_LYCTX, &leaf->value, &value)); \
+ CHECK_LYD_VALUE(value, VALUE_TYPE, ## __VA_ARGS__); \
+ if (LY_TYPE_INST == LY_TYPE_ ## VALUE_TYPE) { \
+ for (LY_ARRAY_COUNT_TYPE it = 0; it < LY_ARRAY_COUNT(leaf->value.target); it++) { \
+ assert_ptr_equal(value.target[it].node, leaf->value.target[it].node); \
+ LY_ARRAY_COUNT_TYPE arr_size_predicates = 0; \
+ if (value.target[it].pred_type == LY_PATH_PREDTYPE_NONE) { \
+ assert_null(value.target[it].predicates); \
+ } else { \
+ assert_non_null(value.target[it].predicates); \
+ arr_size_predicates = LY_ARRAY_COUNT(value.target[it].predicates); \
+ assert_int_equal(LY_ARRAY_COUNT(value.target[it].predicates), LY_ARRAY_COUNT(leaf->value.target[it].predicates)); \
+ } \
+ for (LY_ARRAY_COUNT_TYPE jt = 0; jt < arr_size_predicates; jt++) { \
+ if (value.target[it].pred_type == LY_PATH_PREDTYPE_POSITION) { \
+ assert_int_equal(value.target[it].predicates[jt].position, leaf->value.target[it].predicates[jt].position); \
+ } else { \
+ assert_true(LY_SUCCESS == value.realtype->plugin->compare(&value, &leaf->value)); \
+ } \
+ } \
+ } \
+ } \
+ value.realtype->plugin->free(UTEST_LYCTX, &value); \
}
-#endif
- ly_ctx_destroy(s->ctx, NULL);
- free(s);
+#define TEST_TYPE_ERROR(TYPE, VALUE, ERROR_MSG) \
+ { \
+ const char *data = "<" TYPE " xmlns=\"urn:tests:types\">" VALUE "</" TYPE">"; \
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree); \
+ CHECK_LOG_CTX(ERROR_MSG, "/types:"TYPE); \
+ }
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
-
-#define TEST_DATA(DATA, RETCODE, ERRMSG) \
- logbuf_clean(); \
- if (!in) { \
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(DATA, &in)); \
- } else { \
- ly_in_memory(in, DATA); \
- } \
- assert_int_equal(RETCODE, lyd_parse_data(s->ctx, in, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); \
- if (!RETCODE) { \
- logbuf_assert(ERRMSG); \
+#define TEST_PRINTED_VALUE(VALUE, EXPECTED, FORMAT, PREFIX_DATA) \
+ { \
+ const char *_str; \
+ uint8_t _dynamic; \
+ assert_non_null(_str = (VALUE)->realtype->plugin->print(VALUE, FORMAT, (void *)PREFIX_DATA, &_dynamic)); \
+ assert_string_equal(EXPECTED, _str); \
+ if (_dynamic) { \
+ free((char *)_str); \
+ } \
}
static void
test_int(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_int;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
+ const char *data;
+ char *error_msg;
/* valid data */
- TEST_DATA("<int8 xmlns=\"urn:tests:types\">\n 15 \t\n </int8>", LY_SUCCESS, "");
+ data = "<int8 xmlns=\"urn:tests:types\">\n 15 \t\n </int8>";
+ CHECK_PARSE_LYD(data, tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("int8", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("15", leaf->value.canonical);
- assert_int_equal(15, leaf->value.int8);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_int_equal(15, value.int8);
- value.realtype->plugin->free(s->ctx, &value);
- memset(&value, 0, sizeof value);
+ TEST_PATTERN_1(tree, "int8", 1, INT8, "15", 15);
lyd_free_all(tree);
/* invalid range */
- TEST_DATA("<int8 xmlns=\"urn:tests:types\">1</int8>", LY_EVALID, "Value \"1\" does not satisfy the range constraint. /types:int8");
- TEST_DATA("<int16 xmlns=\"urn:tests:types\">100</int16>", LY_EVALID, "Value \"100\" does not satisfy the range constraint. /types:int16");
+ error_msg = "Value \"1\" does not satisfy the range constraint.";
+ TEST_TYPE_ERROR("int8", "1", error_msg);
+ error_msg = "Value \"100\" does not satisfy the range constraint.";
+ TEST_TYPE_ERROR("int16", "100", error_msg);
/* invalid value */
- TEST_DATA("<int32 xmlns=\"urn:tests:types\">0x01</int32>", LY_EVALID, "Invalid int32 value \"0x01\". /types:int32");
- TEST_DATA("<int64 xmlns=\"urn:tests:types\"></int64>", LY_EVALID, "Invalid empty int64 value. /types:int64");
- TEST_DATA("<int64 xmlns=\"urn:tests:types\"> </int64>", LY_EVALID, "Invalid empty int64 value. /types:int64");
- TEST_DATA("<int64 xmlns=\"urn:tests:types\">-10 xxx</int64>", LY_EVALID, "Invalid int64 value \"-10 xxx\". /types:int64");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ error_msg = "Invalid int32 value \"0x01\".";
+ TEST_TYPE_ERROR("int32", "0x01", error_msg);
+ error_msg = "Invalid empty int64 value.";
+ TEST_TYPE_ERROR("int64", "", error_msg);
+ error_msg = "Invalid empty int64 value.";
+ TEST_TYPE_ERROR("int64", " ", error_msg);
+ error_msg = "Invalid int64 value \"-10 xxx\".";
+ TEST_TYPE_ERROR("int64", "-10 xxx", error_msg);
}
static void
test_uint(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_uint;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
/* valid data */
- TEST_DATA("<uint8 xmlns=\"urn:tests:types\">\n 150 \t\n </uint8>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<uint8 xmlns=\"urn:tests:types\">\n 150 \t\n </uint8>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("uint8", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("150", leaf->value.canonical);
- assert_int_equal(150, leaf->value.uint8);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_int_equal(150, value.uint8);
- value.realtype->plugin->free(s->ctx, &value);
- memset(&value, 0, sizeof value);
+ TEST_PATTERN_1(tree, "uint8", 1, UINT8, "150", 150);
lyd_free_all(tree);
/* invalid range */
- TEST_DATA("<uint8 xmlns=\"urn:tests:types\">\n 15 \t\n </uint8>", LY_EVALID, "Value \"15\" does not satisfy the range constraint. /types:uint8");
- TEST_DATA("<uint16 xmlns=\"urn:tests:types\">\n 1500 \t\n </uint16>", LY_EVALID, "Value \"1500\" does not satisfy the range constraint. /types:uint16");
+ TEST_TYPE_ERROR("uint8", "\n 15 \t\n ",
+ "Value \"15\" does not satisfy the range constraint.");
+ TEST_TYPE_ERROR("uint16", "\n 1500 \t\n ",
+ "Value \"1500\" does not satisfy the range constraint.");
/* invalid value */
- TEST_DATA("<uint32 xmlns=\"urn:tests:types\">-10</uint32>", LY_EVALID, "Value \"-10\" is out of uint32's min/max bounds. /types:uint32");
- TEST_DATA("<uint64 xmlns=\"urn:tests:types\"/>", LY_EVALID, "Invalid empty uint64 value. /types:uint64");
- TEST_DATA("<uint64 xmlns=\"urn:tests:types\"> </uint64>", LY_EVALID, "Invalid empty uint64 value. /types:uint64");
- TEST_DATA("<uint64 xmlns=\"urn:tests:types\">10 xxx</uint64>", LY_EVALID, "Invalid uint64 value \"10 xxx\". /types:uint64");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("uint32", "-10",
+ "Value \"-10\" is out of uint32's min/max bounds.");
+ CHECK_PARSE_LYD_PARAM("<uint64 xmlns=\"urn:tests:types\"/>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid empty uint64 value.", "/types:uint64");
+ TEST_TYPE_ERROR("uint64", " ", "Invalid empty uint64 value.");
+ TEST_TYPE_ERROR("uint64", "10 xxx", "Invalid uint64 value \"10 xxx\".");
}
static void
test_dec64(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_dec64;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
/* valid data */
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">\n +8 \t\n </dec64>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<dec64 xmlns=\"urn:tests:types\">\n +8 \t\n </dec64>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("dec64", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("8.0", leaf->value.canonical);
- assert_int_equal(80, leaf->value.dec64);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_int_equal(80, value.dec64);
- value.realtype->plugin->free(s->ctx, &value);
- memset(&value, 0, sizeof value);
+ TEST_PATTERN_1(tree, "dec64", 1, DEC64, "8.0", 80);
lyd_free_all(tree);
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">8.00</dec64>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<dec64 xmlns=\"urn:tests:types\">8.00</dec64>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("dec64", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("8.0", leaf->value.canonical);
- assert_int_equal(80, leaf->value.dec64);
+ TEST_PATTERN_1(tree, "dec64", 1, DEC64, "8.0", 80);
lyd_free_all(tree);
- TEST_DATA("<dec64-norestr xmlns=\"urn:tests:types\">-9.223372036854775808</dec64-norestr>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<dec64-norestr xmlns=\"urn:tests:types\">-9.223372036854775808</dec64-norestr>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("dec64-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("-9.223372036854775808", leaf->value.canonical);
- assert_int_equal(INT64_C(-9223372036854775807) - INT64_C(1), leaf->value.dec64);
+ TEST_PATTERN_1(tree, "dec64-norestr", 1, DEC64, "-9.223372036854775808", INT64_C(-9223372036854775807) - INT64_C(1));
lyd_free_all(tree);
- TEST_DATA("<dec64-norestr xmlns=\"urn:tests:types\">9.223372036854775807</dec64-norestr>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<dec64-norestr xmlns=\"urn:tests:types\">9.223372036854775807</dec64-norestr>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("dec64-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("9.223372036854775807", leaf->value.canonical);
- assert_int_equal(INT64_C(9223372036854775807), leaf->value.dec64);
+ TEST_PATTERN_1(tree, "dec64-norestr", 1, DEC64, "9.223372036854775807", INT64_C(9223372036854775807));
lyd_free_all(tree);
/* invalid range */
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">\n 15 \t\n </dec64>", LY_EVALID, "Value \"15.0\" does not satisfy the range constraint. /types:dec64");
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">\n 0 \t\n </dec64>", LY_EVALID, "Value \"0.0\" does not satisfy the range constraint. /types:dec64");
+ TEST_TYPE_ERROR("dec64", "\n 15 \t\n ", "Value \"15.0\" does not satisfy the range constraint.");
+ TEST_TYPE_ERROR("dec64", "\n 0 \t\n ", "Value \"0.0\" does not satisfy the range constraint.");
/* invalid value */
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">xxx</dec64>", LY_EVALID, "Invalid 1. character of decimal64 value \"xxx\". /types:dec64");
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\"/>", LY_EVALID, "Invalid empty decimal64 value. /types:dec64");
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\"> </dec64>", LY_EVALID, "Invalid empty decimal64 value. /types:dec64");
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">8.5 xxx</dec64>", LY_EVALID, "Invalid 6. character of decimal64 value \"8.5 xxx\". /types:dec64");
- TEST_DATA("<dec64 xmlns=\"urn:tests:types\">8.55 xxx</dec64>", LY_EVALID, "Value \"8.55\" of decimal64 type exceeds defined number (1) of fraction digits. /types:dec64");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("dec64", "xxx", "Invalid 1. character of decimal64 value \"xxx\".");
+ CHECK_PARSE_LYD_PARAM("<dec64 xmlns=\"urn:tests:types\"/>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid empty decimal64 value.", "/types:dec64");
+ TEST_TYPE_ERROR("dec64", " ", "Invalid empty decimal64 value.");
+ TEST_TYPE_ERROR("dec64", "8.5 xxx", "Invalid 6. character of decimal64 value \"8.5 xxx\".");
+ TEST_TYPE_ERROR("dec64", "8.55 xxx", "Value \"8.55\" of decimal64 type exceeds defined number (1) of fraction digits.");
}
static void
test_string(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_string;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
/* valid data */
- TEST_DATA("<str xmlns=\"urn:tests:types\">teststring</str>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<str xmlns=\"urn:tests:types\">teststring</str>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("str", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("teststring", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "str", 1, STRING, "teststring");
lyd_free_all(tree);
/* multibyte characters (€ encodes as 3-byte UTF8 character, length restriction is 2-5) */
- TEST_DATA("<str-utf8 xmlns=\"urn:tests:types\">€€</str-utf8>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<str-utf8 xmlns=\"urn:tests:types\">€€</str-utf8>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("str-utf8", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("€€", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "str-utf8", 1, STRING, "€€");
lyd_free_all(tree);
- TEST_DATA("<str-utf8 xmlns=\"urn:tests:types\">€</str-utf8>", LY_EVALID, "Length \"1\" does not satisfy the length constraint. /types:str-utf8");
- TEST_DATA("<str-utf8 xmlns=\"urn:tests:types\">€€€€€€</str-utf8>", LY_EVALID, "Length \"6\" does not satisfy the length constraint. /types:str-utf8");
- TEST_DATA("<str-utf8 xmlns=\"urn:tests:types\">€€x</str-utf8>", LY_EVALID, "String \"€€x\" does not conform to the pattern \"€*\". /types:str-utf8");
+
+ /*error */
+ TEST_TYPE_ERROR("str-utf8", "€",
+ "Length \"1\" does not satisfy the length constraint.");
+ TEST_TYPE_ERROR("str-utf8", "€€€€€€",
+ "Length \"6\" does not satisfy the length constraint.");
+ TEST_TYPE_ERROR("str-utf8", "€€x",
+ "String \"€€x\" does not conform to the pattern \"€*\".");
/* invalid length */
- TEST_DATA("<str xmlns=\"urn:tests:types\">short</str>", LY_EVALID, "Length \"5\" does not satisfy the length constraint. /types:str");
- TEST_DATA("<str xmlns=\"urn:tests:types\">tooooo long</str>", LY_EVALID, "Length \"11\" does not satisfy the length constraint. /types:str");
+ TEST_TYPE_ERROR("str", "short",
+ "Length \"5\" does not satisfy the length constraint.");
+ TEST_TYPE_ERROR("str", "tooooo long",
+ "Length \"11\" does not satisfy the length constraint.");
/* invalid pattern */
- TEST_DATA("<str xmlns=\"urn:tests:types\">string15</str>", LY_EVALID, "String \"string15\" does not conform to the pattern \"[a-z ]*\". /types:str");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("str", "string15", "String \"string15\" does not conform to the pattern \"[a-z ]*\".");
}
static void
test_bits(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_bits;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
/* valid data */
- TEST_DATA("<bits xmlns=\"urn:tests:types\">\n two \t\nzero\n </bits>", LY_SUCCESS, "");
- tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("bits", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("zero two", leaf->value.canonical);
- assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.bits_items));
- assert_string_equal("zero", leaf->value.bits_items[0]->name);
- assert_string_equal("two", leaf->value.bits_items[1]->name);
+ const char *bits_array[] = {"zero", "two"};
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_int_equal(2, LY_ARRAY_COUNT(value.bits_items));
- assert_string_equal("zero", value.bits_items[0]->name);
- assert_string_equal("two", value.bits_items[1]->name);
- value.realtype->plugin->free(s->ctx, &value);
- memset(&value, 0, sizeof value);
+ CHECK_PARSE_LYD("<bits xmlns=\"urn:tests:types\">\n two \t\nzero\n </bits>", tree);
+ assert_non_null(tree);
+ tree = tree->next;
+ TEST_PATTERN_1(tree, "bits", 1, BITS, "zero two", bits_array);
lyd_free_all(tree);
- TEST_DATA("<bits xmlns=\"urn:tests:types\">zero two</bits>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<bits xmlns=\"urn:tests:types\">zero two</bits>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("bits", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("zero two", leaf->value.canonical);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_int_equal(2, LY_ARRAY_COUNT(value.bits_items));
- assert_string_equal("zero", value.bits_items[0]->name);
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PATTERN_1(tree, "bits", 1, BITS, "zero two", bits_array);
lyd_free_all(tree);
/* disabled feature */
- TEST_DATA("<bits xmlns=\"urn:tests:types\"> \t one \n\t </bits>", LY_EVALID, "Bit \"one\" is disabled by its 1. if-feature condition. /types:bits");
+ TEST_TYPE_ERROR("bits", " \t one \n\t ", "Invalid bit value \"one\".");
+
+ /* disabled feature */
+ TEST_TYPE_ERROR("bits", "\t one \n\t", "Invalid bit value \"one\".");
/* multiple instances of the bit */
- TEST_DATA("<bits xmlns=\"urn:tests:types\">one zero one</bits>", LY_EVALID, "Bit \"one\" used multiple times. /types:bits");
+ TEST_TYPE_ERROR("bits", "one zero one", "Invalid bit value \"one\".");
/* invalid bit value */
- TEST_DATA("<bits xmlns=\"urn:tests:types\">one xero one</bits>", LY_EVALID, "Invalid bit value \"xero\". /types:bits");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("bits", "one xero one", "Invalid bit value \"one\".");
}
static void
test_enums(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_enums;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
/* valid data */
- TEST_DATA("<enums xmlns=\"urn:tests:types\">white</enums>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<enums xmlns=\"urn:tests:types\">white</enums>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("enums", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("white", leaf->value.canonical);
- assert_string_equal("white", leaf->value.enum_item->name);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- assert_string_equal("white", value.enum_item->name);
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PATTERN_1(tree, "enums", 1, ENUM, "white", "white");
lyd_free_all(tree);
/* disabled feature */
- TEST_DATA("<enums xmlns=\"urn:tests:types\">yellow</enums>", LY_EVALID,
- "Enumeration \"yellow\" is disabled by its 1. if-feature condition. /types:enums");
+ TEST_TYPE_ERROR("enums", "yellow", "Invalid enumeration value \"yellow\".");
/* leading/trailing whitespaces are not valid */
- TEST_DATA("<enums xmlns=\"urn:tests:types\"> white</enums>", LY_EVALID, "Invalid enumeration value \" white\". /types:enums");
- TEST_DATA("<enums xmlns=\"urn:tests:types\">white\n</enums>", LY_EVALID, "Invalid enumeration value \"white\n\". /types:enums");
+ TEST_TYPE_ERROR("enums", " white", "Invalid enumeration value \" white\".");
+ TEST_TYPE_ERROR("enums", "white\n", "Invalid enumeration value \"white\n\".");
/* invalid enumeration value */
- TEST_DATA("<enums xmlns=\"urn:tests:types\">black</enums>", LY_EVALID, "Invalid enumeration value \"black\". /types:enums");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("enums", "black", "Invalid enumeration value \"black\".");
}
static void
test_binary(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_binary;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
- struct lyd_value value = {0};
/* valid data (hello) */
- TEST_DATA("<binary xmlns=\"urn:tests:types\">\n aGVs\nbG8= \t\n </binary><binary-norestr xmlns=\"urn:tests:types\">TQ==</binary-norestr>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<binary xmlns=\"urn:tests:types\">\n aGVs\nbG8= \t\n </binary>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("binary", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("aGVs\nbG8=", leaf->value.canonical);
- assert_non_null(tree = tree->next);
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("binary-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("TQ==", leaf->value.canonical);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal(leaf->value.canonical, value.canonical);
- value.realtype->plugin->free(s->ctx, &value);
- memset(&value, 0, sizeof value);
+ TEST_PATTERN_1(tree, "binary", 1, BINARY, "aGVs\nbG8=");
+ lyd_free_all(tree);
+ CHECK_PARSE_LYD("<binary-norestr xmlns=\"urn:tests:types\">TQ==</binary-norestr>", tree);
+ assert_non_null(tree);
+ tree = tree->next;
+ assert_non_null(tree);
+ TEST_PATTERN_1(tree, "binary-norestr", 1, BINARY, "TQ==");
lyd_free_all(tree);
/* no data */
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\">\n \t\n </binary-norestr>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<binary-norestr xmlns=\"urn:tests:types\">\n \t\n </binary-norestr>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("binary-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("</binary-norestr>", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "binary-norestr", 1, BINARY, "</binary-norestr>");
lyd_free_all(tree);
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\"></binary-norestr>", LY_SUCCESS, "");
+
+ CHECK_PARSE_LYD("<binary-norestr xmlns=\"urn:tests:types\"></binary-norestr>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("binary-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "binary-norestr", 1, BINARY, "");
lyd_free_all(tree);
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\"/>", LY_SUCCESS, "");
+
+ CHECK_PARSE_LYD("<binary-norestr xmlns=\"urn:tests:types\"/>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("binary-norestr", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "binary-norestr", 1, BINARY, "");
lyd_free_all(tree);
/* invalid base64 character */
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\">a@bcd=</binary-norestr>", LY_EVALID,
- "Invalid Base64 character (@). /types:binary-norestr");
+ TEST_TYPE_ERROR("binary-norestr", "a@bcd=", "Invalid Base64 character (@).");
/* missing data */
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\">aGVsbG8</binary-norestr>", LY_EVALID,
- "Base64 encoded value length must be divisible by 4. /types:binary-norestr");
- TEST_DATA("<binary-norestr xmlns=\"urn:tests:types\">VsbG8=</binary-norestr>", LY_EVALID,
- "Base64 encoded value length must be divisible by 4. /types:binary-norestr");
+ TEST_TYPE_ERROR("binary-norestr", "aGVsbG8", "Base64 encoded value length must be divisible by 4.");
+
+ TEST_TYPE_ERROR("binary-norestr", "VsbG8=", "Base64 encoded value length must be divisible by 4.");
/* invalid binary length */
/* helloworld */
- TEST_DATA("<binary xmlns=\"urn:tests:types\">aGVsbG93b3JsZA==</binary>", LY_EVALID,
- "This base64 value must be of length 5. /types:binary");
- /* M */
- TEST_DATA("<binary xmlns=\"urn:tests:types\">TQ==</binary>", LY_EVALID,
- "This base64 value must be of length 5. /types:binary");
+ TEST_TYPE_ERROR("binary", "aGVsbG93b3JsZA==", "This base64 value must be of length 5.");
- ly_in_free(in, 0);
- s->func = NULL;
+ /* M */
+ TEST_TYPE_ERROR("binary", "TQ==", "This base64 value must be of length 5.");
}
static void
test_boolean(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_boolean;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
/* valid data */
- TEST_DATA("<bool xmlns=\"urn:tests:types\">true</bool>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<bool xmlns=\"urn:tests:types\">true</bool>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("bool", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("true", leaf->value.canonical);
- assert_int_equal(1, leaf->value.boolean);
+ TEST_PATTERN_1(tree, "bool", 1, BOOL, "true", 1);
lyd_free_all(tree);
- TEST_DATA("<bool xmlns=\"urn:tests:types\">false</bool>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<bool xmlns=\"urn:tests:types\">false</bool>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("bool", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("false", leaf->value.canonical);
- assert_int_equal(0, leaf->value.boolean);
+ TEST_PATTERN_1(tree, "bool", 1, BOOL, "false", 0);
lyd_free_all(tree);
- TEST_DATA("<tbool xmlns=\"urn:tests:types\">false</tbool>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<tbool xmlns=\"urn:tests:types\">false</tbool>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("tbool", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("false", leaf->value.canonical);
- assert_int_equal(0, leaf->value.boolean);
+ TEST_PATTERN_1(tree, "tbool", 1, BOOL, "false", 0);
lyd_free_all(tree);
/* invalid value */
- TEST_DATA("<bool xmlns=\"urn:tests:types\">unsure</bool>", LY_EVALID, "Invalid boolean value \"unsure\". /types:bool");
- TEST_DATA("<bool xmlns=\"urn:tests:types\"> true</bool>", LY_EVALID, "Invalid boolean value \" true\". /types:bool");
+ TEST_TYPE_ERROR("bool", "unsure", "Invalid boolean value \"unsure\".");
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("bool", " true", "Invalid boolean value \" true\".");
}
static void
test_empty(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_empty;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
- struct lyd_node_term *leaf;
/* valid data */
-
- TEST_DATA("<empty xmlns=\"urn:tests:types\"></empty>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<empty xmlns=\"urn:tests:types\"></empty>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("empty", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "empty", 1, EMPTY, "");
lyd_free_all(tree);
- TEST_DATA("<empty xmlns=\"urn:tests:types\"/>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<empty xmlns=\"urn:tests:types\"/>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("empty", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "empty", 1, EMPTY, "");
lyd_free_all(tree);
- TEST_DATA("<tempty xmlns=\"urn:tests:types\"/>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<tempty xmlns=\"urn:tests:types\"/>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("tempty", tree->schema->name);
- leaf = (struct lyd_node_term *)tree;
- assert_string_equal("", leaf->value.canonical);
+ TEST_PATTERN_1(tree, "tempty", 1, EMPTY, "");
lyd_free_all(tree);
/* invalid value */
- TEST_DATA("<empty xmlns=\"urn:tests:types\">x</empty>", LY_EVALID, "Invalid empty value \"x\". /types:empty");
- TEST_DATA("<empty xmlns=\"urn:tests:types\"> </empty>", LY_EVALID, "Invalid empty value \" \". /types:empty");
+ TEST_TYPE_ERROR("empty", "x", "Invalid empty value \"x\".");
- ly_in_free(in, 0);
- s->func = NULL;
-}
-
-static void
-test_printed_value(const struct lyd_value *value, const char *expected_value, LY_PREFIX_FORMAT format,
- const void *prefix_data)
-{
- const char *str;
- uint8_t dynamic;
-
- assert_non_null(str = value->realtype->plugin->print(value, format, (void *)prefix_data, &dynamic));
- assert_string_equal(expected_value, str);
- if (dynamic) {
- free((char *)str);
- }
+ TEST_TYPE_ERROR("empty", " ", "Invalid empty value \" \".");
}
static void
test_identityref(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_identityref;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
struct lyd_node_term *leaf;
- struct lyd_value value = {0};
+ const struct lys_module *mod_types;
+ const struct lys_module *mod_defs;
+
+ assert_non_null(mod_types = ly_ctx_get_module_implemented(UTEST_LYCTX, "types"));
+ assert_non_null(mod_defs = ly_ctx_get_module_implemented(UTEST_LYCTX, "defs"));
/* valid data */
- TEST_DATA("<ident xmlns=\"urn:tests:types\">gigabit-ethernet</ident>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<ident xmlns=\"urn:tests:types\">gigabit-ethernet</ident>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("ident", tree->schema->name);
+ TEST_PATTERN_1(tree, "ident", 1, IDENT, "types:gigabit-ethernet", "gigabit-ethernet");
leaf = (struct lyd_node_term *)tree;
- assert_non_null(leaf->value.canonical);
- assert_string_equal("types:gigabit-ethernet", leaf->value.canonical);
- assert_string_equal("gigabit-ethernet", leaf->value.ident->name);
- test_printed_value(&leaf->value, "t:gigabit-ethernet", LY_PREF_SCHEMA, s->mod_types->parsed);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal("types:gigabit-ethernet", value.canonical);
- assert_string_equal("gigabit-ethernet", value.ident->name);
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PRINTED_VALUE(&leaf->value, "t:gigabit-ethernet", LY_PREF_SCHEMA, mod_types->parsed);
lyd_free_all(tree);
- TEST_DATA("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</ident>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</ident>", tree);
+ assert_non_null(tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("ident", tree->schema->name);
+ TEST_PATTERN_1(tree, "ident", 1, IDENT, "defs:fast-ethernet", "fast-ethernet");
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("defs:fast-ethernet", leaf->value.canonical);
- test_printed_value(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, s->mod_defs->parsed);
+ TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
lyd_free_all(tree);
/* invalid value */
- TEST_DATA("<ident xmlns=\"urn:tests:types\">fast-ethernet</ident>", LY_EVALID,
- "Invalid identityref \"fast-ethernet\" value - identity not found. /types:ident");
- TEST_DATA("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:slow-ethernet</ident>", LY_EVALID,
- "Invalid identityref \"x:slow-ethernet\" value - identity not found. /types:ident");
- TEST_DATA("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:crypto-alg</ident>", LY_EVALID,
- "Invalid identityref \"x:crypto-alg\" value - identity not accepted by the type specification. /types:ident");
- TEST_DATA("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:unknown\">x:fast-ethernet</ident>", LY_EVALID,
- "Invalid identityref \"x:fast-ethernet\" value - unable to map prefix to YANG schema. /types:ident");
+ TEST_TYPE_ERROR("ident", "fast-ethernet",
+ "Invalid identityref \"fast-ethernet\" value - identity not found in module \"types\".");
- ly_in_free(in, 0);
- s->func = NULL;
+ CHECK_PARSE_LYD_PARAM("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:slow-ethernet</ident>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid identityref \"x:slow-ethernet\" value - identity not found in module \"defs\".",
+ "/types:ident");
+
+ CHECK_PARSE_LYD_PARAM("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:crypto-alg</ident>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid identityref \"x:crypto-alg\" value - identity not derived from the base \"defs:interface-type\".",
+ "/types:ident");
+
+ CHECK_PARSE_LYD_PARAM("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:unknown\">x:fast-ethernet</ident>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid identityref \"x:fast-ethernet\" value - unable to map prefix to YANG schema.",
+ "/types:ident");
}
/* dummy get_prefix callback for test_instanceid() */
@@ -705,281 +505,323 @@
static void
test_instanceid(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_instanceid;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
const struct lyd_node_term *leaf;
- struct lyd_value value = {0};
+ const struct lys_module *mod_types;
const char *data;
+ assert_non_null(mod_types = ly_ctx_get_module_implemented(UTEST_LYCTX, "types"));
+
/* valid data */
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaftarget/></cont>"
- "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:cont/xdf:leaftarget</xdf:inst>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<cont xmlns=\"urn:tests:types\"><leaftarget/></cont>"
+ "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:cont/xdf:leaftarget</xdf:inst>", tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:cont/leaftarget", leaf->value.canonical);
+ const enum ly_path_pred_type result_1[] = {LY_PATH_PREDTYPE_NONE, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:cont/leaftarget", result_1);
+ leaf = (struct lyd_node_term *)tree;
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x5, 1, "cont", 1, LYS_CONTAINER, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "leaftarget", 1, LYS_LEAF, 1, 0, NULL, 0);
+ lyd_free_all(tree);
+
+ CHECK_PARSE_LYD("<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id></list>"
+ "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[xdf:id='b']/xdf:id</xdf:inst>", tree);
+ tree = tree->prev;
+ const enum ly_path_pred_type result_2[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list[id='b']/id", result_2);
+ leaf = (struct lyd_node_term *)tree;
assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
- assert_string_equal("cont", leaf->value.target[0].node->name);
- assert_null(leaf->value.target[0].predicates);
- assert_string_equal("leaftarget", leaf->value.target[1].node->name);
- assert_null(leaf->value.target[1].predicates);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal("/types:cont/leaftarget", value.canonical);
- assert_true(LY_ARRAY_COUNT(leaf->value.target) == LY_ARRAY_COUNT(value.target));
- assert_true(leaf->value.target[0].node == value.target[0].node);
- assert_true(leaf->value.target[0].predicates == value.target[0].predicates); /* NULL */
- assert_true(leaf->value.target[1].node == value.target[1].node);
- assert_true(leaf->value.target[1].predicates == value.target[1].predicates); /* NULL */
- value.realtype->plugin->free(s->ctx, &value);
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x105, 1, "id", 1, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id></list>"
- "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[xdf:id='b']/xdf:id</xdf:inst>", LY_SUCCESS, "");
+ CHECK_PARSE_LYD("<leaflisttarget xmlns=\"urn:tests:types\">1</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">2</leaflisttarget>"
+ "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:leaflisttarget[.='1']</xdf:inst>", tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:list[id='b']/id", leaf->value.canonical);
+ const enum ly_path_pred_type result_3[] = {LY_PATH_PREDTYPE_LEAFLIST};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:leaflisttarget[.='1']", result_3);
+ leaf = (struct lyd_node_term *)tree;
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "leaflisttarget", 1, LYS_LEAFLIST, 0, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">1</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">2</leaflisttarget>"
- "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:leaflisttarget[.='1']</xdf:inst>", LY_SUCCESS, "");
- tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:leaflisttarget[.='1']", leaf->value.canonical);
- lyd_free_all(tree);
-
- TEST_DATA("<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='a']</id><value>x</value></list_inst>"
+ data = "<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='a']</id><value>x</value></list_inst>"
"<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='b']</id><value>y</value></list_inst>"
"<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list_inst[a:id=\"/a:leaflisttarget[.='b']\"]/a:value</a:inst>", LY_SUCCESS, "");
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list_inst[a:id=\"/a:leaflisttarget[.='b']\"]/a:value</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_4[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", result_4);
+ leaf = (struct lyd_node_term *)tree;
assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
- assert_string_equal("list_inst", leaf->value.target[0].node->name);
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list_inst", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "value", 0, LYS_LEAF, 1, 0, NULL, 0);
+
assert_int_equal(1, LY_ARRAY_COUNT(leaf->value.target[0].predicates));
- assert_string_equal("value", leaf->value.target[1].node->name);
assert_null(leaf->value.target[1].predicates);
-
- test_printed_value(&leaf->value, "/t:list_inst[t:id=\"/t:leaflisttarget[.='b']\"]/t:value", LY_PREF_SCHEMA, s->mod_types->parsed);
- test_printed_value(&leaf->value, "/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", LY_PREF_JSON, NULL);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal("/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", value.canonical);
- assert_true(LY_ARRAY_COUNT(leaf->value.target) == LY_ARRAY_COUNT(value.target));
- assert_true(leaf->value.target[0].node == value.target[0].node);
- assert_true(LY_ARRAY_COUNT(leaf->value.target[0].predicates) == LY_ARRAY_COUNT(value.target[0].predicates));
- assert_true(leaf->value.target[1].node == value.target[1].node);
- assert_true(leaf->value.target[1].predicates == value.target[1].predicates); /* NULL */
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PRINTED_VALUE(&leaf->value, "/t:list_inst[t:id=\"/t:leaflisttarget[.='b']\"]/t:value", LY_PREF_SCHEMA, mod_types->parsed);
+ TEST_PRINTED_VALUE(&leaf->value, "/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", LY_PREF_JSON, NULL);
lyd_free_all(tree);
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id><value>x</value></list>"
- "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[xdf:id='b']/xdf:value</xdf:inst>", LY_SUCCESS, "");
+ data = "<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id><value>x</value></list>"
+ "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[xdf:id='b']/xdf:value</xdf:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:list[id='b']/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_5[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list[id='b']/value", result_5);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "value", 1, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='a']</id><value>x</value></list_inst>"
+ data = "<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='a']</id><value>x</value></list_inst>"
"<list_inst xmlns=\"urn:tests:types\"><id xmlns:b=\"urn:tests:types\">/b:leaflisttarget[.='b']</id><value>y</value></list_inst>"
"<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list_inst[a:id=\"/a:leaflisttarget[.='a']\"]/a:value</a:inst>", LY_SUCCESS, "");
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list_inst[a:id=\"/a:leaflisttarget[.='a']\"]/a:value</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_string_equal("/types:list_inst[id=\"/types:leaflisttarget[.='a']\"]/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_6[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list_inst[id=\"/types:leaflisttarget[.='a']\"]/value", result_6);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list_inst", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "value", 0, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list_ident xmlns=\"urn:tests:types\"><id xmlns:dfs=\"urn:tests:defs\">dfs:ethernet</id><value>x</value></list_ident>"
+ data = "<list_ident xmlns=\"urn:tests:types\"><id xmlns:dfs=\"urn:tests:defs\">dfs:ethernet</id><value>x</value></list_ident>"
"<list_ident xmlns=\"urn:tests:types\"><id xmlns:dfs=\"urn:tests:defs\">dfs:fast-ethernet</id><value>y</value></list_ident>"
- "<a:inst xmlns:a=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">/a:list_ident[a:id='d:fast-ethernet']/a:value</a:inst>", LY_SUCCESS, "");
+ "<a:inst xmlns:a=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">/a:list_ident[a:id='d:fast-ethernet']/a:value</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_non_null(leaf->value.canonical);
- assert_string_equal("/types:list_ident[id='defs:fast-ethernet']/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_7[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list_ident[id='defs:fast-ethernet']/value", result_7);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list_ident", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "value", 0, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list2 xmlns=\"urn:tests:types\"><id>types:xxx</id><value>x</value></list2>"
+ data = "<list2 xmlns=\"urn:tests:types\"><id>types:xxx</id><value>x</value></list2>"
"<list2 xmlns=\"urn:tests:types\"><id>a:xxx</id><value>y</value></list2>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a:xxx'][a:value='y']/a:value</a:inst>", LY_SUCCESS, "");
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a:xxx'][a:value='y']/a:value</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_non_null(leaf->value.canonical);
- assert_string_equal("/types:list2[id='a:xxx'][value='y']/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_8[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list2[id='a:xxx'][value='y']/value", result_8);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list2", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x105, 1, "value", 0, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>types:xxx</id><value>x</value></list>"
+ data = "<list xmlns=\"urn:tests:types\"><id>types:xxx</id><value>x</value></list>"
"<list xmlns=\"urn:tests:types\"><id>a:xxx</id><value>y</value></list>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list[a:id='a:xxx']/a:value</a:inst>", LY_SUCCESS, "");
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list[a:id='a:xxx']/a:value</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("inst", tree->schema->name);
- leaf = (const struct lyd_node_term *)tree;
- assert_non_null(leaf->value.canonical);
- assert_string_equal("/types:list[id='a:xxx']/value", leaf->value.canonical);
+ const enum ly_path_pred_type result_9[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list[id='a:xxx']/value", result_9);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x5, 1, "value", 1, LYS_LEAF, 1, 0, NULL, 0);
lyd_free_all(tree);
- TEST_DATA("<list2 xmlns=\"urn:tests:types\"><id>a</id><value>a</value></list2>"
+ data = "<list2 xmlns=\"urn:tests:types\"><id>a</id><value>a</value></list2>"
"<list2 xmlns=\"urn:tests:types\"><id>c</id><value>b</value></list2>"
"<list2 xmlns=\"urn:tests:types\"><id>a</id><value>b</value></list2>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a'][a:value='b']/a:id</a:inst>", LY_SUCCESS, "");
- leaf = (const struct lyd_node_term *)tree->prev;
- assert_int_equal(LYS_LEAF, leaf->schema->nodetype);
- assert_string_equal("inst", leaf->schema->name);
- assert_non_null(leaf->value.canonical);
- assert_string_equal("/types:list2[id='a'][value='b']/id", leaf->value.canonical);
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a'][a:value='b']/a:id</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
+ tree = tree->prev;
+ const enum ly_path_pred_type result_10[] = {LY_PATH_PREDTYPE_LIST, LY_PATH_PREDTYPE_NONE};
+
+ TEST_PATTERN_1(tree, "inst", 1, INST, "/types:list2[id='a'][value='b']/id", result_10);
+ leaf = (struct lyd_node_term *)tree;
+ assert_int_equal(2, LY_ARRAY_COUNT(leaf->value.target));
+ CHECK_LYSC_NODE(leaf->value.target[0].node, NULL, 0, 0x85, 1, "list2", 1, LYS_LIST, 0, 0, NULL, 0);
+ CHECK_LYSC_NODE(leaf->value.target[1].node, NULL, 0, 0x105, 1, "id", 1, LYS_LEAF, 1, 0, NULL, 0);
assert_non_null(leaf = lyd_target(leaf->value.target, tree));
assert_string_equal("a", leaf->value.canonical);
assert_string_equal("b", ((struct lyd_node_term *)leaf->next)->value.canonical);
lyd_free_all(tree);
/* invalid value */
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id><value>x</value></list>"
- "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[2]/xdf:value</xdf:inst>", LY_EVALID,
- "Invalid instance-identifier \"/xdf:list[2]/xdf:value\" value - semantic error. /types:inst");
- TEST_DATA("<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:1leaftarget</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:1leaftarget\" value - syntax error. /types:inst");
- TEST_DATA("<t:inst xmlns:t=\"urn:tests:types\">/t:cont:t:1leaftarget</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont:t:1leaftarget\" value - syntax error. /types:inst");
- TEST_DATA("<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:invalid/t:path</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:invalid/t:path\" value - semantic error. /types:inst");
- TEST_DATA("<inst xmlns=\"urn:tests:types\" xmlns:t=\"urn:tests:invalid\">/t:cont/t:leaftarget</inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaftarget\" value - semantic error. /types:inst");
- TEST_DATA("<inst xmlns=\"urn:tests:types\">/cont/leaftarget</inst>", LY_EVALID,
- "Invalid instance-identifier \"/cont/leaftarget\" value - syntax error. /types:inst");
+ data = "<list xmlns=\"urn:tests:types\"><id>a</id></list>"
+ "<list xmlns=\"urn:tests:types\"><id>b</id><value>x</value></list>"
+ "<xdf:inst xmlns:xdf=\"urn:tests:types\">/xdf:list[2]/xdf:value</xdf:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/xdf:list[2]/xdf:value\" value - semantic error.", "/types:inst");
+
+ data = "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:1leaftarget</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:1leaftarget\" value - syntax error.", "/types:inst");
+
+ data = "<t:inst xmlns:t=\"urn:tests:types\">/t:cont:t:1leaftarget</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont:t:1leaftarget\" value - syntax error.", "/types:inst");
+
+ data = "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:invalid/t:path</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:invalid/t:path\" value - semantic error.", "/types:inst");
+
+ data = "<inst xmlns=\"urn:tests:types\" xmlns:t=\"urn:tests:invalid\">/t:cont/t:leaftarget</inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaftarget\" value - semantic error.", "/types:inst");
+
+ TEST_TYPE_ERROR("inst", "/cont/leaftarget", "Invalid instance-identifier \"/cont/leaftarget\" value - syntax error.");
/* instance-identifier is here in JSON format because it is already in internal representation without canonical prefixes */
- TEST_DATA("<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaftarget</t:inst>", LY_ENOTFOUND,
- "Invalid instance-identifier \"/types:cont/leaftarget\" value - required instance not found. /types:inst");
+ data = "<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaftarget</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_ENOTFOUND, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:cont/leaftarget\" value - required instance not found.", "/types:inst");
/* instance-identifier is here in JSON format because it is already in internal representation without canonical prefixes */
- TEST_DATA("<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaftarget</t:inst>", LY_ENOTFOUND,
- "Invalid instance-identifier \"/types:cont/leaftarget\" value - required instance not found. /types:inst");
+ data = "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaftarget</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_ENOTFOUND, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:cont/leaftarget\" value - required instance not found.", "/types:inst");
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><t:inst xmlns:t=\"urn:tests:types\">/t:leaflisttarget[1</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:leaflisttarget[1\" value - syntax error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">/t:cont[1]</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont[1]\" value - semantic error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">[1]</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"[1]\" value - syntax error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont><t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[id='1']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaflisttarget[id='1']\" value - syntax error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[t:id='1']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaflisttarget[t:id='1']\" value - semantic error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget><leaflisttarget>2</leaflisttarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[4]</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaflisttarget[4]\" value - semantic error. /types:inst");
- TEST_DATA("<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[6]</t:inst-noreq>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaflisttarget[6]\" value - semantic error. /types:inst-noreq");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:value='x']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:listtarget[t:value='x']\" value - semantic error. /types:inst");
- logbuf_clean();
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:leaflisttarget[1</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:leaflisttarget[1\" value - syntax error.", "/types:inst");
- TEST_DATA("<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:value='x']</t:inst-noreq>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:listtarget[t:value='x']\" value - semantic error. /types:inst-noreq");
- TEST_DATA("<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:x='x']</t:inst-noreq>", LY_ENOTFOUND,
- "Invalid instance-identifier \"/t:cont/t:listtarget[t:x='x']\" value - semantic error. /types:inst-noreq");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[.='x']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:listtarget[.='x']\" value - semantic error. /types:inst");
+ data = "<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">/t:cont[1]</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont[1]\" value - semantic error.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"/><t:inst xmlns:t=\"urn:tests:types\">[1]</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"[1]\" value - syntax error.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[id='1']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaflisttarget[id='1']\" value - syntax error.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[t:id='1']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaflisttarget[t:id='1']\" value - semantic error.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget><leaflisttarget>2</leaflisttarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[4]</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaflisttarget[4]\" value - semantic error.", "/types:inst");
+
+ data = "<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[6]</t:inst-noreq>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaflisttarget[6]\" value - semantic error.", "/types:inst-noreq");
+
+ data = "<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:value='x']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:listtarget[t:value='x']\" value - semantic error.", "/types:inst");
+
+ data = "<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:value='x']</t:inst-noreq>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:listtarget[t:value='x']\" value - semantic error.", "/types:inst-noreq");
+
+ data = "<t:inst-noreq xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:x='x']</t:inst-noreq>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_ENOTFOUND, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:listtarget[t:x='x']\" value - semantic error.", "/types:inst-noreq");
+
+ data = "<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[.='x']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:listtarget[.='x']\" value - semantic error.", "/types:inst");
/* instance-identifier is here in JSON format because it is already in internal representation without canonical prefixes */
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[.='2']</t:inst>", LY_ENOTFOUND,
- "Invalid instance-identifier \"/types:cont/leaflisttarget[.='2']\" value - required instance not found. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[.='x']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:leaflisttarget[.='x']\" value - semantic error. /types:inst");
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:id='x']</t:inst>", LY_EVALID,
- "Invalid instance-identifier \"/t:cont/t:listtarget[t:id='x']\" value - semantic error. /types:inst");
+ data = "<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[.='2']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_ENOTFOUND, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:cont/leaflisttarget[.='2']\" value - required instance not found.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"><leaflisttarget>1</leaflisttarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:leaflisttarget[.='x']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:leaflisttarget[.='x']\" value - semantic error.", "/types:inst");
+
+ data = "<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:id='x']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/t:cont/t:listtarget[t:id='x']\" value - semantic error.", "/types:inst");
/* instance-identifier is here in JSON format because it is already in internal representation without canonical prefixes */
- TEST_DATA("<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
- "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:id='2']</t:inst>", LY_ENOTFOUND,
- "Invalid instance-identifier \"/types:cont/listtarget[id='2']\" value - required instance not found. /types:inst");
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget>"
+ data = "<cont xmlns=\"urn:tests:types\"><listtarget><id>1</id><value>x</value></listtarget></cont>"
+ "<t:inst xmlns:t=\"urn:tests:types\">/t:cont/t:listtarget[t:id='2']</t:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_ENOTFOUND, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:cont/listtarget[id='2']\" value - required instance not found.", "/types:inst");
+
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget>"
"<leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:leaflisttarget[1][2]</a:inst>", LY_EVALID,
- "Invalid instance-identifier \"/a:leaflisttarget[1][2]\" value - syntax error. /types:inst");
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget>"
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:leaflisttarget[1][2]</a:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/a:leaflisttarget[1][2]\" value - syntax error.", "/types:inst");
+
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget>"
"<leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:leaflisttarget[.='a'][.='b']</a:inst>", LY_EVALID,
- "Invalid instance-identifier \"/a:leaflisttarget[.='a'][.='b']\" value - syntax error. /types:inst");
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>a</id><value>x</value></list>"
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:leaflisttarget[.='a'][.='b']</a:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/a:leaflisttarget[.='a'][.='b']\" value - syntax error.", "/types:inst");
+
+ data = "<list xmlns=\"urn:tests:types\"><id>a</id><value>x</value></list>"
"<list xmlns=\"urn:tests:types\"><id>b</id><value>y</value></list>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list[a:id='a'][a:id='b']/a:value</a:inst>", LY_EVALID,
- "Invalid instance-identifier \"/a:list[a:id='a'][a:id='b']/a:value\" value - syntax error. /types:inst");
- TEST_DATA("<list2 xmlns=\"urn:tests:types\"><id>a</id><value>x</value></list2>"
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list[a:id='a'][a:id='b']/a:value</a:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/a:list[a:id='a'][a:id='b']/a:value\" value - syntax error.", "/types:inst");
+
+ data = "<list2 xmlns=\"urn:tests:types\"><id>a</id><value>x</value></list2>"
"<list2 xmlns=\"urn:tests:types\"><id>b</id><value>y</value></list2>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a']/a:value</a:inst>", LY_EVALID,
- "Invalid instance-identifier \"/a:list2[a:id='a']/a:value\" value - semantic error. /types:inst");
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a']/a:value</a:inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/a:list2[a:id='a']/a:value\" value - semantic error.", "/types:inst");
/* check for validting instance-identifier with a complete data tree */
- TEST_DATA("<list2 xmlns=\"urn:tests:types\"><id>a</id><value>a</value></list2>"
+ data = "<list2 xmlns=\"urn:tests:types\"><id>a</id><value>a</value></list2>"
"<list2 xmlns=\"urn:tests:types\"><id>c</id><value>b</value></list2>"
"<leaflisttarget xmlns=\"urn:tests:types\">a</leaflisttarget>"
"<leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a'][a:value='a']/a:id</a:inst>", LY_SUCCESS, "");
-
+ "<a:inst xmlns:a=\"urn:tests:types\">/a:list2[a:id='a'][a:value='a']/a:id</a:inst>";
+ CHECK_PARSE_LYD(data, tree);
/* key-predicate */
data = "/types:list2[id='a'][value='b']/id";
- assert_int_equal(LY_ENOTFOUND, lyd_value_validate(s->ctx, (const struct lyd_node_term *)tree->prev, data, strlen(data),
+ assert_int_equal(LY_ENOTFOUND, lyd_value_validate(UTEST_LYCTX, (const struct lyd_node_term *)tree->prev, data, strlen(data),
tree, NULL));
- logbuf_assert("Invalid instance-identifier \"/types:list2[id='a'][value='b']/id\" value - required instance not found. /types:inst");
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:list2[id='a'][value='b']/id\" value - required instance not found.", "/types:inst");
/* leaf-list-predicate */
data = "/types:leaflisttarget[.='c']";
- assert_int_equal(LY_ENOTFOUND, lyd_value_validate(s->ctx, (const struct lyd_node_term *)tree->prev, data, strlen(data),
+ assert_int_equal(LY_ENOTFOUND, lyd_value_validate(UTEST_LYCTX, (const struct lyd_node_term *)tree->prev, data, strlen(data),
tree, NULL));
- logbuf_assert("Invalid instance-identifier \"/types:leaflisttarget[.='c']\" value - required instance not found. /types:inst");
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:leaflisttarget[.='c']\" value - required instance not found.", "/types:inst");
/* position predicate */
data = "/types:list_keyless[4]";
- assert_int_equal(LY_ENOTFOUND, lyd_value_validate(s->ctx, (const struct lyd_node_term *)tree->prev, data, strlen(data),
+ assert_int_equal(LY_ENOTFOUND, lyd_value_validate(UTEST_LYCTX, (const struct lyd_node_term *)tree->prev, data, strlen(data),
tree, NULL));
- logbuf_assert("Invalid instance-identifier \"/types:list_keyless[4]\" value - required instance not found. /types:inst");
+ CHECK_LOG_CTX("Invalid instance-identifier \"/types:list_keyless[4]\" value - required instance not found.", "/types:inst");
lyd_free_all(tree);
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
- "<inst xmlns=\"urn:tests:types\">/a:leaflisttarget[1]</inst>", LY_EVALID,
- "Invalid instance-identifier \"/a:leaflisttarget[1]\" value - semantic error. /types:inst");
-
- ly_in_free(in, 0);
-
- s->func = NULL;
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">b</leaflisttarget>"
+ "<inst xmlns=\"urn:tests:types\">/a:leaflisttarget[1]</inst>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid instance-identifier \"/a:leaflisttarget[1]\" value - semantic error.", "/types:inst");
}
static void
test_leafref(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_leafref;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
struct lyd_node_term *leaf;
+ const char *data;
/* types:lref: /leaflisttarget */
/* types:lref2: ../list[id = current()/../str-norestr]/targets */
@@ -992,100 +834,112 @@
"}}}";
/* additional schema */
- assert_int_equal(LY_SUCCESS, lys_parse_mem(s->ctx, schema, LYS_IN_YANG, NULL));
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
/* valid data */
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget><lref xmlns=\"urn:tests:types\">y</lref>", LY_SUCCESS, "");
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget>"
+ "<leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget>"
+ "<lref xmlns=\"urn:tests:types\">y</lref>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("lref", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, 0x5, 1, "lref", 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("y", leaf->value.canonical);
- assert_int_equal(LY_TYPE_STRING, leaf->value.realtype->plugin->type);
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 0, 1, STRING, "y");
lyd_free_all(tree);
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
+ data = "<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
"<list xmlns=\"urn:tests:types\"><id>y</id><targets>x</targets><targets>y</targets></list>"
- "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">y</lref2>", LY_SUCCESS, "");
+ "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">y</lref2>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("lref2", tree->schema->name);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, 0x5, 1, "lref2", 1, LYS_LEAF, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("y", leaf->value.canonical);
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 0, 1, STRING, "y");
lyd_free_all(tree);
- TEST_DATA("<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
- "<c xmlns=\"urn:tests:leafrefs\"><l><id>x</id><value>x</value><lr1>y</lr1></l></c>", LY_SUCCESS, "");
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
+ data = "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
+ "<c xmlns=\"urn:tests:leafrefs\"><l><id>x</id><value>x</value><lr1>y</lr1></l></c>";
+ CHECK_PARSE_LYD(data, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, 0x5, 1, "c", 0, LYS_CONTAINER, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)(lyd_child(lyd_child(tree)->next)->prev);
- assert_int_equal(LYS_LEAF, leaf->schema->nodetype);
- assert_string_equal("lr1", leaf->schema->name);
- assert_string_equal("y", leaf->value.canonical);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, 0x5, 1, "lr1", 1, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 1, 1, STRING, "y");
lyd_free_all(tree);
- TEST_DATA("<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
+ data = "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
"<c xmlns=\"urn:tests:leafrefs\"><l><id>y</id><value>y</value></l>"
- "<l><id>x</id><value>x</value><lr2>y</lr2></l></c>", LY_SUCCESS, "");
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
+ "<l><id>x</id><value>x</value><lr2>y</lr2></l></c>";
+ CHECK_PARSE_LYD(data, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, 0x5, 1, "c", 0, LYS_CONTAINER, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)(lyd_child(lyd_child(tree)->prev)->prev);
- assert_int_equal(LYS_LEAF, leaf->schema->nodetype);
- assert_string_equal("lr2", leaf->schema->name);
- assert_string_equal("y", leaf->value.canonical);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, 0x5, 1, "lr2", 1, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 1, 1, STRING, "y");
lyd_free_all(tree);
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
+ data = "<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
"<list xmlns=\"urn:tests:types\"><id>y</id><targets>c</targets><targets>d</targets></list>"
"<c xmlns=\"urn:tests:leafrefs\"><x><x>y</x></x>"
- "<l><id>x</id><value>x</value><lr3>c</lr3></l></c>", LY_SUCCESS, "");
- assert_int_equal(LYS_CONTAINER, tree->schema->nodetype);
+ "<l><id>x</id><value>x</value><lr3>c</lr3></l></c>";
+ CHECK_PARSE_LYD(data, tree);
+ CHECK_LYSC_NODE(tree->schema, NULL, 0, 0x5, 1, "c", 0, LYS_CONTAINER, 0, 0, NULL, 0);
leaf = (struct lyd_node_term *)(lyd_child(lyd_child(tree)->prev)->prev);
- assert_int_equal(LYS_LEAF, leaf->schema->nodetype);
- assert_string_equal("lr3", leaf->schema->name);
- assert_string_equal("c", leaf->value.canonical);
+ CHECK_LYSC_NODE(leaf->schema, NULL, 0, 0x5, 1, "lr3", 0, LYS_LEAF, 1, 0, NULL, 0);
+ CHECK_LYD_NODE_TERM(leaf, 0, 0, 0, 1, 1, STRING, "c");
lyd_free_all(tree);
/* invalid value */
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><lref xmlns=\"urn:tests:types\">y</lref>", LY_EVALID,
- "Invalid leafref value \"y\" - no target instance \"/leaflisttarget\" with the same value. /types:lref");
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><lref xmlns=\"urn:tests:types\">y</lref>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"y\" - "
+ "no target instance \"/leaflisttarget\" with the same value.",
+ "/types:lref");
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
+ data = "<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
"<list xmlns=\"urn:tests:types\"><id>y</id><targets>x</targets><targets>y</targets></list>"
- "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">b</lref2>", LY_EVALID,
- "Invalid leafref value \"b\" - no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value. /types:lref2");
+ "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">b</lref2>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"b\" - "
+ "no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value.",
+ "/types:lref2");
- TEST_DATA("<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
+ data = "<list xmlns=\"urn:tests:types\"><id>x</id><targets>a</targets><targets>b</targets></list>"
"<list xmlns=\"urn:tests:types\"><id>y</id><targets>x</targets><targets>y</targets></list>"
- "<lref2 xmlns=\"urn:tests:types\">b</lref2>", LY_EVALID,
- "Invalid leafref value \"b\" - no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value. /types:lref2");
+ "<lref2 xmlns=\"urn:tests:types\">b</lref2>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"b\" - "
+ "no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value.",
+ "/types:lref2");
- TEST_DATA("<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">b</lref2>", LY_EVALID,
- "Invalid leafref value \"b\" - no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value. /types:lref2");
+ data = "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr><lref2 xmlns=\"urn:tests:types\">b</lref2>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"b\" - "
+ "no target instance \"../list[id = current()/../str-norestr]/targets\" with the same value.",
+ "/types:lref2");
- TEST_DATA("<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
- "<c xmlns=\"urn:tests:leafrefs\"><l><id>x</id><value>x</value><lr1>a</lr1></l></c>", LY_EVALID,
- "Invalid leafref value \"a\" - no target instance \"../../../t:str-norestr\" with the same value. /leafrefs:c/l[id='x'][value='x']/lr1");
+ data = "<str-norestr xmlns=\"urn:tests:types\">y</str-norestr>"
+ "<c xmlns=\"urn:tests:leafrefs\"><l><id>x</id><value>x</value><lr1>a</lr1></l></c>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"a\" - no target instance \"../../../t:str-norestr\" with the same value.",
+ "/leafrefs:c/l[id='x'][value='x']/lr1");
- TEST_DATA("<str-norestr xmlns=\"urn:tests:types\">z</str-norestr>"
+ data = "<str-norestr xmlns=\"urn:tests:types\">z</str-norestr>"
"<c xmlns=\"urn:tests:leafrefs\"><l><id>y</id><value>y</value></l>"
- "<l><id>x</id><value>x</value><lr2>z</lr2></l></c>", LY_EVALID,
- "Invalid leafref value \"z\" - no target instance \"../../l[id=current()/../../../t:str-norestr]"
- "[value=current()/../../../t:str-norestr]/value\" with the same value. /leafrefs:c/l[id='x'][value='x']/lr2");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ "<l><id>x</id><value>x</value><lr2>z</lr2></l></c>";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid leafref value \"z\" - no target instance \"../../l[id=current()/../../../t:str-norestr]"
+ "[value=current()/../../../t:str-norestr]/value\" with the same value.",
+ "/leafrefs:c/l[id='x'][value='x']/lr2");
}
static void
test_union(void **state)
{
- struct state_s *s = (struct state_s *)(*state);
-
- s->func = test_union;
-
- struct ly_in *in = NULL;
struct lyd_node *tree;
struct lyd_node_term *leaf;
- struct lyd_value value = {0};
+ const char *data;
+ const struct lys_module *mod_defs;
+
+ assert_non_null(mod_defs = ly_ctx_get_module_implemented(UTEST_LYCTX, "defs"));
/*
* leaf un1 {type union {
@@ -1100,133 +954,84 @@
*/
/* valid data */
- TEST_DATA("<int8 xmlns=\"urn:tests:types\">12</int8><un1 xmlns=\"urn:tests:types\">12</un1>", LY_SUCCESS, "");
+ data = "<int8 xmlns=\"urn:tests:types\">12</int8><un1 xmlns=\"urn:tests:types\">12</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->next->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "12", INT8, "12", 12);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("12", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 0);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_INT8, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("12", leaf->value.subvalue->value.canonical);
- assert_int_equal(12, leaf->value.subvalue->value.int8);
-
- test_printed_value(&leaf->value, "12", LY_PREF_SCHEMA, NULL);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal("12", value.canonical);
- assert_non_null(value.subvalue->prefix_data);
- assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 0);
- assert_int_equal(LY_TYPE_INT8, value.subvalue->value.realtype->basetype);
- assert_string_equal("12", value.subvalue->value.canonical);
- assert_int_equal(12, leaf->value.subvalue->value.int8);
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PRINTED_VALUE(&leaf->value, "12", LY_PREF_SCHEMA, NULL);
lyd_free_all(tree);
- TEST_DATA("<int8 xmlns=\"urn:tests:types\">12</int8><un1 xmlns=\"urn:tests:types\">2</un1>", LY_SUCCESS, "");
+ data = "<int8 xmlns=\"urn:tests:types\">12</int8><un1 xmlns=\"urn:tests:types\">2</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->next->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "2", STRING, "2");
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("2", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 0);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("2", leaf->value.subvalue->value.canonical);
+ TEST_PRINTED_VALUE(&leaf->value, "2", LY_PREF_SCHEMA, NULL);
lyd_free_all(tree);
- TEST_DATA("<un1 xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</un1>", LY_SUCCESS, "");
+ data = "<un1 xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "defs:fast-ethernet", IDENT, "defs:fast-ethernet", "fast-ethernet");
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("defs:fast-ethernet", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_IDENT, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("defs:fast-ethernet", leaf->value.subvalue->value.canonical);
-
- test_printed_value(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, s->mod_defs->parsed);
- test_printed_value(&leaf->value.subvalue->value, "d:fast-ethernet", LY_PREF_SCHEMA, s->mod_defs->parsed);
-
- assert_int_equal(LY_SUCCESS, leaf->value.realtype->plugin->duplicate(s->ctx, &leaf->value, &value));
- assert_string_equal("defs:fast-ethernet", value.canonical);
- assert_string_equal("defs:fast-ethernet", value.subvalue->value.canonical);
- assert_non_null(value.subvalue->prefix_data);
- assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
- assert_int_equal(LY_TYPE_IDENT, value.subvalue->value.realtype->basetype);
- assert_string_equal("fast-ethernet", value.subvalue->value.ident->name);
- value.realtype->plugin->free(s->ctx, &value);
+ TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
+ TEST_PRINTED_VALUE(&leaf->value.subvalue->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
lyd_free_all(tree);
- TEST_DATA("<un1 xmlns=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">d:superfast-ethernet</un1>", LY_SUCCESS, "");
+ data = "<un1 xmlns=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">d:superfast-ethernet</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->next;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "d:superfast-ethernet", STRING, "d:superfast-ethernet");
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("d:superfast-ethernet", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("d:superfast-ethernet", leaf->value.subvalue->value.canonical);
lyd_free_all(tree);
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget>"
- "<un1 xmlns=\"urn:tests:types\" xmlns:a=\"urn:tests:types\">/a:leaflisttarget[.='y']</un1>", LY_SUCCESS, "");
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget>"
+ "<un1 xmlns=\"urn:tests:types\" xmlns:a=\"urn:tests:types\">/a:leaflisttarget[.='y']</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ const enum ly_path_pred_type result_1[] = {LY_PATH_PREDTYPE_LEAFLIST};
+
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "/types:leaflisttarget[.='y']", INST, "/types:leaflisttarget[.='y']", result_1);
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("/types:leaflisttarget[.='y']", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
+
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_INST, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("/types:leaflisttarget[.='y']", leaf->value.subvalue->value.canonical);
lyd_free_all(tree);
- TEST_DATA("<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget>"
- "<un1 xmlns=\"urn:tests:types\" xmlns:a=\"urn:tests:types\">/a:leaflisttarget[3]</un1>", LY_SUCCESS, "");
+ data = "<leaflisttarget xmlns=\"urn:tests:types\">x</leaflisttarget><leaflisttarget xmlns=\"urn:tests:types\">y</leaflisttarget>"
+ "<un1 xmlns=\"urn:tests:types\" xmlns:a=\"urn:tests:types\">/a:leaflisttarget[3]</un1>";
+ CHECK_PARSE_LYD(data, tree);
tree = tree->prev;
- assert_int_equal(LYS_LEAF, tree->schema->nodetype);
- assert_string_equal("un1", tree->schema->name);
+ TEST_PATTERN_1(tree, "un1", 0, UNION, "/a:leaflisttarget[3]", STRING, "/a:leaflisttarget[3]");
leaf = (struct lyd_node_term *)tree;
- assert_string_equal("/a:leaflisttarget[3]", leaf->value.canonical);
- assert_non_null(leaf->value.subvalue->prefix_data);
assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
- assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
- assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value.realtype->basetype);
- assert_string_equal("/a:leaflisttarget[3]", leaf->value.subvalue->value.canonical);
lyd_free_all(tree);
- TEST_DATA("<un1 xmlns=\"urn:tests:types\">123456789012345678901</un1>", LY_EVALID, "Invalid union value \"123456789012345678901\" - no matching subtype found. /types:un1");
-
- ly_in_free(in, 0);
- s->func = NULL;
+ TEST_TYPE_ERROR("un1", "123456789012345678901",
+ "Invalid union value \"123456789012345678901\" - no matching subtype found.");
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_setup_teardown(test_int, setup, teardown),
- cmocka_unit_test_setup_teardown(test_uint, setup, teardown),
- cmocka_unit_test_setup_teardown(test_dec64, setup, teardown),
- cmocka_unit_test_setup_teardown(test_string, setup, teardown),
- cmocka_unit_test_setup_teardown(test_bits, setup, teardown),
- cmocka_unit_test_setup_teardown(test_enums, setup, teardown),
- cmocka_unit_test_setup_teardown(test_binary, setup, teardown),
- cmocka_unit_test_setup_teardown(test_boolean, setup, teardown),
- cmocka_unit_test_setup_teardown(test_empty, setup, teardown),
- cmocka_unit_test_setup_teardown(test_identityref, setup, teardown),
- cmocka_unit_test_setup_teardown(test_instanceid, setup, teardown),
- cmocka_unit_test_setup_teardown(test_leafref, setup, teardown),
- cmocka_unit_test_setup_teardown(test_union, setup, teardown),
+ UTEST(test_int, setup),
+ UTEST(test_uint, setup),
+ UTEST(test_dec64, setup),
+ UTEST(test_string, setup),
+ UTEST(test_bits, setup),
+ UTEST(test_enums, setup),
+ UTEST(test_binary, setup),
+ UTEST(test_boolean, setup),
+ UTEST(test_empty, setup),
+ UTEST(test_identityref, setup),
+ UTEST(test_instanceid, setup),
+ UTEST(test_leafref, setup),
+ UTEST(test_union, setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
diff --git a/tests/utests/data/test_validation.c b/tests/utests/data/test_validation.c
index 2e8bf5f..c29ac4d 100644
--- a/tests/utests/data/test_validation.c
+++ b/tests/utests/data/test_validation.c
@@ -11,6 +11,8 @@
*
* https://opensource.org/licenses/BSD-3-Clause
*/
+#define _UTEST_MAIN_
+#include "utests.h"
#include <stdio.h>
#include <string.h>
@@ -23,42 +25,15 @@
#include "tests/config.h"
#include "tree_data_internal.h"
#include "tree_schema.h"
-#include "utests.h"
-#define BUFSIZE 1024
-char logbuf[BUFSIZE] = {0};
-int store = -1; /* negative for infinite logging, positive for limited logging */
+#define LYD_TREE_CREATE(INPUT, MODEL) \
+ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, MODEL)
-struct ly_ctx *ctx; /* context for tests */
-
-/* set to 0 to printing error messages to stderr instead of checking them in code */
-#define ENABLE_LOGGER_CHECKING 1
-
-#if ENABLE_LOGGER_CHECKING
static void
-logger(LY_LOG_LEVEL level, const char *msg, const char *path)
+test_when(void **state)
{
- (void) level; /* unused */
- if (store) {
- if (path && path[0]) {
- snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
- } else {
- strncpy(logbuf, msg, BUFSIZE - 1);
- }
- if (store > 0) {
- --store;
- }
- }
-}
-
-#endif
-
-static int
-setup(void **state)
-{
- (void) state; /* unused */
-
- const char *schema_a =
+ struct lyd_node *tree;
+ const char *schema =
"module a {\n"
" namespace urn:tests:a;\n"
" prefix a;\n"
@@ -78,7 +53,30 @@
" type string;\n"
" }\n"
"}";
- const char *schema_b =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+
+ CHECK_PARSE_LYD_PARAM("<c xmlns=\"urn:tests:a\">hey</c>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("When condition \"/cont/b = 'val_b'\" not satisfied.", "/a:c");
+
+ LYD_TREE_CREATE("<cont xmlns=\"urn:tests:a\"><b>val_b</b></cont><c xmlns=\"urn:tests:a\">hey</c>", tree);
+ CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 0, LYS_LEAF, 0, 0, NULL, 1);
+ assert_int_equal(LYD_WHEN_TRUE, tree->next->flags);
+ lyd_free_all(tree);
+
+ LYD_TREE_CREATE("<cont xmlns=\"urn:tests:a\"><a>val</a><b>val_b</b></cont><c xmlns=\"urn:tests:a\">val_c</c>", tree);
+ CHECK_LYSC_NODE(lyd_child(tree)->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 1);
+ assert_int_equal(LYD_WHEN_TRUE, lyd_child(tree)->flags);
+ CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 0, LYS_LEAF, 0, 0, NULL, 1);
+ assert_int_equal(LYD_WHEN_TRUE, tree->next->flags);
+ lyd_free_all(tree);
+}
+
+static void
+test_mandatory(void **state)
+{
+ struct lyd_node *tree;
+ const char *schema =
"module b {\n"
" namespace urn:tests:b;\n"
" prefix b;\n"
@@ -103,7 +101,27 @@
" type empty;\n"
" }\n"
"}";
- const char *schema_c =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+
+ CHECK_PARSE_LYD_PARAM("<d xmlns=\"urn:tests:b\"/>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Mandatory node \"choic\" instance does not exist.", "/b:choic");
+
+ CHECK_PARSE_LYD_PARAM("<l xmlns=\"urn:tests:b\">string</l><d xmlns=\"urn:tests:b\"/>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Mandatory node \"c\" instance does not exist.", "/b:c");
+
+ CHECK_PARSE_LYD_PARAM("<a xmlns=\"urn:tests:b\">string</a>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Mandatory node \"c\" instance does not exist.", "/b:c");
+
+ LYD_TREE_CREATE("<a xmlns=\"urn:tests:b\">string</a><c xmlns=\"urn:tests:b\">string2</c>", tree);
+ lyd_free_siblings(tree);
+}
+
+static void
+test_minmax(void **state)
+{
+ struct lyd_node *tree;
+ const char *schema =
"module c {\n"
" namespace urn:tests:c;\n"
" prefix c;\n"
@@ -131,56 +149,431 @@
" type empty;\n"
" }\n"
"}";
- const char *schema_d =
- "module d {\n"
- " namespace urn:tests:d;\n"
- " prefix d;\n"
- " yang-version 1.1;\n"
- "\n"
- " list lt {\n"
- " key \"k\";\n"
- " unique \"l1\";\n"
- " leaf k {\n"
- " type string;\n"
- " }\n"
- " leaf l1 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " list lt2 {\n"
- " key \"k\";\n"
- " unique \"cont/l2 l4\";\n"
- " unique \"l5 l6\";\n"
- " leaf k {\n"
- " type string;\n"
- " }\n"
- " container cont {\n"
- " leaf l2 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " leaf l4 {\n"
- " type string;\n"
- " }\n"
- " leaf l5 {\n"
- " type string;\n"
- " }\n"
- " leaf l6 {\n"
- " type string;\n"
- " }\n"
- " list lt3 {\n"
- " key \"kk\";\n"
- " unique \"l3\";\n"
- " leaf kk {\n"
- " type string;\n"
- " }\n"
- " leaf l3 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " }\n"
- "}";
- const char *schema_e =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+
+ CHECK_PARSE_LYD_PARAM("<d xmlns=\"urn:tests:c\"/>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Too few \"l\" instances.", "/c:choic/b/l");
+
+ CHECK_PARSE_LYD_PARAM("<l xmlns=\"urn:tests:c\">val1</l>"
+ "<l xmlns=\"urn:tests:c\">val2</l>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Too few \"l\" instances.", "/c:choic/b/l");
+
+ LYD_TREE_CREATE("<l xmlns=\"urn:tests:c\">val1</l>"
+ "<l xmlns=\"urn:tests:c\">val2</l>"
+ "<l xmlns=\"urn:tests:c\">val3</l>", tree);
+ lyd_free_all(tree);
+
+ CHECK_PARSE_LYD_PARAM("<l xmlns=\"urn:tests:c\">val1</l>"
+ "<l xmlns=\"urn:tests:c\">val2</l>"
+ "<l xmlns=\"urn:tests:c\">val3</l>"
+ "<lt xmlns=\"urn:tests:c\"><k>val1</k></lt>"
+ "<lt xmlns=\"urn:tests:c\"><k>val2</k></lt>"
+ "<lt xmlns=\"urn:tests:c\"><k>val3</k></lt>"
+ "<lt xmlns=\"urn:tests:c\"><k>val4</k></lt>"
+ "<lt xmlns=\"urn:tests:c\"><k>val5</k></lt>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Too many \"lt\" instances.", "/c:lt");
+}
+
+const char *schema_d =
+ "module d {\n"
+ " namespace urn:tests:d;\n"
+ " prefix d;\n"
+ " yang-version 1.1;\n"
+ "\n"
+ " list lt {\n"
+ " key \"k\";\n"
+ " unique \"l1\";\n"
+ " leaf k {\n"
+ " type string;\n"
+ " }\n"
+ " leaf l1 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " list lt2 {\n"
+ " key \"k\";\n"
+ " unique \"cont/l2 l4\";\n"
+ " unique \"l5 l6\";\n"
+ " leaf k {\n"
+ " type string;\n"
+ " }\n"
+ " container cont {\n"
+ " leaf l2 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " leaf l4 {\n"
+ " type string;\n"
+ " }\n"
+ " leaf l5 {\n"
+ " type string;\n"
+ " }\n"
+ " leaf l6 {\n"
+ " type string;\n"
+ " }\n"
+ " list lt3 {\n"
+ " key \"kk\";\n"
+ " unique \"l3\";\n"
+ " leaf kk {\n"
+ " type string;\n"
+ " }\n"
+ " leaf l3 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "}";
+
+static void
+test_unique(void **state)
+{
+ struct lyd_node *tree;
+
+ UTEST_ADD_MODULE(schema_d, LYS_IN_YANG, NULL, NULL);
+
+ LYD_TREE_CREATE("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>same</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ "</lt>", tree);
+ lyd_free_all(tree);
+
+ LYD_TREE_CREATE("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>same</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <l1>not-same</l1>\n"
+ "</lt>", tree);
+ lyd_free_all(tree);
+
+ CHECK_PARSE_LYD_PARAM("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>same</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <l1>same</l1>\n"
+ "</lt>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Unique data leaf(s) \"l1\" not satisfied in \"/d:lt[k='val1']\" and \"/d:lt[k='val2']\".", "/d:lt[k='val2']");
+
+ /* now try with more instances */
+ LYD_TREE_CREATE("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>1</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <l1>2</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <l1>3</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <l1>4</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <l1>5</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val6</k>\n"
+ " <l1>6</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val7</k>\n"
+ " <l1>7</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val8</k>\n"
+ " <l1>8</l1>\n"
+ "</lt>", tree);
+ lyd_free_all(tree);
+
+ LYD_TREE_CREATE("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>1</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <l1>2</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <l1>3</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <l1>5</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val6</k>\n"
+ " <l1>6</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val7</k>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val8</k>\n"
+ "</lt>", tree);
+ lyd_free_all(tree);
+
+ CHECK_PARSE_LYD_PARAM("<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <l1>1</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <l1>2</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <l1>4</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val6</k>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val7</k>\n"
+ " <l1>2</l1>\n"
+ "</lt>\n"
+ "<lt xmlns=\"urn:tests:d\">\n"
+ " <k>val8</k>\n"
+ " <l1>8</l1>\n"
+ "</lt>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Unique data leaf(s) \"l1\" not satisfied in \"/d:lt[k='val7']\" and \"/d:lt[k='val2']\".", "/d:lt[k='val2']");
+}
+
+static void
+test_unique_nested(void **state)
+{
+ struct lyd_node *tree;
+
+ UTEST_ADD_MODULE(schema_d, LYS_IN_YANG, NULL, NULL);
+
+ /* nested list uniquest are compared only with instances in the same parent list instance */
+ LYD_TREE_CREATE("<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <cont>\n"
+ " <l2>1</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <cont>\n"
+ " <l2>2</l2>\n"
+ " </cont>\n"
+ " <l4>2</l4>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>1</l3>\n"
+ " </lt3>\n"
+ " <lt3>\n"
+ " <kk>val2</kk>\n"
+ " <l3>2</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <cont>\n"
+ " <l2>3</l2>\n"
+ " </cont>\n"
+ " <l4>3</l4>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>2</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <cont>\n"
+ " <l2>4</l2>\n"
+ " </cont>\n"
+ " <l4>4</l4>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>3</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <cont>\n"
+ " <l2>5</l2>\n"
+ " </cont>\n"
+ " <l4>5</l4>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>3</l3>\n"
+ " </lt3>\n"
+ "</lt2>", tree);
+ lyd_free_all(tree);
+
+ CHECK_PARSE_LYD_PARAM("<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <cont>\n"
+ " <l2>1</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <cont>\n"
+ " <l2>2</l2>\n"
+ " </cont>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>1</l3>\n"
+ " </lt3>\n"
+ " <lt3>\n"
+ " <kk>val2</kk>\n"
+ " <l3>2</l3>\n"
+ " </lt3>\n"
+ " <lt3>\n"
+ " <kk>val3</kk>\n"
+ " <l3>1</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <cont>\n"
+ " <l2>3</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>2</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <cont>\n"
+ " <l2>4</l2>\n"
+ " </cont>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>3</l3>\n"
+ " </lt3>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <cont>\n"
+ " <l2>5</l2>\n"
+ " </cont>\n"
+ " <lt3>\n"
+ " <kk>val1</kk>\n"
+ " <l3>3</l3>\n"
+ " </lt3>\n"
+ "</lt2>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Unique data leaf(s) \"l3\" not satisfied in"
+ " \"/d:lt2[k='val2']/lt3[kk='val3']\" and"
+ " \"/d:lt2[k='val2']/lt3[kk='val1']\".", "/d:lt2[k='val2']/lt3[kk='val1']");
+
+ CHECK_PARSE_LYD_PARAM("<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <cont>\n"
+ " <l2>1</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <cont>\n"
+ " <l2>2</l2>\n"
+ " </cont>\n"
+ " <l4>2</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <cont>\n"
+ " <l2>3</l2>\n"
+ " </cont>\n"
+ " <l4>3</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <cont>\n"
+ " <l2>2</l2>\n"
+ " </cont>\n"
+ " <l4>2</l4>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <cont>\n"
+ " <l2>5</l2>\n"
+ " </cont>\n"
+ " <l4>5</l4>\n"
+ "</lt2>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Unique data leaf(s) \"cont/l2 l4\" not satisfied in \"/d:lt2[k='val4']\" and \"/d:lt2[k='val2']\".", "/d:lt2[k='val2']");
+
+ CHECK_PARSE_LYD_PARAM("<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val1</k>\n"
+ " <cont>\n"
+ " <l2>1</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <l5>1</l5>\n"
+ " <l6>1</l6>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val2</k>\n"
+ " <cont>\n"
+ " <l2>2</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <l5>1</l5>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val3</k>\n"
+ " <cont>\n"
+ " <l2>3</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <l5>3</l5>\n"
+ " <l6>3</l6>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val4</k>\n"
+ " <cont>\n"
+ " <l2>4</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <l6>1</l6>\n"
+ "</lt2>\n"
+ "<lt2 xmlns=\"urn:tests:d\">\n"
+ " <k>val5</k>\n"
+ " <cont>\n"
+ " <l2>5</l2>\n"
+ " </cont>\n"
+ " <l4>1</l4>\n"
+ " <l5>3</l5>\n"
+ " <l6>3</l6>\n"
+ "</lt2>", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Unique data leaf(s) \"l5 l6\" not satisfied in \"/d:lt2[k='val5']\" and \"/d:lt2[k='val3']\".",
+ "/d:lt2[k='val3']");
+}
+
+static void
+test_dup(void **state)
+{
+ struct lyd_node *tree;
+ const char *schema =
"module e {\n"
" namespace urn:tests:e;\n"
" prefix e;\n"
@@ -229,7 +622,69 @@
" }\n"
" }\n"
"}";
- const char *schema_f =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+
+ CHECK_PARSE_LYD_PARAM("<d xmlns=\"urn:tests:e\">25</d><d xmlns=\"urn:tests:e\">50</d>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"d\".", "/e:d");
+
+ CHECK_PARSE_LYD_PARAM("<lt xmlns=\"urn:tests:e\"><k>A</k></lt>"
+ "<lt xmlns=\"urn:tests:e\"><k>B</k></lt>"
+ "<lt xmlns=\"urn:tests:e\"><k>A</k></lt>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"lt\".", "/e:lt[k='A']");
+
+ CHECK_PARSE_LYD_PARAM("<ll xmlns=\"urn:tests:e\">A</ll>"
+ "<ll xmlns=\"urn:tests:e\">B</ll>"
+ "<ll xmlns=\"urn:tests:e\">B</ll>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"ll\".", "/e:ll[.='B']");
+
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:e\"></cont><cont xmlns=\"urn:tests:e\"/>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"cont\".", "/e:cont");
+
+ /* same tests again but using hashes */
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:e\"><d>25</d><d>50</d><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll></cont>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"d\".", "/e:cont/d");
+
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:e\"><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll>"
+ "<lt><k>a</k></lt>"
+ "<lt><k>b</k></lt>"
+ "<lt><k>c</k></lt>"
+ "<lt><k>d</k></lt>"
+ "<lt><k>c</k></lt></cont>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"lt\".", "/e:cont/lt[k='c']");
+
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:e\"><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll>"
+ "<ll>a</ll><ll>b</ll><ll>c</ll><ll>d</ll><ll>d</ll></cont>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"ll\".", "/e:cont/ll[.='d']");
+
+ /* cases */
+ CHECK_PARSE_LYD_PARAM("<l xmlns=\"urn:tests:e\">a</l>"
+ "<l xmlns=\"urn:tests:e\">b</l>"
+ "<l xmlns=\"urn:tests:e\">c</l>"
+ "<l xmlns=\"urn:tests:e\">b</l>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Duplicate instance of \"l\".", "/e:l[.='b']");
+
+ CHECK_PARSE_LYD_PARAM("<l xmlns=\"urn:tests:e\">a</l><l xmlns=\"urn:tests:e\">b</l>"
+ "<l xmlns=\"urn:tests:e\">c</l>"
+ "<a xmlns=\"urn:tests:e\">aa</a>",
+ LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Data for both cases \"a\" and \"b\" exist.", "/e:choic");
+}
+
+static void
+test_defaults(void **state)
+{
+ struct lyd_node *tree, *node, *diff;
+ const struct lys_module *mod;
+ const char *schema =
"module f {\n"
" namespace urn:tests:f;\n"
" prefix f;\n"
@@ -294,42 +749,197 @@
" }\n"
" }\n"
"}";
- const char *schema_g =
- "module g {\n"
- " namespace urn:tests:g;\n"
- " prefix g;\n"
- " yang-version 1.1;\n"
- "\n"
- " feature f1;\n"
- " feature f2;\n"
- " feature f3;\n"
- "\n"
- " container cont {\n"
- " if-feature \"f1\";\n"
- " choice choic {\n"
- " if-feature \"f2 or f3\";\n"
- " leaf a {\n"
- " type string;\n"
- " }\n"
- " case b {\n"
- " if-feature \"f2 and f1\";\n"
- " leaf l {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " }\n"
- " leaf d {\n"
- " type uint32;\n"
- " }\n"
- " container cont2 {\n"
- " if-feature \"f2\";\n"
- " leaf e {\n"
- " type string;\n"
- " }\n"
- " }\n"
- " }\n"
- "}";
- const char *schema_h =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod);
+
+ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
+ assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-netconf-with-defaults", "2011-06-01", NULL));\
+
+ /* get defaults */
+ tree = NULL;
+ assert_int_equal(lyd_validate_module(&tree, mod, 0, &diff), LY_SUCCESS);
+ assert_non_null(tree);
+ assert_non_null(diff);
+
+ /* check all defaults exist */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ "<d xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_WITHSIBLINGS);
+
+ /* check diff */
+ CHECK_LYD_STRING_PARAM(diff,
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def1</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def2</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def3</ll1>\n"
+ "<d xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">dflt1</ll2>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">\n"
+ " <ll1 yang:operation=\"create\">def1</ll1>\n"
+ " <ll1 yang:operation=\"create\">def2</ll1>\n"
+ " <ll1 yang:operation=\"create\">def3</ll1>\n"
+ " <d yang:operation=\"create\">15</d>\n"
+ " <ll2 yang:operation=\"create\">dflt1</ll2>\n"
+ " <ll2 yang:operation=\"create\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_WITHSIBLINGS);
+ lyd_free_all(diff);
+
+ /* create another explicit case and validate */
+ assert_int_equal(lyd_new_term(NULL, mod, "l", "value", 0, &node), LY_SUCCESS);
+ assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
+
+ /* check data tree */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<l xmlns=\"urn:tests:f\">value</l>\n"
+ "<d xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_WITHSIBLINGS);
+
+ /* check diff */
+ CHECK_LYD_STRING_PARAM(diff,
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def1</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def2</ll1>\n"
+ "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def3</ll1>\n",
+ LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_WITHSIBLINGS);
+ lyd_free_all(diff);
+
+ /* create explicit leaf-list and leaf and validate */
+ assert_int_equal(lyd_new_term(NULL, mod, "d", "15", 0, &node), LY_SUCCESS);
+ assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
+ assert_int_equal(lyd_new_term(NULL, mod, "ll2", "dflt2", 0, &node), LY_SUCCESS);
+ assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
+
+ /* check data tree */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<l xmlns=\"urn:tests:f\">value</l>\n"
+ "<d xmlns=\"urn:tests:f\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_WITHSIBLINGS);
+
+ /* check diff */
+ CHECK_LYD_STRING_PARAM(diff,
+ "<d xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">dflt1</ll2>\n"
+ "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">dflt2</ll2>\n",
+ LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_WITHSIBLINGS);
+ lyd_free_all(diff);
+
+ /* create first explicit container, which should become implicit */
+ assert_int_equal(lyd_new_inner(NULL, mod, "cont", 0, &node), LY_SUCCESS);
+ assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
+
+ /* check data tree */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<l xmlns=\"urn:tests:f\">value</l>\n"
+ "<d xmlns=\"urn:tests:f\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_WITHSIBLINGS);
+ /* check diff */
+ assert_null(diff);
+
+ /* create second explicit container, which should become implicit, so the first tree node should be removed */
+ assert_int_equal(lyd_new_inner(NULL, mod, "cont", 0, &node), LY_SUCCESS);
+ assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
+
+ /* check data tree */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<l xmlns=\"urn:tests:f\">value</l>\n"
+ "<d xmlns=\"urn:tests:f\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
+ " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
+ " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
+ " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_IMPL_TAG | LYD_PRINT_WITHSIBLINGS);
+ /* check diff */
+ assert_null(diff);
+
+ /* similar changes for nested defaults */
+ assert_int_equal(lyd_new_term(tree->prev, NULL, "ll1", "def3", 0, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_term(tree->prev, NULL, "d", "5", 0, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_new_term(tree->prev, NULL, "ll2", "non-dflt", 0, NULL), LY_SUCCESS);
+ assert_int_equal(lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
+
+ /* check data tree */
+ CHECK_LYD_STRING_PARAM(tree,
+ "<l xmlns=\"urn:tests:f\">value</l>\n"
+ "<d xmlns=\"urn:tests:f\">15</d>\n"
+ "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
+ "<cont xmlns=\"urn:tests:f\">\n"
+ " <ll1>def3</ll1>\n"
+ " <d>5</d>\n"
+ " <ll2>non-dflt</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WITHSIBLINGS);
+
+ /* check diff */
+ CHECK_LYD_STRING_PARAM(diff,
+ "<cont xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
+ " <ll1 yang:operation=\"delete\">def1</ll1>\n"
+ " <ll1 yang:operation=\"delete\">def2</ll1>\n"
+ " <ll1 yang:operation=\"delete\">def3</ll1>\n"
+ " <d yang:operation=\"delete\">15</d>\n"
+ " <ll2 yang:operation=\"delete\">dflt1</ll2>\n"
+ " <ll2 yang:operation=\"delete\">dflt2</ll2>\n"
+ "</cont>\n",
+ LYD_XML, LYD_PRINT_WD_ALL | LYD_PRINT_WITHSIBLINGS);
+ lyd_free_all(diff);
+ lyd_free_all(tree);
+}
+
+static void
+test_state(void **state)
+{
+ const char *data;
+ struct lyd_node *tree;
+ const char *schema =
"module h {\n"
" namespace urn:tests:h;\n"
" prefix h;\n"
@@ -344,7 +954,28 @@
" }\n"
" }\n"
"}";
- const char *schema_i =
+
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
+
+ data = "<cont xmlns=\"urn:tests:h\">\n"
+ " <cont2>\n"
+ " <l>val</l>\n"
+ " </cont2>\n"
+ "</cont>\n";
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, LYD_PARSE_ONLY | LYD_PARSE_NO_STATE, 0, LY_EVALID, tree);
+ CHECK_LOG_CTX("Invalid state data node \"cont2\" found.", "/h:cont/cont2");
+
+ CHECK_PARSE_LYD_PARAM(data, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree);
+ assert_int_equal(LY_EVALID, lyd_validate_all(&tree, NULL, LYD_VALIDATE_PRESENT | LYD_VALIDATE_NO_STATE, NULL));
+ CHECK_LOG_CTX("Invalid state data node \"cont2\" found.", "/h:cont/cont2");
+ lyd_free_all(tree);
+}
+
+static void
+test_must(void **state)
+{
+ struct lyd_node *tree;
+ const char *schema =
"module i {\n"
" namespace urn:tests:i;\n"
" prefix i;\n"
@@ -360,940 +991,82 @@
" }\n"
" }\n"
"}";
- const char *schema_j =
- "module j {\n"
- " namespace urn:tests:j;\n"
- " prefix j;\n"
- " yang-version 1.1;\n"
- "\n"
- " feature feat1;\n"
- "\n"
- " container cont {\n"
- " must \"false()\";\n"
- " list l1 {\n"
- " key \"k\";\n"
- " leaf k {\n"
- " type string;\n"
- " }\n"
- " action act {\n"
- " if-feature feat1;\n"
- " input {\n"
- " must \"../../lf1 = 'true'\";\n"
- " leaf lf2 {\n"
- " type leafref {\n"
- " path /lf3;\n"
- " }\n"
- " }\n"
- " }\n"
- " output {\n"
- " must \"../../lf1 = 'true2'\";\n"
- " leaf lf2 {\n"
- " type leafref {\n"
- " path /lf4;\n"
- " }\n"
- " }\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " leaf lf1 {\n"
- " type string;\n"
- " }\n"
- " }\n"
- "\n"
- " leaf lf3 {\n"
- " type string;\n"
- " }\n"
- "\n"
- " leaf lf4 {\n"
- " type string;\n"
- " }\n"
- "}";
- struct ly_in *in;
- const char *feats[] = {"feat1", NULL};
-#if ENABLE_LOGGER_CHECKING
- ly_set_log_clb(logger, 1);
-#endif
+ UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
- assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_DIR_MODULES_YANG, 0, &ctx));
- assert_non_null(ly_ctx_load_module(ctx, "ietf-netconf-with-defaults", "2011-06-01", NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_a, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_b, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_c, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_d, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_e, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_f, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_g, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_h, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, schema_i, LYS_IN_YANG, NULL));
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(schema_j, &in));
- assert_int_equal(LY_SUCCESS, lys_parse(ctx, in, LYS_IN_YANG, feats, NULL));
- ly_in_free(in, 0);
-
- return 0;
-}
-
-static int
-teardown(void **state)
-{
- (void)state;
- ly_ctx_destroy(ctx, NULL);
- ctx = NULL;
-
- return 0;
-}
-
-static int
-teardown_s(void **state)
-{
-#if ENABLE_LOGGER_CHECKING
- if (*state) {
- fprintf(stderr, "%s\n", logbuf);
- }
-#else
- (void) state; /* unused */
-#endif
-
- return 0;
-}
-
-void
-logbuf_clean(void)
-{
- logbuf[0] = '\0';
-}
-
-#if ENABLE_LOGGER_CHECKING
-# define logbuf_assert(str) assert_string_equal(logbuf, str)
-#else
-# define logbuf_assert(str)
-#endif
-
-static void
-test_when(void **state)
-{
- *state = test_when;
-
- const char *data;
- struct lyd_node *tree;
-
- data = "<c xmlns=\"urn:tests:a\">hey</c>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("When condition \"/cont/b = 'val_b'\" not satisfied. /a:c");
-
- data = "<cont xmlns=\"urn:tests:a\"><b>val_b</b></cont><c xmlns=\"urn:tests:a\">hey</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_string_equal("c", tree->next->schema->name);
- assert_int_equal(LYD_WHEN_TRUE, tree->next->flags);
- lyd_free_all(tree);
-
- data = "<cont xmlns=\"urn:tests:a\"><a>val</a><b>val_b</b></cont><c xmlns=\"urn:tests:a\">val_c</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- assert_string_equal("a", lyd_child(tree)->schema->name);
- assert_int_equal(LYD_WHEN_TRUE, lyd_child(tree)->flags);
- assert_string_equal("c", tree->next->schema->name);
- assert_int_equal(LYD_WHEN_TRUE, tree->next->flags);
- lyd_free_all(tree);
-
- *state = NULL;
-}
-
-static void
-test_mandatory(void **state)
-{
- *state = test_mandatory;
-
- const char *data;
- struct lyd_node *tree;
-
- data = "<d xmlns=\"urn:tests:b\"/>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Mandatory node \"choic\" instance does not exist. /b:choic");
-
- data = "<l xmlns=\"urn:tests:b\">string</l><d xmlns=\"urn:tests:b\"/>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Mandatory node \"c\" instance does not exist. /b:c");
-
- data = "<a xmlns=\"urn:tests:b\">string</a>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Mandatory node \"c\" instance does not exist. /b:c");
-
- data = "<a xmlns=\"urn:tests:b\">string</a><c xmlns=\"urn:tests:b\">string2</c>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- *state = NULL;
-}
-
-static void
-test_minmax(void **state)
-{
- *state = test_minmax;
-
- const char *data;
- struct lyd_node *tree;
-
- data = "<d xmlns=\"urn:tests:c\"/>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Too few \"l\" instances. /c:choic/b/l");
-
- data =
- "<l xmlns=\"urn:tests:c\">val1</l>"
- "<l xmlns=\"urn:tests:c\">val2</l>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Too few \"l\" instances. /c:choic/b/l");
-
- data =
- "<l xmlns=\"urn:tests:c\">val1</l>"
- "<l xmlns=\"urn:tests:c\">val2</l>"
- "<l xmlns=\"urn:tests:c\">val3</l>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<l xmlns=\"urn:tests:c\">val1</l>"
- "<l xmlns=\"urn:tests:c\">val2</l>"
- "<l xmlns=\"urn:tests:c\">val3</l>"
- "<lt xmlns=\"urn:tests:c\"><k>val1</k></lt>"
- "<lt xmlns=\"urn:tests:c\"><k>val2</k></lt>"
- "<lt xmlns=\"urn:tests:c\"><k>val3</k></lt>"
- "<lt xmlns=\"urn:tests:c\"><k>val4</k></lt>"
- "<lt xmlns=\"urn:tests:c\"><k>val5</k></lt>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Too many \"lt\" instances. /c:lt");
-
- *state = NULL;
-}
-
-static void
-test_unique(void **state)
-{
- *state = test_unique;
-
- const char *data;
- struct lyd_node *tree;
-
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>same</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- "</lt>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>same</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <l1>not-same</l1>\n"
- "</lt>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>same</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <l1>same</l1>\n"
- "</lt>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Unique data leaf(s) \"l1\" not satisfied in \"/d:lt[k='val1']\" and \"/d:lt[k='val2']\". /d:lt[k='val2']");
-
- /* now try with more instances */
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>1</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <l1>2</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <l1>3</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <l1>4</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <l1>5</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val6</k>\n"
- " <l1>6</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val7</k>\n"
- " <l1>7</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val8</k>\n"
- " <l1>8</l1>\n"
- "</lt>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>1</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <l1>2</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <l1>3</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <l1>5</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val6</k>\n"
- " <l1>6</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val7</k>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val8</k>\n"
- "</lt>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <l1>1</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <l1>2</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <l1>4</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val6</k>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val7</k>\n"
- " <l1>2</l1>\n"
- "</lt>\n"
- "<lt xmlns=\"urn:tests:d\">\n"
- " <k>val8</k>\n"
- " <l1>8</l1>\n"
- "</lt>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Unique data leaf(s) \"l1\" not satisfied in \"/d:lt[k='val7']\" and \"/d:lt[k='val2']\". /d:lt[k='val2']");
-
- *state = NULL;
-}
-
-static void
-test_unique_nested(void **state)
-{
- *state = test_unique_nested;
-
- const char *data;
- struct lyd_node *tree;
-
- /* nested list uniquest are compared only with instances in the same parent list instance */
- data =
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <cont>\n"
- " <l2>1</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <cont>\n"
- " <l2>2</l2>\n"
- " </cont>\n"
- " <l4>2</l4>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>1</l3>\n"
- " </lt3>\n"
- " <lt3>\n"
- " <kk>val2</kk>\n"
- " <l3>2</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <cont>\n"
- " <l2>3</l2>\n"
- " </cont>\n"
- " <l4>3</l4>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>2</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <cont>\n"
- " <l2>4</l2>\n"
- " </cont>\n"
- " <l4>4</l4>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>3</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <cont>\n"
- " <l2>5</l2>\n"
- " </cont>\n"
- " <l4>5</l4>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>3</l3>\n"
- " </lt3>\n"
- "</lt2>";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_siblings(tree);
-
- data =
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <cont>\n"
- " <l2>1</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <cont>\n"
- " <l2>2</l2>\n"
- " </cont>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>1</l3>\n"
- " </lt3>\n"
- " <lt3>\n"
- " <kk>val2</kk>\n"
- " <l3>2</l3>\n"
- " </lt3>\n"
- " <lt3>\n"
- " <kk>val3</kk>\n"
- " <l3>1</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <cont>\n"
- " <l2>3</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>2</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <cont>\n"
- " <l2>4</l2>\n"
- " </cont>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>3</l3>\n"
- " </lt3>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <cont>\n"
- " <l2>5</l2>\n"
- " </cont>\n"
- " <lt3>\n"
- " <kk>val1</kk>\n"
- " <l3>3</l3>\n"
- " </lt3>\n"
- "</lt2>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Unique data leaf(s) \"l3\" not satisfied in \"/d:lt2[k='val2']/lt3[kk='val3']\" and"
- " \"/d:lt2[k='val2']/lt3[kk='val1']\". /d:lt2[k='val2']/lt3[kk='val1']");
-
- data =
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <cont>\n"
- " <l2>1</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <cont>\n"
- " <l2>2</l2>\n"
- " </cont>\n"
- " <l4>2</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <cont>\n"
- " <l2>3</l2>\n"
- " </cont>\n"
- " <l4>3</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <cont>\n"
- " <l2>2</l2>\n"
- " </cont>\n"
- " <l4>2</l4>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <cont>\n"
- " <l2>5</l2>\n"
- " </cont>\n"
- " <l4>5</l4>\n"
- "</lt2>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Unique data leaf(s) \"cont/l2 l4\" not satisfied in \"/d:lt2[k='val4']\" and \"/d:lt2[k='val2']\". /d:lt2[k='val2']");
-
- data =
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val1</k>\n"
- " <cont>\n"
- " <l2>1</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <l5>1</l5>\n"
- " <l6>1</l6>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val2</k>\n"
- " <cont>\n"
- " <l2>2</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <l5>1</l5>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val3</k>\n"
- " <cont>\n"
- " <l2>3</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <l5>3</l5>\n"
- " <l6>3</l6>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val4</k>\n"
- " <cont>\n"
- " <l2>4</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <l6>1</l6>\n"
- "</lt2>\n"
- "<lt2 xmlns=\"urn:tests:d\">\n"
- " <k>val5</k>\n"
- " <cont>\n"
- " <l2>5</l2>\n"
- " </cont>\n"
- " <l4>1</l4>\n"
- " <l5>3</l5>\n"
- " <l6>3</l6>\n"
- "</lt2>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Unique data leaf(s) \"l5 l6\" not satisfied in \"/d:lt2[k='val5']\" and \"/d:lt2[k='val3']\". /d:lt2[k='val3']");
-
- *state = NULL;
-}
-
-static void
-test_dup(void **state)
-{
- *state = test_dup;
-
- const char *data;
- struct lyd_node *tree;
-
- data = "<d xmlns=\"urn:tests:e\">25</d><d xmlns=\"urn:tests:e\">50</d>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"d\". /e:d");
-
- data = "<lt xmlns=\"urn:tests:e\"><k>A</k></lt><lt xmlns=\"urn:tests:e\"><k>B</k></lt><lt xmlns=\"urn:tests:e\"><k>A</k></lt>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"lt\". /e:lt[k='A']");
-
- data = "<ll xmlns=\"urn:tests:e\">A</ll><ll xmlns=\"urn:tests:e\">B</ll><ll xmlns=\"urn:tests:e\">B</ll>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"ll\". /e:ll[.='B']");
-
- data = "<cont xmlns=\"urn:tests:e\"></cont><cont xmlns=\"urn:tests:e\"/>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"cont\". /e:cont");
-
- /* same tests again but using hashes */
- data = "<cont xmlns=\"urn:tests:e\"><d>25</d><d>50</d><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll></cont>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"d\". /e:cont/d");
-
- data = "<cont xmlns=\"urn:tests:e\"><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll>"
- "<lt><k>a</k></lt><lt><k>b</k></lt><lt><k>c</k></lt><lt><k>d</k></lt><lt><k>c</k></lt></cont>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"lt\". /e:cont/lt[k='c']");
-
- data = "<cont xmlns=\"urn:tests:e\"><ll>1</ll><ll>2</ll><ll>3</ll><ll>4</ll>"
- "<ll>a</ll><ll>b</ll><ll>c</ll><ll>d</ll><ll>d</ll></cont>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"ll\". /e:cont/ll[.='d']");
-
- /* cases */
- data = "<l xmlns=\"urn:tests:e\">a</l><l xmlns=\"urn:tests:e\">b</l><l xmlns=\"urn:tests:e\">c</l><l xmlns=\"urn:tests:e\">b</l>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Duplicate instance of \"l\". /e:l[.='b']");
-
- data = "<l xmlns=\"urn:tests:e\">a</l><l xmlns=\"urn:tests:e\">b</l><l xmlns=\"urn:tests:e\">c</l><a xmlns=\"urn:tests:e\">aa</a>";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Data for both cases \"a\" and \"b\" exist. /e:choic");
-
- *state = NULL;
-}
-
-static void
-test_defaults(void **state)
-{
- *state = test_defaults;
-
- char *str;
- struct lyd_node *tree, *node, *diff;
- const struct lys_module *mod = ly_ctx_get_module_latest(ctx, "f");
-
- struct ly_out *out;
-
- assert_int_equal(LY_SUCCESS, ly_out_new_memory(&str, 0, &out));
-
- /* get defaults */
- tree = NULL;
- assert_int_equal(lyd_validate_module(&tree, mod, 0, &diff), LY_SUCCESS);
- assert_non_null(tree);
- assert_non_null(diff);
-
- /* check all defaults exist */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- "<d xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- lyd_print_all(out, diff, LYD_XML, LYD_PRINT_WD_ALL);
- assert_string_equal(str,
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def1</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def2</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">def3</ll1>\n"
- "<d xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">dflt1</ll2>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"create\">\n"
- " <ll1 yang:operation=\"create\">def1</ll1>\n"
- " <ll1 yang:operation=\"create\">def2</ll1>\n"
- " <ll1 yang:operation=\"create\">def3</ll1>\n"
- " <d yang:operation=\"create\">15</d>\n"
- " <ll2 yang:operation=\"create\">dflt1</ll2>\n"
- " <ll2 yang:operation=\"create\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
- lyd_free_siblings(diff);
-
- /* create another explicit case and validate */
- assert_int_equal(lyd_new_term(NULL, mod, "l", "value", 0, &node), LY_SUCCESS);
- assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&tree, ctx, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
-
- /* check data tree */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<l xmlns=\"urn:tests:f\">value</l>\n"
- "<d xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- lyd_print_all(out, diff, LYD_XML, LYD_PRINT_WD_ALL);
- assert_string_equal(str,
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def1</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def2</ll1>\n"
- "<ll1 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">def3</ll1>\n");
- ly_out_reset(out);
- lyd_free_siblings(diff);
-
- /* create explicit leaf-list and leaf and validate */
- assert_int_equal(lyd_new_term(NULL, mod, "d", "15", 0, &node), LY_SUCCESS);
- assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
- assert_int_equal(lyd_new_term(NULL, mod, "ll2", "dflt2", 0, &node), LY_SUCCESS);
- assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&tree, ctx, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
-
- /* check data tree */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<l xmlns=\"urn:tests:f\">value</l>\n"
- "<d xmlns=\"urn:tests:f\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- lyd_print_all(out, diff, LYD_XML, LYD_PRINT_WD_ALL);
- assert_string_equal(str,
- "<d xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">dflt1</ll2>\n"
- "<ll2 xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"delete\">dflt2</ll2>\n");
- ly_out_reset(out);
- lyd_free_siblings(diff);
-
- /* create first explicit container, which should become implicit */
- assert_int_equal(lyd_new_inner(NULL, mod, "cont", 0, &node), LY_SUCCESS);
- assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&tree, ctx, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
-
- /* check data tree */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<l xmlns=\"urn:tests:f\">value</l>\n"
- "<d xmlns=\"urn:tests:f\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- assert_null(diff);
-
- /* create second explicit container, which should become implicit, so the first tree node should be removed */
- assert_int_equal(lyd_new_inner(NULL, mod, "cont", 0, &node), LY_SUCCESS);
- assert_int_equal(lyd_insert_sibling(tree, node, &tree), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&tree, ctx, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
-
- /* check data tree */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<l xmlns=\"urn:tests:f\">value</l>\n"
- "<d xmlns=\"urn:tests:f\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def1</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def2</ll1>\n"
- " <ll1 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">def3</ll1>\n"
- " <d xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">15</d>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt1</ll2>\n"
- " <ll2 xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\" ncwd:default=\"true\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- assert_null(diff);
-
- /* similar changes for nested defaults */
- assert_int_equal(lyd_new_term(tree->prev, NULL, "ll1", "def3", 0, NULL), LY_SUCCESS);
- assert_int_equal(lyd_new_term(tree->prev, NULL, "d", "5", 0, NULL), LY_SUCCESS);
- assert_int_equal(lyd_new_term(tree->prev, NULL, "ll2", "non-dflt", 0, NULL), LY_SUCCESS);
- assert_int_equal(lyd_validate_all(&tree, ctx, LYD_VALIDATE_PRESENT, &diff), LY_SUCCESS);
-
- /* check data tree */
- lyd_print_all(out, tree, LYD_XML, LYD_PRINT_WD_IMPL_TAG);
- assert_string_equal(str,
- "<l xmlns=\"urn:tests:f\">value</l>\n"
- "<d xmlns=\"urn:tests:f\">15</d>\n"
- "<ll2 xmlns=\"urn:tests:f\">dflt2</ll2>\n"
- "<cont xmlns=\"urn:tests:f\">\n"
- " <ll1>def3</ll1>\n"
- " <d>5</d>\n"
- " <ll2>non-dflt</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
-
- /* check diff */
- lyd_print_all(out, diff, LYD_XML, LYD_PRINT_WD_ALL);
- assert_string_equal(str,
- "<cont xmlns=\"urn:tests:f\" xmlns:yang=\"urn:ietf:params:xml:ns:yang:1\" yang:operation=\"none\">\n"
- " <ll1 yang:operation=\"delete\">def1</ll1>\n"
- " <ll1 yang:operation=\"delete\">def2</ll1>\n"
- " <ll1 yang:operation=\"delete\">def3</ll1>\n"
- " <d yang:operation=\"delete\">15</d>\n"
- " <ll2 yang:operation=\"delete\">dflt1</ll2>\n"
- " <ll2 yang:operation=\"delete\">dflt2</ll2>\n"
- "</cont>\n");
- ly_out_reset(out);
- lyd_free_siblings(diff);
-
- lyd_free_siblings(tree);
- ly_out_free(out, NULL, 1);
-
- *state = NULL;
-}
-
-static void
-test_state(void **state)
-{
- *state = test_state;
-
- const char *data;
- struct lyd_node *tree;
-
- data =
- "<cont xmlns=\"urn:tests:h\">\n"
- " <cont2>\n"
- " <l>val</l>\n"
- " </cont2>\n"
- "</cont>\n";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY | LYD_PARSE_NO_STATE, 0, &tree));
- assert_null(tree);
- logbuf_assert("Invalid state data node \"cont2\" found. /h:cont/cont2");
-
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT | LYD_VALIDATE_NO_STATE, &tree));
- assert_null(tree);
- logbuf_assert("Invalid state data node \"cont2\" found. /h:cont/cont2");
-
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
-
- assert_int_equal(LY_EVALID, lyd_validate_all(&tree, NULL, LYD_VALIDATE_PRESENT | LYD_VALIDATE_NO_STATE, NULL));
- logbuf_assert("Invalid state data node \"cont2\" found. /h:cont/cont2");
-
- lyd_free_siblings(tree);
-
- *state = NULL;
-}
-
-static void
-test_must(void **state)
-{
- *state = test_must;
-
- const char *data;
- struct lyd_node *tree;
-
- data =
- "<cont xmlns=\"urn:tests:i\">\n"
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:i\">\n"
" <l>wrong</l>\n"
" <l2>val</l2>\n"
- "</cont>\n";
- assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_null(tree);
- logbuf_assert("Must condition \"../l = 'right'\" not satisfied. /i:cont/l2");
+ "</cont>\n", LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
+ CHECK_LOG_CTX("Must condition \"../l = 'right'\" not satisfied.", "/i:cont/l2");
- data =
- "<cont xmlns=\"urn:tests:i\">\n"
+ LYD_TREE_CREATE("<cont xmlns=\"urn:tests:i\">\n"
" <l>right</l>\n"
" <l2>val</l2>\n"
- "</cont>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
- assert_non_null(tree);
- lyd_free_tree(tree);
-
- *state = NULL;
+ "</cont>\n", tree);
+ lyd_free_all(tree);
}
+const char *schema_j =
+ "module j {\n"
+ " namespace urn:tests:j;\n"
+ " prefix j;\n"
+ " yang-version 1.1;\n"
+ "\n"
+ " feature feat1;\n"
+ "\n"
+ " container cont {\n"
+ " must \"false()\";\n"
+ " list l1 {\n"
+ " key \"k\";\n"
+ " leaf k {\n"
+ " type string;\n"
+ " }\n"
+ " action act {\n"
+ " if-feature feat1;\n"
+ " input {\n"
+ " must \"../../lf1 = 'true'\";\n"
+ " leaf lf2 {\n"
+ " type leafref {\n"
+ " path /lf3;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " output {\n"
+ " must \"../../lf1 = 'true2'\";\n"
+ " leaf lf2 {\n"
+ " type leafref {\n"
+ " path /lf4;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " leaf lf1 {\n"
+ " type string;\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " leaf lf3 {\n"
+ " type string;\n"
+ " }\n"
+ "\n"
+ " leaf lf4 {\n"
+ " type string;\n"
+ " }\n"
+ "}";
+const char *feats_j[] = {"feat1", NULL};
+
static void
test_action(void **state)
{
- *state = test_action;
-
- const char *data;
struct ly_in *in;
struct lyd_node *tree, *op_tree;
- data =
+ UTEST_ADD_MODULE(schema_j, LYS_IN_YANG, feats_j, NULL);
+
+ assert_int_equal(LY_SUCCESS, ly_in_new_memory(
"<cont xmlns=\"urn:tests:j\">\n"
" <l1>\n"
" <k>val1</k>\n"
@@ -1301,57 +1074,48 @@
" <lf2>target</lf2>\n"
" </act>\n"
" </l1>\n"
- "</cont>\n";
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_XML, &op_tree, NULL));
+ "</cont>\n", &in));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_XML, &op_tree, NULL));
assert_non_null(op_tree);
/* missing leafref */
assert_int_equal(LY_EVALID, lyd_validate_op(op_tree, NULL, LYD_VALIDATE_OP_RPC, NULL));
- logbuf_assert("Invalid leafref value \"target\" - no target instance \"/lf3\" with the same value."
- " /j:cont/l1[k='val1']/act/lf2");
+ CHECK_LOG_CTX("Invalid leafref value \"target\" - no target instance \"/lf3\" with the same value.", "/j:cont/l1[k='val1']/act/lf2");
ly_in_free(in, 0);
- data =
- "<cont xmlns=\"urn:tests:j\">\n"
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:j\">\n"
" <lf1>not true</lf1>\n"
"</cont>\n"
- "<lf3 xmlns=\"urn:tests:j\">target</lf3>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
+ "<lf3 xmlns=\"urn:tests:j\">target</lf3>\n",
+ LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree);
/* input must false */
assert_int_equal(LY_EVALID, lyd_validate_op(op_tree, tree, LYD_VALIDATE_OP_RPC, NULL));
- logbuf_assert("Must condition \"../../lf1 = 'true'\" not satisfied. /j:cont/l1[k='val1']/act");
+ CHECK_LOG_CTX("Must condition \"../../lf1 = 'true'\" not satisfied.", "/j:cont/l1[k='val1']/act");
- lyd_free_siblings(tree);
- data =
- "<cont xmlns=\"urn:tests:j\">\n"
+ lyd_free_all(tree);
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:j\">\n"
" <lf1>true</lf1>\n"
"</cont>\n"
- "<lf3 xmlns=\"urn:tests:j\">target</lf3>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
+ "<lf3 xmlns=\"urn:tests:j\">target</lf3>\n",
+ LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree);
/* success */
assert_int_equal(LY_SUCCESS, lyd_validate_op(op_tree, tree, LYD_VALIDATE_OP_RPC, NULL));
lyd_free_tree(op_tree);
lyd_free_siblings(tree);
-
- *state = NULL;
}
static void
test_reply(void **state)
{
- *state = test_reply;
-
- const char *data;
struct ly_in *in;
struct lyd_node *tree, *op_tree, *request;
- data =
+ UTEST_ADD_MODULE(schema_j, LYS_IN_YANG, feats_j, NULL);
+
+ assert_int_equal(LY_SUCCESS, ly_in_new_memory(
"<cont xmlns=\"urn:tests:j\">\n"
" <l1>\n"
" <k>val1</k>\n"
@@ -1359,14 +1123,12 @@
" <lf2>target</lf2>\n"
" </act>\n"
" </l1>\n"
- "</cont>\n";
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
- assert_int_equal(LY_SUCCESS, lyd_parse_rpc(ctx, in, LYD_XML, &request, NULL));
+ "</cont>\n", &in));
+ assert_int_equal(LY_SUCCESS, lyd_parse_rpc(UTEST_LYCTX, in, LYD_XML, &request, NULL));
assert_non_null(request);
ly_in_free(in, 0);
- data = "<lf2 xmlns=\"urn:tests:j\">target</lf2>";
- assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
+ assert_int_equal(LY_SUCCESS, ly_in_new_memory("<lf2 xmlns=\"urn:tests:j\">target</lf2>", &in));
assert_int_equal(LY_SUCCESS, lyd_parse_reply(request, in, LYD_XML, &op_tree, NULL));
lyd_free_all(request);
assert_non_null(op_tree);
@@ -1374,55 +1136,48 @@
/* missing leafref */
assert_int_equal(LY_EVALID, lyd_validate_op(op_tree, NULL, LYD_VALIDATE_OP_REPLY, NULL));
- logbuf_assert("Invalid leafref value \"target\" - no target instance \"/lf4\" with the same value."
- " /j:cont/l1[k='val1']/act/lf2");
+ CHECK_LOG_CTX("Invalid leafref value \"target\" - no target instance \"/lf4\" with the same value.", "/j:cont/l1[k='val1']/act/lf2");
- data =
- "<cont xmlns=\"urn:tests:j\">\n"
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:j\">\n"
" <lf1>not true</lf1>\n"
"</cont>\n"
- "<lf4 xmlns=\"urn:tests:j\">target</lf4>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
+ "<lf4 xmlns=\"urn:tests:j\">target</lf4>\n",
+ LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree);
/* input must false */
assert_int_equal(LY_EVALID, lyd_validate_op(op_tree, tree, LYD_VALIDATE_OP_REPLY, NULL));
- logbuf_assert("Must condition \"../../lf1 = 'true2'\" not satisfied. /j:cont/l1[k='val1']/act");
+ CHECK_LOG_CTX("Must condition \"../../lf1 = 'true2'\" not satisfied.", "/j:cont/l1[k='val1']/act");
- lyd_free_siblings(tree);
- data =
- "<cont xmlns=\"urn:tests:j\">\n"
+ lyd_free_all(tree);
+ CHECK_PARSE_LYD_PARAM("<cont xmlns=\"urn:tests:j\">\n"
" <lf1>true2</lf1>\n"
"</cont>\n"
- "<lf4 xmlns=\"urn:tests:j\">target</lf4>\n";
- assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, data, LYD_XML, LYD_PARSE_ONLY, 0, &tree));
- assert_non_null(tree);
+ "<lf4 xmlns=\"urn:tests:j\">target</lf4>\n",
+ LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree);
/* success */
assert_int_equal(LY_SUCCESS, lyd_validate_op(op_tree, tree, LYD_VALIDATE_OP_REPLY, NULL));
lyd_free_tree(op_tree);
- lyd_free_siblings(tree);
-
- *state = NULL;
+ lyd_free_all(tree);
}
int
main(void)
{
const struct CMUnitTest tests[] = {
- cmocka_unit_test_teardown(test_when, teardown_s),
- cmocka_unit_test_teardown(test_mandatory, teardown_s),
- cmocka_unit_test_teardown(test_minmax, teardown_s),
- cmocka_unit_test_teardown(test_unique, teardown_s),
- cmocka_unit_test_teardown(test_unique_nested, teardown_s),
- cmocka_unit_test_teardown(test_dup, teardown_s),
- cmocka_unit_test_teardown(test_defaults, teardown_s),
- cmocka_unit_test_teardown(test_state, teardown_s),
- cmocka_unit_test_teardown(test_must, teardown_s),
- cmocka_unit_test_teardown(test_action, teardown_s),
- cmocka_unit_test_teardown(test_reply, teardown_s),
+ UTEST(test_when),
+ UTEST(test_mandatory),
+ UTEST(test_minmax),
+ UTEST(test_unique),
+ UTEST(test_unique_nested),
+ UTEST(test_dup),
+ UTEST(test_defaults),
+ UTEST(test_state),
+ UTEST(test_must),
+ UTEST(test_action),
+ UTEST(test_reply),
};
- return cmocka_run_group_tests(tests, setup, teardown);
+ return cmocka_run_group_tests(tests, NULL, NULL);
}