tests/utests/data/test_parser_xml.c

/*
 * @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);
}