| /* |
| * @file test_parser_xml.c |
| * @author: Radek Krejci <rkrejci@cesnet.cz> |
| * @brief unit tests for functions from parser_xml.c |
| * |
| * Copyright (c) 2019 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. |
| * You may obtain a copy of the License at |
| * |
| * https://opensource.org/licenses/BSD-3-Clause |
| */ |
| |
| #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 = |
| "module a {\n" |
| " namespace urn:tests:a;\n" |
| " prefix a;\n" |
| " yang-version 1.1;\n" |
| " list l1 {\n" |
| " key \"a b c\";\n" |
| " leaf a {type string;}\n" |
| " leaf b {type string;}\n" |
| " leaf c {type int16;}\n" |
| " leaf d {type string;}}\n" |
| " leaf foo { type string;}\n" |
| " container c {\n" |
| " leaf x {type string;}\n" |
| " action act { input { leaf al {type string;} } output { leaf al {type uint8;} } }\n" |
| " notification n1 { leaf nl {type string;}}}\n" |
| " container cp {presence \"container switch\"; leaf y {type string;} leaf z {type int8;}}\n" |
| " anydata any {config false;}\n" |
| " 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 |
| |
| 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)); |
| |
| 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 |
| |
| 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_int_equal(LYS_LEAF, tree->next->next->schema->nodetype); |
| assert_string_equal("foo2", tree->next->next->schema->name); |
| leaf = (struct lyd_node_term *)tree->next->next; |
| assert_string_equal("default-val", leaf->value.canonical); |
| 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)); |
| assert_non_null(tree); |
| tree = tree->next; |
| assert_int_equal(LYS_LEAF, tree->schema->nodetype); |
| assert_string_equal("foo2", tree->schema->name); |
| leaf = (struct lyd_node_term *)tree; |
| assert_string_equal("default-val", leaf->value.canonical); |
| 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)); |
| assert_non_null(tree); |
| tree = tree->next; |
| assert_int_equal(LYS_LEAF, tree->schema->nodetype); |
| assert_string_equal("foo2", tree->schema->name); |
| leaf = (struct lyd_node_term *)tree; |
| assert_string_equal("default-val", leaf->value.canonical); |
| 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" |
| " <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)); |
| 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, |
| "<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); |
| |
| 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>"; |
| 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); |
| list = (struct lyd_node_inner *)tree; |
| LY_LIST_FOR(list->child, iter) { |
| assert_int_not_equal(0, iter->hash); |
| } |
| 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']"); |
| |
| 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']"); |
| |
| 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']"); |
| |
| /* 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"); |
| |
| /* 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); |
| list = (struct lyd_node_inner *)tree; |
| assert_non_null(leaf = (struct lyd_node_term *)list->child); |
| assert_string_equal("a", leaf->schema->name); |
| assert_non_null(leaf = (struct lyd_node_term *)leaf->next); |
| assert_string_equal("b", leaf->schema->name); |
| assert_non_null(leaf = (struct lyd_node_term *)leaf->next); |
| assert_string_equal("c", leaf->schema->name); |
| 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."); |
| 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); |
| list = (struct lyd_node_inner *)tree; |
| assert_non_null(leaf = (struct lyd_node_term *)list->child); |
| assert_string_equal("a", leaf->schema->name); |
| assert_non_null(leaf = (struct lyd_node_term *)leaf->next); |
| assert_string_equal("b", leaf->schema->name); |
| 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(); |
| 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; |
| } |
| |
| 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); |
| 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)); |
| assert_non_null(tree); |
| tree = tree->next; |
| assert_int_equal(LYS_CONTAINER, tree->schema->nodetype); |
| assert_string_equal("cp", tree->schema->name); |
| 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); |
| |
| /* 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); |
| 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); |
| |
| /* 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); |
| 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); |
| |
| /* 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); |
| 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; |
| } |
| |
| 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; |
| |
| 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" |
| " <edit-config>\n" |
| " <target>\n" |
| " <running/>\n" |
| " </target>\n" |
| " <config xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n" |
| " <l1 xmlns=\"urn:tests:a\" nc:operation=\"replace\">\n" |
| " <a>val_a</a>\n" |
| " <b>val_b</b>\n" |
| " <c>val_c</c>\n" |
| " </l1>\n" |
| " <cp xmlns=\"urn:tests:a\">\n" |
| " <z nc:operation=\"delete\"/>\n" |
| " </cp>\n" |
| " </config>\n" |
| " </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)); |
| 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"); |
| assert_non_null(((struct lyd_node_opaq *)tree)->attr); |
| node = lyd_child(tree); |
| assert_string_equal(node->schema->name, "edit-config"); |
| node = lyd_child(node)->next; |
| assert_string_equal(node->schema->name, "config"); |
| |
| node = ((struct lyd_node_any *)node)->value.tree; |
| assert_non_null(node->schema); |
| assert_string_equal(node->schema->name, "cp"); |
| node = lyd_child(node); |
| /* z has no value */ |
| assert_null(node->schema); |
| assert_string_equal(((struct lyd_node_opaq *)node)->name.name, "z"); |
| 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"); |
| |
| lyd_print_tree(out, tree, LYD_XML, 0); |
| assert_string_equal(str, |
| "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\" custom-attr=\"val\">\n" |
| " <edit-config>\n" |
| " <target>\n" |
| " <running/>\n" |
| " </target>\n" |
| " <config>\n" |
| " <cp xmlns=\"urn:tests:a\">\n" |
| " <z xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\" nc:operation=\"delete\"/>\n" |
| " </cp>\n" |
| " <l1 xmlns=\"urn:tests:a\" xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\" nc:operation=\"replace\">\n" |
| " <a>val_a</a>\n" |
| " <b>val_b</b>\n" |
| " <c>val_c</c>\n" |
| " </l1>\n" |
| " </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" |
| " <action xmlns=\"urn:ietf:params:xml:ns:yang:1\">\n" |
| " <c xmlns=\"urn:tests:a\">\n" |
| " <act>\n" |
| " <al>value</al>\n" |
| " </act>\n" |
| " </c>\n" |
| " </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)); |
| ly_in_free(in, 0); |
| |
| assert_non_null(op); |
| assert_string_equal(op->schema->name, "act"); |
| |
| 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); |
| 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, |
| "<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" |
| " <al>value</al>\n" |
| " </act>\n" |
| " </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" |
| " <eventTime>2037-07-08T00:01:00Z</eventTime>\n" |
| " <c xmlns=\"urn:tests:a\">\n" |
| " <n1>\n" |
| " <nl>value</nl>\n" |
| " </n1>\n" |
| " </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)); |
| ly_in_free(in, 0); |
| |
| assert_non_null(ntf); |
| assert_string_equal(ntf->schema->name, "n1"); |
| |
| 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); |
| 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); |
| node = node->next; |
| assert_non_null(node->schema); |
| assert_string_equal(node->schema->name, "c"); |
| |
| lyd_print_tree(out, tree, LYD_XML, 0); |
| assert_string_equal(str, data); |
| ly_out_reset(out); |
| lyd_free_all(tree); |
| |
| /* top-level notif without envelope */ |
| data = "<n2 xmlns=\"urn:tests:a\"/>"; |
| 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)); |
| ly_in_free(in, 0); |
| |
| assert_non_null(ntf); |
| assert_string_equal(ntf->schema->name, "n2"); |
| |
| 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); |
| 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" |
| " <al>value</al>\n" |
| " </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)); |
| ly_in_free(in, 0); |
| |
| data = |
| "<rpc-reply xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" msgid=\"25\">\n" |
| " <al xmlns=\"urn:tests:a\">25</al>\n" |
| "</rpc-reply>\n"; |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in)); |
| assert_int_equal(LY_SUCCESS, lyd_parse_reply(request, in, LYD_XML, &tree, &op)); |
| ly_in_free(in, 0); |
| lyd_free_all(request); |
| |
| assert_non_null(op); |
| assert_string_equal(op->schema->name, "act"); |
| node = lyd_child(op); |
| assert_non_null(node->schema); |
| assert_string_equal(node->schema->name, "al"); |
| 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); |
| node = lyd_child(tree); |
| assert_non_null(node->schema); |
| assert_string_equal(node->schema->name, "c"); |
| |
| /* 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); |
| 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), |
| }; |
| |
| return cmocka_run_group_tests(tests, NULL, NULL); |
| } |