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