/**
* @file test_state_lists.c
* @author Michal Vasko <mvasko@cesnet.cz>
* @brief Cmoka tests for handling state leaf-lists and lists.
*
* Copyright (c) 2018 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 <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <cmocka.h>
#include <assert.h>
#include "libyang.h"
#include "tree_internal.h"
#include "tests/config.h"
#include "hash_table.h"
struct state {
struct ly_ctx *ctx;
struct lyd_node *root1, *root2;
};
const char *schemafile = TESTS_DIR"/data/files/state-lists.yang";
const char *datafile = TESTS_DIR"/data/files/state-lists1.xml";
#ifdef LY_ENABLED_CACHE
static void
lyd_hash_check(struct lyd_node *node)
{
struct lyd_node *iter;
uint32_t orig_hash, i;
if (!node) {
return;
}
orig_hash = node->hash;
node->hash = 0;
lyd_hash(node);
assert(node->hash == orig_hash);
if (node->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF | LYS_INPUT | LYS_OUTPUT)) {
for (i = 0, iter = node->child; iter; ++i, iter = iter->next) {
if ((iter->schema->nodetype == LYS_LIST) && !lyd_list_has_keys(iter)) {
--i;
}
}
if (i >= LY_CACHE_HT_MIN_CHILDREN) {
assert(node->ht && (node->ht->used == i));
LY_TREE_FOR(node->child, iter) {
if ((iter->schema->nodetype != LYS_LIST) || lyd_list_has_keys(iter)) {
assert(!lyht_find(node->ht, &iter, iter->hash, NULL));
}
}
} else {
assert(!node->ht);
}
LY_TREE_FOR(node->child, iter) {
lyd_hash_check(iter);
}
}
if ((node->schema->nodetype != LYS_LIST) || lyd_list_has_keys(node)) {
assert(node->hash);
} else {
assert(!node->hash);
}
}
static void
test_hash(void **state)
{
struct lyd_node *root, *node;
struct state *st = (*state);
root = lyd_new_path(NULL, st->ctx, "/state-lists:cont/l/leaf1", "cc", 0, 0);
assert_non_null(root);
lyd_hash_check(root);
node = lyd_new_path(root, NULL, "/state-lists:cont/l[1]/lcont/l2/leaf4", "cc", 0, 0);
assert_non_null(root);
assert_string_equal(node->schema->name, "lcont");
lyd_hash_check(root);
assert_int_equal(lyd_insert(st->root1, root->child), 0);
lyd_free(root);
lyd_hash_check(st->root1);
lyd_free(st->root1->child->next->next->next);
lyd_hash_check(st->root1);
lyd_free(st->root1->child->child->next->next->child->next->child);
lyd_hash_check(st->root1);
lyd_free(st->root1->child->child->next);
lyd_hash_check(st->root1);
}
#endif
static int
setup_f(void **state)
{
struct state *st;
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(NULL, 0);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
return -1;
}
/* schema */
if (!lys_parse_path(st->ctx, schemafile, LYS_IN_YANG)) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schemafile);
return -1;
}
/* data */
st->root1 = lyd_parse_path(st->ctx, datafile, LYD_XML, LYD_OPT_GET);
st->root2 = lyd_dup(st->root1, 1);
if (!st->root1 || !st->root2) {
fprintf(stderr, "Failed to load initial data file.\n");
return -1;
}
return 0;
}
static int
teardown_f(void **state)
{
struct state *st = (*state);
#ifdef LY_ENABLED_CACHE
lyd_hash_check(st->root1);
lyd_hash_check(st->root2);
#endif
lyd_free(st->root1);
lyd_free(st->root2);
ly_ctx_destroy(st->ctx, NULL);
free(st);
(*state) = NULL;
return 0;
}
static void
test_merge_same(void **state)
{
char *str1;
struct state *st = (*state);
const char str2[] =
"<cont xmlns=\"urn:state-lists\">\n"
" <l>\n"
" <leaf1>aa</leaf1>\n"
" <leaf2>10</leaf2>\n"
" <lcont>\n"
" <leaf3/>\n"
" <l2>\n"
" <leaf4>aa</leaf4>\n"
" <leaf5>aa</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <l>\n"
" <leaf1>b</leaf1>\n"
" <leaf2>20</leaf2>\n"
" <lcont>\n"
" <l2>\n"
" <leaf5>bb</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l/>\n"
" <l/>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
"</cont>\n";
/* merging 2 exact same data trees, the result should always be again the same data tree */
assert_int_equal(lyd_merge(st->root1, st->root2, 0), 0);
lyd_print_mem(&str1, st->root1, LYD_XML, LYP_FORMAT);
assert_non_null(str1);
assert_string_equal(str1, str2);
free(str1);
}
static void
test_merge_equal_leaflist(void **state)
{
struct lyd_node *node;
char *str1;
struct state *st = (*state);
const char str2[] =
"<cont xmlns=\"urn:state-lists\">\n"
" <l>\n"
" <leaf1>aa</leaf1>\n"
" <leaf2>10</leaf2>\n"
" <lcont>\n"
" <leaf3/>\n"
" <l2>\n"
" <leaf4>aa</leaf4>\n"
" <leaf5>aa</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <l>\n"
" <leaf1>b</leaf1>\n"
" <leaf2>20</leaf2>\n"
" <lcont>\n"
" <l2>\n"
" <leaf5>bb</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l/>\n"
" <l/>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <ll>abab</ll>\n"
"</cont>\n";
/* we added a leaf-list, an exact same one is already there */
node = lyd_new_path(st->root2, NULL, "/state-lists:cont/ll", "abab", 0, 0);
assert_non_null(node);
assert_string_equal(node->schema->name, "ll");
assert_int_equal(lyd_merge(st->root1, st->root2, 0), 0);
lyd_print_mem(&str1, st->root1, LYD_XML, LYP_FORMAT);
assert_non_null(str1);
assert_string_equal(str1, str2);
free(str1);
}
static void
test_merge_equal_list(void **state)
{
struct lyd_node *node;
char *str1;
struct state *st = (*state);
const char str2[] =
"<cont xmlns=\"urn:state-lists\">\n"
" <l>\n"
" <leaf1>aa</leaf1>\n"
" <leaf2>10</leaf2>\n"
" <lcont>\n"
" <leaf3/>\n"
" <l2>\n"
" <leaf4>aa</leaf4>\n"
" <leaf5>aa</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <l>\n"
" <leaf1>b</leaf1>\n"
" <leaf2>20</leaf2>\n"
" <lcont>\n"
" <l2>\n"
" <leaf5>bb</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l/>\n"
" <l/>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l>\n"
" <leaf1>aa</leaf1>\n"
" <leaf2>10</leaf2>\n"
" <lcont>\n"
" <leaf3/>\n"
" <l2>\n"
" <leaf4>aa</leaf4>\n"
" <leaf5>aa</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
"</cont>\n";
/* we added a list, an exact same one is already there */
node = lyd_dup(st->root1->child, 1);
assert_non_null(node);
assert_string_equal(node->schema->name, "l");
assert_int_equal(lyd_insert(st->root2, node), 0);
assert_int_equal(lyd_merge(st->root1, st->root2, 0), 0);
lyd_print_mem(&str1, st->root1, LYD_XML, LYP_FORMAT);
assert_non_null(str1);
assert_string_equal(str1, str2);
free(str1);
}
static void
test_merge_nonequal_list(void **state)
{
struct lyd_node *node;
char *str1;
struct state *st = (*state);
const char str2[] =
"<cont xmlns=\"urn:state-lists\">\n"
" <l>\n"
" <leaf1>aa</leaf1>\n"
" <leaf2>10</leaf2>\n"
" <lcont>\n"
" <leaf3/>\n"
" <l2>\n"
" <leaf4>aa</leaf4>\n"
" <leaf5>aa</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <l>\n"
" <leaf1>b</leaf1>\n"
" <leaf2>20</leaf2>\n"
" <lcont>\n"
" <l2>\n"
" <leaf5>bb</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l/>\n"
" <l/>\n"
" <ll>abab</ll>\n"
" <ll>baba</ll>\n"
" <l>\n"
" <leaf1>b</leaf1>\n"
" <leaf2>20</leaf2>\n"
" <lcont>\n"
" <l2>\n"
" <leaf5>cc</leaf5>\n"
" </l2>\n"
" </lcont>\n"
" </l>\n"
"</cont>\n";
/* now one of the keyless lists is different, the whole instance should be in the diff */
node = lyd_dup(st->root1->child->next, 1);
assert_non_null(node);
assert_string_equal(node->schema->name, "l");
assert_int_equal(lyd_insert(st->root2, node), 0);
node = lyd_new_path(st->root2, NULL, "/state-lists:cont/l[5]/lcont/l2[1]/leaf5", "cc", 0, LYD_PATH_OPT_UPDATE);
assert_non_null(node);
assert_string_equal(node->schema->name, "leaf5");
assert_int_equal(lyd_merge(st->root1, st->root2, 0), 0);
lyd_print_mem(&str1, st->root1, LYD_XML, LYP_FORMAT);
assert_non_null(str1);
assert_string_equal(str1, str2);
free(str1);
}
static void
test_diff_same(void **state)
{
struct lyd_difflist *diff;
struct state *st = (*state);
/* diffing 2 exact same data trees, the result should be no differences */
diff = lyd_diff(st->root1, st->root2, 0);
assert_non_null(diff);
assert_int_equal(diff->type[0], LYD_DIFF_END);
lyd_free_diff(diff);
}
static void
test_diff_equal_leaflist(void **state)
{
struct lyd_node *node;
struct lyd_difflist *diff;
struct state *st = (*state);
/* we added a leaf-list, an exact same one is already there */
node = lyd_new_path(st->root2, NULL, "/state-lists:cont/ll", "abab", 0, 0);
assert_non_null(node);
assert_string_equal(node->schema->name, "ll");
diff = lyd_diff(st->root1, st->root2, 0);
assert_non_null(diff);
assert_int_equal(diff->type[0], LYD_DIFF_CREATED);
assert_string_equal(diff->second[0]->schema->name, "ll");
assert_string_equal(((struct lyd_node_leaf_list *)diff->second[0])->value_str, "abab");
assert_int_equal(diff->type[1], LYD_DIFF_END);
lyd_free_diff(diff);
}
static void
test_diff_equal_list(void **state)
{
struct lyd_node *node;
struct lyd_difflist *diff;
struct state *st = (*state);
/* we added a list, an exact same one is already there */
node = lyd_dup(st->root1->child, 1);
assert_non_null(node);
assert_string_equal(node->schema->name, "l");
assert_int_equal(lyd_insert(st->root2, node), 0);
diff = lyd_diff(st->root1, st->root2, 0);
assert_non_null(diff);
assert_int_equal(diff->type[0], LYD_DIFF_CREATED);
assert_string_equal(diff->second[0]->schema->name, "l");
assert_int_equal(lyd_list_pos(diff->second[0]), 5);
assert_int_equal(diff->type[1], LYD_DIFF_END);
lyd_free_diff(diff);
}
static void
test_diff_nonequal_list(void **state)
{
struct lyd_node *node;
struct lyd_difflist *diff;
struct state *st = (*state);
/* now one of the keyless lists is different, the whole instance should be in the diff */
node = lyd_dup(st->root1->child->next, 1);
assert_non_null(node);
assert_string_equal(node->schema->name, "l");
assert_int_equal(lyd_insert(st->root2, node), 0);
node = lyd_new_path(st->root2, NULL, "/state-lists:cont/l[5]/lcont/l2[1]/leaf5", "cc", 0, LYD_PATH_OPT_UPDATE);
assert_non_null(node);
assert_string_equal(node->schema->name, "leaf5");
diff = lyd_diff(st->root1, st->root2, 0);
assert_int_equal(diff->type[0], LYD_DIFF_CREATED);
assert_string_equal(diff->second[0]->schema->name, "l");
assert_int_equal(lyd_list_pos(diff->second[0]), 5);
assert_int_equal(diff->type[1], LYD_DIFF_END);
lyd_free_diff(diff);
}
int main(void)
{
const struct CMUnitTest tests[] = {
#ifdef LY_ENABLED_CACHE
cmocka_unit_test_setup_teardown(test_hash, setup_f, teardown_f),
#endif
cmocka_unit_test_setup_teardown(test_merge_same, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_merge_equal_leaflist, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_merge_equal_list, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_merge_nonequal_list, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_diff_same, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_diff_equal_leaflist, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_diff_equal_list, setup_f, teardown_f),
cmocka_unit_test_setup_teardown(test_diff_nonequal_list, setup_f, teardown_f),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}