blob: 27dba424417574ffebd1158c50f97d57aa585b17 [file] [log] [blame]
Michal Vasko004d3152020-06-11 19:59:22 +02001/**
aPiecek023f83a2021-05-11 07:37:03 +02002 * @file test_tree_data.c
Radek Krejci1f05b6a2019-07-18 16:15:06 +02003 * @author: Radek Krejci <rkrejci@cesnet.cz>
4 * @brief unit tests for functions from tress_data.c
5 *
6 * Copyright (c) 2018-2019 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Radek Iša56ca9e42020-09-08 18:42:00 +020014#define _UTEST_MAIN_
15#include "utests.h"
Radek Krejci1f05b6a2019-07-18 16:15:06 +020016
Michal Vasko38c2ba72020-07-27 14:46:59 +020017#include "common.h"
Radek Krejcib4ac5a92020-11-23 17:54:33 +010018#include "libyang.h"
Michal Vasko38c2ba72020-07-27 14:46:59 +020019#include "path.h"
20#include "xpath.h"
Radek Krejci1f05b6a2019-07-18 16:15:06 +020021
Radek Krejci1f05b6a2019-07-18 16:15:06 +020022static int
23setup(void **state)
24{
aPiecek24252202021-03-30 12:23:32 +020025 const char *schema1 = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;"
26 "revision 2014-05-08;"
Radek Krejcica989142020-11-05 11:32:22 +010027 "leaf bar {type string;}"
Radek Krejci1f05b6a2019-07-18 16:15:06 +020028 "list l1 { key \"a b\"; leaf a {type string;} leaf b {type string;} leaf c {type string;}}"
29 "leaf foo { type string;}"
30 "leaf-list ll { type string;}"
31 "container c {leaf-list x {type string;}}"
32 "anydata any {config false;}"
Michal Vasko38c2ba72020-07-27 14:46:59 +020033 "list l2 {config false;"
Radek Krejcib4ac5a92020-11-23 17:54:33 +010034 " container c{leaf x {type string;} leaf-list d {type string;}}"
Michal Vasko38c2ba72020-07-27 14:46:59 +020035 "}}";
Radek Krejci1f05b6a2019-07-18 16:15:06 +020036
aPiecek24252202021-03-30 12:23:32 +020037 const char *schema2 = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
38 "revision 2014-05-08;"
39 "list l2 {config false;"
40 " container c{leaf x {type string;}}}"
41 "anydata any {config false;}"
42 "}";
43
Michal Vasko6b669ff2021-04-30 16:25:36 +020044 const char *schema3 = "module c {yang-version 1.1; namespace \"http://example.com/main\";prefix m;"
45 "import \"ietf-inet-types\" {prefix inet;}"
46 "typedef optional-ip-address {type union {"
47 " type inet:ip-address;"
Michal Vasko4fd91922021-09-15 08:51:06 +020048 " type string;"
Michal Vasko6b669ff2021-04-30 16:25:36 +020049 "}}"
50 "container cont {"
51 " list nexthop {min-elements 1; key \"gateway\";"
52 " leaf gateway {type optional-ip-address;}"
53 " }"
Michal Vasko15dc9fa2021-05-03 14:33:05 +020054 " leaf-list pref {type inet:ipv6-prefix;}"
Michal Vasko6b669ff2021-04-30 16:25:36 +020055 "}}";
56
Radek Iša56ca9e42020-09-08 18:42:00 +020057 UTEST_SETUP;
Radek Krejci1f05b6a2019-07-18 16:15:06 +020058
aPiecek24252202021-03-30 12:23:32 +020059 UTEST_ADD_MODULE(schema1, LYS_IN_YANG, NULL, NULL);
60 UTEST_ADD_MODULE(schema2, LYS_IN_YANG, NULL, NULL);
Michal Vasko6b669ff2021-04-30 16:25:36 +020061 UTEST_ADD_MODULE(schema3, LYS_IN_YANG, NULL, NULL);
Radek Krejci1f05b6a2019-07-18 16:15:06 +020062
63 return 0;
64}
65
Radek Iša56ca9e42020-09-08 18:42:00 +020066#define CHECK_PARSE_LYD(INPUT, PARSE_OPTION, VALIDATE_OPTION, TREE) \
67 CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, PARSE_OPTION, VALIDATE_OPTION, LY_SUCCESS, TREE)
Radek Krejci1f05b6a2019-07-18 16:15:06 +020068
aPiecek24252202021-03-30 12:23:32 +020069#define CHECK_PARSE_LYD_PARAM_CTX(CTX, INPUT, PARSE_OPTION, OUT_NODE) \
70 assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(CTX, INPUT, LYD_XML, PARSE_OPTION, LYD_VALIDATE_PRESENT, &OUT_NODE)); \
71 assert_non_null(OUT_NODE);
72
73#define RECREATE_CTX_WITH_MODULE(CTX, MODULE) \
Radek Krejci90ed21e2021-04-12 14:47:46 +020074 ly_ctx_destroy(CTX); \
aPiecek24252202021-03-30 12:23:32 +020075 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &CTX)); \
76 assert_int_equal(LY_SUCCESS, ly_in_new_memory(MODULE, &_UC->in)); \
77 assert_int_equal(LY_SUCCESS, lys_parse(CTX, _UC->in, LYS_IN_YANG, NULL, NULL)); \
78 ly_in_free(_UC->in, 0);
79
Radek Krejci1f05b6a2019-07-18 16:15:06 +020080static void
81test_compare(void **state)
82{
Radek Krejci1f05b6a2019-07-18 16:15:06 +020083 struct lyd_node *tree1, *tree2;
Radek Iša56ca9e42020-09-08 18:42:00 +020084 const char *data1;
85 const char *data2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +020086
Michal Vasko8f359bf2020-07-28 10:41:15 +020087 assert_int_equal(LY_SUCCESS, lyd_compare_single(NULL, NULL, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +020088
Radek Iša56ca9e42020-09-08 18:42:00 +020089 data1 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
90 data2 = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>y</c></l1>";
91 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
92 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko8f359bf2020-07-28 10:41:15 +020093 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
94 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejcib4ac5a92020-11-23 17:54:33 +010095 assert_int_equal(LY_ENOT, lyd_compare_single(((struct lyd_node_inner *)tree1)->child, tree2, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +020096 lyd_free_all(tree1);
97 lyd_free_all(tree2);
98
99 data1 = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
100 data2 = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200101 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
102 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko26123192020-11-09 21:02:34 +0100103 assert_int_equal(LY_ENOT, lyd_compare_single(tree1->next, tree2->next, 0));
104 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next->next, tree2->next, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200105 lyd_free_all(tree1);
106 lyd_free_all(tree2);
107
108 data1 = "<ll xmlns=\"urn:tests:a\">a</ll><ll xmlns=\"urn:tests:a\">b</ll>";
109 data2 = "<ll xmlns=\"urn:tests:a\">b</ll>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200110 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
111 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200112 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
113 assert_int_equal(LY_ENOT, lyd_compare_single(NULL, tree2, 0));
114 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, NULL, 0));
115 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200116 lyd_free_all(tree1);
117 lyd_free_all(tree2);
118
119 data1 = "<c xmlns=\"urn:tests:a\"><x>x</x></c>";
120 data2 = "<c xmlns=\"urn:tests:a\"><x>y</x></c>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200121 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
122 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200123 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
124 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200125 lyd_free_all(tree1);
126 lyd_free_all(tree2);
127
128 data1 = "<c xmlns=\"urn:tests:a\"><x>x</x></c>";
129 data2 = "<c xmlns=\"urn:tests:a\"><x>x</x><x>y</x></c>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200130 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
131 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200132 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
133 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200134 lyd_free_all(tree1);
135 lyd_free_all(tree2);
136
137 data1 = "<any xmlns=\"urn:tests:a\"><x>x</x></any>";
138 data2 = "<any xmlns=\"urn:tests:a\"><x>x</x><x>y</x></any>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200139 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
140 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
Michal Vasko26123192020-11-09 21:02:34 +0100141 assert_int_equal(LY_ENOT, lyd_compare_single(tree1->next, tree2->next, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200142 lyd_free_all(tree1);
143 data1 = "<any xmlns=\"urn:tests:a\"><x>x</x><x>y</x></any>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200144 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200145 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200146 lyd_free_all(tree1);
147 lyd_free_all(tree2);
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200148}
149
Radek Krejci22ebdba2019-07-25 13:59:43 +0200150static void
aPiecek24252202021-03-30 12:23:32 +0200151test_compare_diff_ctx(void **state)
152{
153 struct lyd_node *tree1, *tree2;
154 const char *data1, *data2;
155 struct ly_ctx *ctx2 = NULL;
156 const char *module;
157
158 /* create second context with the same schema */
159 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
160 "revision 2014-05-08;"
161 "list l2 {config false;"
162 " container c{leaf x {type string;}}"
163 "}}";
164 RECREATE_CTX_WITH_MODULE(ctx2, module);
165 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
166 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
167 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
168 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
169 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
170 lyd_free_all(tree1);
171 lyd_free_all(tree2);
172
173 /* recreate second context with schema that has a different name */
174 module = "module c {namespace urn:tests:c;prefix c;yang-version 1.1;"
175 "revision 2014-05-08;"
176 "list l2 {config false;"
177 " container c{leaf x {type string;}}"
178 "}}";
179 RECREATE_CTX_WITH_MODULE(ctx2, module);
180 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
181 data2 = "<l2 xmlns=\"urn:tests:c\"><c><x>b</x></c></l2>";
182 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
183 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
184 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
185 lyd_free_all(tree1);
186 lyd_free_all(tree2);
187
188 /* recreate second context with schema that has a different revision */
189 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
190 "revision 2015-05-08;"
191 "list l2 {config false;"
192 " container c{leaf x {type string;}}"
193 "}}";
194 RECREATE_CTX_WITH_MODULE(ctx2, module);
195 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
196 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
197 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
198 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
199 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
200 lyd_free_all(tree1);
201 lyd_free_all(tree2);
202
203 /* recreate second context with schema that has no revision */
204 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
205 "list l2 {config false;"
206 " container c{leaf x {type string;}}"
207 "}}";
208 RECREATE_CTX_WITH_MODULE(ctx2, module);
209 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
210 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
211 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
212 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
213 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
214 lyd_free_all(tree1);
215 lyd_free_all(tree2);
216
217 /* recreate second context with schema that has a different parent nodetype */
218 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
219 "revision 2014-05-08;"
220 "container l2 {config false;"
221 " container c{leaf x {type string;}}"
222 "}}";
223 RECREATE_CTX_WITH_MODULE(ctx2, module);
224 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
225 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
226 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
227 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
228 assert_int_equal(LY_ENOT, lyd_compare_single(lyd_child(lyd_child(tree1)), lyd_child(lyd_child(tree2)), 0));
229 lyd_free_all(tree1);
230 lyd_free_all(tree2);
231
232 /* recreate second context with the same opaq data nodes */
233 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
234 "revision 2014-05-08;"
235 "anydata any {config false;}"
236 "}";
237 RECREATE_CTX_WITH_MODULE(ctx2, module);
238 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
239 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>bb:x</x></any>";
240 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
241 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
242 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
243 lyd_free_all(tree1);
244 lyd_free_all(tree2);
245
246 /* recreate second context with the different opaq data node value */
247 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
248 "revision 2014-05-08;"
249 "anydata any {config false;}"
250 "}";
251 RECREATE_CTX_WITH_MODULE(ctx2, module);
252 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
253 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>bb:y</x></any>";
254 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
255 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
256 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
257 lyd_free_all(tree1);
258 lyd_free_all(tree2);
259
260 /* recreate second context with the wrong prefix in opaq data node value */
261 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
262 "revision 2014-05-08;"
263 "anydata any {config false;}"
264 "}";
265 RECREATE_CTX_WITH_MODULE(ctx2, module);
266 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
267 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>cc:x</x></any>";
268 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
269 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
270 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
271 lyd_free_all(tree1);
272 lyd_free_all(tree2);
273
274 /* clean up */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200275 ly_ctx_destroy(ctx2);
aPiecek24252202021-03-30 12:23:32 +0200276 _UC->in = NULL;
277}
278
279static void
Radek Krejci22ebdba2019-07-25 13:59:43 +0200280test_dup(void **state)
281{
Radek Krejci22ebdba2019-07-25 13:59:43 +0200282 struct lyd_node *tree1, *tree2;
283 const char *result;
Radek Iša56ca9e42020-09-08 18:42:00 +0200284 const char *data;
Radek Krejci22ebdba2019-07-25 13:59:43 +0200285
Radek Iša56ca9e42020-09-08 18:42:00 +0200286 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
287 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200288 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, LYD_DUP_RECURSIVE, &tree2));
Michal Vasko8f359bf2020-07-28 10:41:15 +0200289 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200290 lyd_free_all(tree1);
291 lyd_free_all(tree2);
292
293 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
294 result = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200295 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200296 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200297 lyd_free_all(tree1);
Radek Iša56ca9e42020-09-08 18:42:00 +0200298 CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200299 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200300 lyd_free_all(tree1);
301 lyd_free_all(tree2);
302
303 data = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
304 result = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200305 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200306 assert_int_equal(LY_SUCCESS, lyd_dup_siblings(tree1, NULL, LYD_DUP_RECURSIVE, &tree2));
Michal Vasko26123192020-11-09 21:02:34 +0100307 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2->next, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200308 lyd_free_all(tree2);
Michal Vasko26123192020-11-09 21:02:34 +0100309 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, LYD_DUP_RECURSIVE, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200310 lyd_free_all(tree1);
Radek Iša56ca9e42020-09-08 18:42:00 +0200311 CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko26123192020-11-09 21:02:34 +0100312 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200313 lyd_free_all(tree2);
314
Michal Vasko26123192020-11-09 21:02:34 +0100315 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200316 lyd_free_all(tree1);
317 result = "<l2 xmlns=\"urn:tests:a\"/>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200318 CHECK_PARSE_LYD_PARAM(result, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree1);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200319 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200320 lyd_free_all(tree1);
321 lyd_free_all(tree2);
322
323 data = "<any xmlns=\"urn:tests:a\"><c><a>a</a></c></any>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200324 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200325 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
Michal Vasko8f359bf2020-07-28 10:41:15 +0200326 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200327 lyd_free_all(tree1);
328 lyd_free_all(tree2);
329
330 data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200331 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100332 assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)((struct lyd_node_inner *)tree1->next)->child)->child, NULL,
333 LYD_DUP_WITH_PARENTS, &tree2));
Radek Iša56ca9e42020-09-08 18:42:00 +0200334 int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM;
335
336 CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "x", 1, LYS_LEAF, 1, 0, NULL, 0);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100337 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, (struct lyd_node *)tree2->parent->parent,
Michal Vasko26123192020-11-09 21:02:34 +0100338 LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200339 lyd_free_all(tree1);
340 lyd_free_all(tree2);
341
342 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>c</c></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200343 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100344 assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev, NULL,
345 LYD_DUP_WITH_PARENTS, &tree2));
Radek Iša56ca9e42020-09-08 18:42:00 +0200346 flag = LYS_CONFIG_W | LYS_SET_ENUM;
347 CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "c", 0, LYS_LEAF, 1, 0, NULL, 0);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100348 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, (struct lyd_node *)tree2->parent, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200349 lyd_free_all(tree1);
350 lyd_free_all(tree2);
351
352 data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200353 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko26123192020-11-09 21:02:34 +0100354 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100355 assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)((struct lyd_node_inner *)tree1->next)->child)->child,
356 (struct lyd_node_inner *)tree2, LYD_DUP_WITH_PARENTS, NULL));
Michal Vasko26123192020-11-09 21:02:34 +0100357 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200358 lyd_free_all(tree1);
359 lyd_free_all(tree2);
360
361 /* invalid */
362 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>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200363 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100364 assert_int_equal(LY_EINVAL, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev,
365 (struct lyd_node_inner *)tree1->next, LYD_DUP_WITH_PARENTS, NULL));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200366 lyd_free_all(tree1);
Radek Krejci22ebdba2019-07-25 13:59:43 +0200367}
368
Michal Vasko38c2ba72020-07-27 14:46:59 +0200369static void
370test_target(void **state)
371{
Michal Vasko38c2ba72020-07-27 14:46:59 +0200372 const struct lyd_node_term *term;
373 struct lyd_node *tree;
374 struct lyxp_expr *exp;
375 struct ly_path *path;
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200376 const char *path_str = "/a:l2[2]/c/d[3]";
Michal Vasko38c2ba72020-07-27 14:46:59 +0200377 const char *data =
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100378 "<l2 xmlns=\"urn:tests:a\"><c>"
379 " <d>a</d>"
380 " </c></l2>"
381 "<l2 xmlns=\"urn:tests:a\"><c>"
382 " <d>a</d>"
383 " <d>b</d>"
384 " <d>b</d>"
385 " <d>c</d>"
386 "</c></l2>"
387 "<l2 xmlns=\"urn:tests:a\"><c>"
388 "</c></l2>";
Michal Vasko38c2ba72020-07-27 14:46:59 +0200389
Radek Iša56ca9e42020-09-08 18:42:00 +0200390 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
Michal Vaskoed725d72021-06-23 12:03:45 +0200391 assert_int_equal(LY_SUCCESS, ly_path_parse(UTEST_LYCTX, NULL, path_str, strlen(path_str), 0, LY_PATH_BEGIN_EITHER,
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100392 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp));
Michal Vaskoed725d72021-06-23 12:03:45 +0200393 assert_int_equal(LY_SUCCESS, ly_path_compile(UTEST_LYCTX, NULL, NULL, NULL, exp, LY_PATH_OPER_INPUT,
Michal Vasko0884d212021-10-14 09:21:46 +0200394 LY_PATH_TARGET_SINGLE, 1, LY_VALUE_JSON, NULL, &path));
Michal Vasko38c2ba72020-07-27 14:46:59 +0200395 term = lyd_target(path, tree);
396
Michal Vaskoe78faec2021-04-08 17:24:43 +0200397 const int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM | LYS_ORDBY_USER;
Radek Iša56ca9e42020-09-08 18:42:00 +0200398
399 CHECK_LYSC_NODE(term->schema, NULL, 0, flag, 1, "d", 0, LYS_LEAFLIST, 1, 0, NULL, 0);
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200400 assert_string_equal(lyd_get_value(&term->node), "b");
401 assert_string_equal(lyd_get_value(term->prev), "b");
Michal Vasko38c2ba72020-07-27 14:46:59 +0200402
403 lyd_free_all(tree);
Radek Iša56ca9e42020-09-08 18:42:00 +0200404 ly_path_free(UTEST_LYCTX, path);
405 lyxp_expr_free(UTEST_LYCTX, exp);
Michal Vasko38c2ba72020-07-27 14:46:59 +0200406}
407
Radek Krejcica989142020-11-05 11:32:22 +0100408static void
409test_list_pos(void **state)
410{
Radek Krejcica989142020-11-05 11:32:22 +0100411 const char *data;
412 struct lyd_node *tree;
413
414 data = "<bar xmlns=\"urn:tests:a\">test</bar>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100415 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b></l1>"
416 "<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
417 "<foo xmlns=\"urn:tests:a\">test</foo>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200418 assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
Radek Krejcica989142020-11-05 11:32:22 +0100419 assert_int_equal(0, lyd_list_pos(tree));
420 assert_int_equal(1, lyd_list_pos(tree->next));
421 assert_int_equal(2, lyd_list_pos(tree->next->next));
422 assert_int_equal(0, lyd_list_pos(tree->next->next->next));
423 lyd_free_all(tree);
424
425 data = "<ll xmlns=\"urn:tests:a\">one</ll>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100426 "<ll xmlns=\"urn:tests:a\">two</ll>"
427 "<ll xmlns=\"urn:tests:a\">three</ll>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200428 assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
Radek Krejcica989142020-11-05 11:32:22 +0100429 assert_int_equal(1, lyd_list_pos(tree));
430 assert_int_equal(2, lyd_list_pos(tree->next));
431 assert_int_equal(3, lyd_list_pos(tree->next->next));
432 lyd_free_all(tree);
433
434 data = "<ll xmlns=\"urn:tests:a\">one</ll>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100435 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b></l1>"
436 "<ll xmlns=\"urn:tests:a\">two</ll>"
437 "<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
438 "<ll xmlns=\"urn:tests:a\">three</ll>"
439 "<l1 xmlns=\"urn:tests:a\"><a>three</a><b>three</b></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200440 assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
Radek Krejcica989142020-11-05 11:32:22 +0100441 assert_string_equal("l1", tree->schema->name);
442 assert_int_equal(1, lyd_list_pos(tree));
443 assert_int_equal(2, lyd_list_pos(tree->next));
444 assert_int_equal(3, lyd_list_pos(tree->next->next));
445 assert_string_equal("ll", tree->next->next->next->schema->name);
446 assert_int_equal(1, lyd_list_pos(tree->next->next->next));
447 assert_int_equal(2, lyd_list_pos(tree->next->next->next->next));
448 assert_int_equal(3, lyd_list_pos(tree->next->next->next->next->next));
449 lyd_free_all(tree);
Radek Krejcica989142020-11-05 11:32:22 +0100450}
451
Radek Krejci4233f9b2020-11-05 12:38:35 +0100452static void
453test_first_sibling(void **state)
454{
Radek Krejci4233f9b2020-11-05 12:38:35 +0100455 const char *data;
456 struct lyd_node *tree;
457 struct lyd_node_inner *parent;
458
459 data = "<bar xmlns=\"urn:tests:a\">test</bar>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100460 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b><c>one</c></l1>"
461 "<foo xmlns=\"urn:tests:a\">test</foo>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200462 assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree));
Radek Krejci4233f9b2020-11-05 12:38:35 +0100463 assert_ptr_equal(tree, lyd_first_sibling(tree->next));
464 assert_ptr_equal(tree, lyd_first_sibling(tree));
465 assert_ptr_equal(tree, lyd_first_sibling(tree->prev));
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100466 parent = (struct lyd_node_inner *)tree->next;
Radek Krejci4233f9b2020-11-05 12:38:35 +0100467 assert_int_equal(LYS_LIST, parent->schema->nodetype);
468 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child->next));
469 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child));
470 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child->prev));
471 lyd_free_all(tree);
Radek Krejci4233f9b2020-11-05 12:38:35 +0100472}
473
Michal Vasko6b669ff2021-04-30 16:25:36 +0200474static void
475test_find_path(void **state)
476{
477 struct lyd_node *root;
478 const struct lys_module *mod;
479
480 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "c");
481 assert_non_null(mod);
482
483 assert_int_equal(LY_SUCCESS, lyd_new_inner(NULL, mod, "cont", 0, &root));
484 assert_int_equal(LY_SUCCESS, lyd_new_path(root, NULL, "/c:cont/nexthop[gateway='10.0.0.1']", NULL, LYD_NEW_PATH_UPDATE, NULL));
485 assert_int_equal(LY_SUCCESS, lyd_new_path(root, NULL, "/c:cont/nexthop[gateway='2100::1']", NULL, LYD_NEW_PATH_UPDATE, NULL));
Michal Vasko15dc9fa2021-05-03 14:33:05 +0200486 assert_int_equal(LY_SUCCESS, lyd_new_path(root, NULL, "/c:cont/pref[.='fc00::/64']", NULL, 0, NULL));
Michal Vasko6b669ff2021-04-30 16:25:36 +0200487
488 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/nexthop[gateway='10.0.0.1']", 0, NULL));
489 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/nexthop[gateway='2100::1']", 0, NULL));
Michal Vasko15dc9fa2021-05-03 14:33:05 +0200490 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/pref[.='fc00::/64']", 0, NULL));
Michal Vasko6b669ff2021-04-30 16:25:36 +0200491 lyd_free_all(root);
492}
493
aPiecek4f07c3e2021-06-11 10:53:07 +0200494static void
495test_data_hash(void **state)
496{
497 struct lyd_node *tree;
498 const char *schema, *data;
499
500 schema =
501 "module test-data-hash {"
502 " yang-version 1.1;"
503 " namespace \"urn:tests:tdh\";"
504 " prefix t;"
505 " container c {"
506 " leaf-list ll {"
507 " type string;"
508 " }"
509 " }"
510 "}";
511
512 UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
513
514 /* The number of <ll/> must be greater or equal to LYD_HT_MIN_ITEMS
515 * for the correct test run. It should guarantee the creation of a hash table.
516 */
517 assert_true(LYD_HT_MIN_ITEMS <= 4);
518 data =
519 "<c xmlns='urn:tests:tdh'>"
520 " <ll/>"
521 " <ll/>"
522 " <ll/>"
523 " <ll/>"
524 "</c>";
525
526 /* The run must not crash due to the assert that checks the hash. */
527 CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
528 lyd_free_all(tree);
529}
530
aPiecekdf23eee2021-10-07 12:21:50 +0200531static void
532test_lyxp_vars(void **UNUSED(state))
533{
534 struct lyxp_var *vars;
535
536 /* Test free. */
537 vars = NULL;
538 lyxp_vars_free(vars);
539
540 /* Bad arguments for lyxp_vars_add(). */
541 assert_int_equal(LY_EINVAL, lyxp_vars_set(NULL, "var1", "val1"));
542 assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, NULL, "val1"));
543 assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, "var1", NULL));
544 lyxp_vars_free(vars);
545 vars = NULL;
546
547 /* Add one item. */
548 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1"));
549 assert_int_equal(LY_ARRAY_COUNT(vars), 1);
550 assert_string_equal(vars[0].name, "var1");
551 assert_string_equal(vars[0].value, "val1");
552 lyxp_vars_free(vars);
553 vars = NULL;
554
555 /* Add three items. */
556 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1"));
557 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var2", "val2"));
558 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var3", "val3"));
559 assert_int_equal(LY_ARRAY_COUNT(vars), 3);
560 assert_string_equal(vars[0].name, "var1");
561 assert_string_equal(vars[0].value, "val1");
562 assert_string_equal(vars[1].name, "var2");
563 assert_string_equal(vars[1].value, "val2");
564 assert_string_equal(vars[2].name, "var3");
565 assert_string_equal(vars[2].value, "val3");
566 lyxp_vars_free(vars);
567 vars = NULL;
568
569 /* Change value of a variable. */
570 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1"));
571 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var2", "val2"));
572 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "new_value"));
573 assert_string_equal(vars[0].name, "var1");
574 assert_string_equal(vars[0].value, "new_value");
575 assert_string_equal(vars[1].name, "var2");
576 assert_string_equal(vars[1].value, "val2");
577 lyxp_vars_free(vars);
578 vars = NULL;
579}
580
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100581int
582main(void)
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200583{
584 const struct CMUnitTest tests[] = {
Radek Iša56ca9e42020-09-08 18:42:00 +0200585 UTEST(test_compare, setup),
aPiecek24252202021-03-30 12:23:32 +0200586 UTEST(test_compare_diff_ctx, setup),
Radek Iša56ca9e42020-09-08 18:42:00 +0200587 UTEST(test_dup, setup),
588 UTEST(test_target, setup),
589 UTEST(test_list_pos, setup),
590 UTEST(test_first_sibling, setup),
Michal Vasko6b669ff2021-04-30 16:25:36 +0200591 UTEST(test_find_path, setup),
aPiecek4f07c3e2021-06-11 10:53:07 +0200592 UTEST(test_data_hash, setup),
aPiecekdf23eee2021-10-07 12:21:50 +0200593 UTEST(test_lyxp_vars),
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200594 };
595
596 return cmocka_run_group_tests(tests, NULL, NULL);
597}