blob: b3dde5a6a4d32d8223df51d82de362165139eb5d [file] [log] [blame]
Michal Vasko004d3152020-06-11 19:59:22 +02001/**
aPiecek023f83a2021-05-11 07:37:03 +02002 * @file test_tree_data.c
Michal Vaskoee9b9482023-06-19 13:17:48 +02003 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief unit tests for functions from tree_data.c
Radek Krejci1f05b6a2019-07-18 16:15:06 +02005 *
Michal Vaskoee9b9482023-06-19 13:17:48 +02006 * Copyright (c) 2018-2023 CESNET, z.s.p.o.
Radek Krejci1f05b6a2019-07-18 16:15:06 +02007 *
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
Radek Krejcib4ac5a92020-11-23 17:54:33 +010017#include "libyang.h"
Michal Vasko8f702ee2024-02-20 15:44:24 +010018#include "ly_common.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 Vaskoee9b9482023-06-19 13:17:48 +0200103 assert_int_equal(LY_ENOT, lyd_compare_single(tree1->next, tree2->next, LYD_COMPARE_FULL_RECURSION));
Michal Vasko26123192020-11-09 21:02:34 +0100104 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);
Michal Vaskof277d362023-04-24 09:08:31 +0200148
149 data1 = "<c xmlns=\"urn:tests:a\"><x>c</x><x>a</x><x>b</x></c>";
150 data2 = "<c xmlns=\"urn:tests:a\"><x>a</x><x>b</x><x>c</x></c>";
151 CHECK_PARSE_LYD(data1, 0, LYD_VALIDATE_PRESENT, tree1);
152 CHECK_PARSE_LYD(data2, 0, LYD_VALIDATE_PRESENT, tree2);
153 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
154 lyd_free_all(tree1);
155 lyd_free_all(tree2);
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200156}
157
Radek Krejci22ebdba2019-07-25 13:59:43 +0200158static void
aPiecek24252202021-03-30 12:23:32 +0200159test_compare_diff_ctx(void **state)
160{
161 struct lyd_node *tree1, *tree2;
162 const char *data1, *data2;
163 struct ly_ctx *ctx2 = NULL;
164 const char *module;
165
166 /* create second context with the same schema */
167 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
168 "revision 2014-05-08;"
169 "list l2 {config false;"
170 " container c{leaf x {type string;}}"
171 "}}";
172 RECREATE_CTX_WITH_MODULE(ctx2, module);
173 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
174 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
175 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
176 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
177 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
178 lyd_free_all(tree1);
179 lyd_free_all(tree2);
180
181 /* recreate second context with schema that has a different name */
182 module = "module c {namespace urn:tests:c;prefix c;yang-version 1.1;"
183 "revision 2014-05-08;"
184 "list l2 {config false;"
185 " container c{leaf x {type string;}}"
186 "}}";
187 RECREATE_CTX_WITH_MODULE(ctx2, module);
188 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
189 data2 = "<l2 xmlns=\"urn:tests:c\"><c><x>b</x></c></l2>";
190 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
191 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
192 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
193 lyd_free_all(tree1);
194 lyd_free_all(tree2);
195
196 /* recreate second context with schema that has a different revision */
197 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
198 "revision 2015-05-08;"
199 "list l2 {config false;"
200 " container c{leaf x {type string;}}"
201 "}}";
202 RECREATE_CTX_WITH_MODULE(ctx2, module);
203 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
204 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
205 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
206 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
Michal Vasko5d49f942023-02-14 10:02:36 +0100207 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
aPiecek24252202021-03-30 12:23:32 +0200208 lyd_free_all(tree1);
209 lyd_free_all(tree2);
210
211 /* recreate second context with schema that has no revision */
212 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
213 "list l2 {config false;"
214 " container c{leaf x {type string;}}"
215 "}}";
216 RECREATE_CTX_WITH_MODULE(ctx2, module);
217 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
218 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
219 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
220 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
Michal Vasko5d49f942023-02-14 10:02:36 +0100221 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
aPiecek24252202021-03-30 12:23:32 +0200222 lyd_free_all(tree1);
223 lyd_free_all(tree2);
224
225 /* recreate second context with schema that has a different parent nodetype */
226 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
227 "revision 2014-05-08;"
228 "container l2 {config false;"
229 " container c{leaf x {type string;}}"
230 "}}";
231 RECREATE_CTX_WITH_MODULE(ctx2, module);
232 data1 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
233 data2 = "<l2 xmlns=\"urn:tests:b\"><c><x>b</x></c></l2>";
234 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1);
235 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2);
236 assert_int_equal(LY_ENOT, lyd_compare_single(lyd_child(lyd_child(tree1)), lyd_child(lyd_child(tree2)), 0));
237 lyd_free_all(tree1);
238 lyd_free_all(tree2);
239
240 /* recreate second context with the same opaq data nodes */
241 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
242 "revision 2014-05-08;"
243 "anydata any {config false;}"
244 "}";
245 RECREATE_CTX_WITH_MODULE(ctx2, module);
246 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
247 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>bb:x</x></any>";
248 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
249 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
250 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, 0));
251 lyd_free_all(tree1);
252 lyd_free_all(tree2);
253
254 /* recreate second context with the different opaq data node value */
255 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
256 "revision 2014-05-08;"
257 "anydata any {config false;}"
258 "}";
259 RECREATE_CTX_WITH_MODULE(ctx2, module);
260 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
261 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>bb:y</x></any>";
262 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
263 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
264 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
265 lyd_free_all(tree1);
266 lyd_free_all(tree2);
267
268 /* recreate second context with the wrong prefix in opaq data node value */
269 module = "module b {namespace urn:tests:b;prefix b;yang-version 1.1;"
270 "revision 2014-05-08;"
271 "anydata any {config false;}"
272 "}";
273 RECREATE_CTX_WITH_MODULE(ctx2, module);
274 data1 = "<any xmlns=\"urn:tests:b\" xmlns:aa=\"urn:tests:b\"><x>aa:x</x></any>";
275 data2 = "<any xmlns=\"urn:tests:b\" xmlns:bb=\"urn:tests:b\"><x>cc:x</x></any>";
276 CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, LYD_PARSE_ONLY, tree1);
277 CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, LYD_PARSE_ONLY, tree2);
278 assert_int_equal(LY_ENOT, lyd_compare_single(tree1, tree2, 0));
279 lyd_free_all(tree1);
280 lyd_free_all(tree2);
281
282 /* clean up */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200283 ly_ctx_destroy(ctx2);
aPiecek24252202021-03-30 12:23:32 +0200284 _UC->in = NULL;
285}
286
287static void
Radek Krejci22ebdba2019-07-25 13:59:43 +0200288test_dup(void **state)
289{
Radek Krejci22ebdba2019-07-25 13:59:43 +0200290 struct lyd_node *tree1, *tree2;
291 const char *result;
Radek Iša56ca9e42020-09-08 18:42:00 +0200292 const char *data;
Radek Krejci22ebdba2019-07-25 13:59:43 +0200293
Radek Iša56ca9e42020-09-08 18:42:00 +0200294 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
295 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, LYD_DUP_RECURSIVE, &tree2));
Michal Vasko8f359bf2020-07-28 10:41:15 +0200297 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200298 lyd_free_all(tree1);
299 lyd_free_all(tree2);
300
301 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>x</c></l1>";
302 result = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200303 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200304 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200305 lyd_free_all(tree1);
Radek Iša56ca9e42020-09-08 18:42:00 +0200306 CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200307 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200308 lyd_free_all(tree1);
309 lyd_free_all(tree2);
310
311 data = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2><l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
312 result = "<l2 xmlns=\"urn:tests:a\"><c><x>a</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200313 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200314 assert_int_equal(LY_SUCCESS, lyd_dup_siblings(tree1, NULL, LYD_DUP_RECURSIVE, &tree2));
Michal Vasko26123192020-11-09 21:02:34 +0100315 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2->next, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200316 lyd_free_all(tree2);
Michal Vasko26123192020-11-09 21:02:34 +0100317 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, LYD_DUP_RECURSIVE, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200318 lyd_free_all(tree1);
Radek Iša56ca9e42020-09-08 18:42:00 +0200319 CHECK_PARSE_LYD(result, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko26123192020-11-09 21:02:34 +0100320 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200321 lyd_free_all(tree2);
322
Michal Vasko26123192020-11-09 21:02:34 +0100323 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200324 lyd_free_all(tree1);
325 result = "<l2 xmlns=\"urn:tests:a\"/>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200326 CHECK_PARSE_LYD_PARAM(result, LYD_XML, LYD_PARSE_ONLY, 0, LY_SUCCESS, tree1);
Michal Vasko8f359bf2020-07-28 10:41:15 +0200327 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200328 lyd_free_all(tree1);
329 lyd_free_all(tree2);
330
331 data = "<any xmlns=\"urn:tests:a\"><c><a>a</a></c></any>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200332 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200333 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1, NULL, 0, &tree2));
Michal Vasko8f359bf2020-07-28 10:41:15 +0200334 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200335 lyd_free_all(tree1);
336 lyd_free_all(tree2);
337
338 data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200339 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vaskoeaef7c92023-10-17 10:06:15 +0200340 assert_int_equal(LY_SUCCESS, lyd_dup_single(lyd_child(lyd_child(tree1->next)), NULL, LYD_DUP_WITH_PARENTS, &tree2));
Radek Iša56ca9e42020-09-08 18:42:00 +0200341 int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM;
342
343 CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "x", 1, LYS_LEAF, 1, 0, NULL, 0);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100344 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, (struct lyd_node *)tree2->parent->parent,
Michal Vasko26123192020-11-09 21:02:34 +0100345 LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200346 lyd_free_all(tree1);
347 lyd_free_all(tree2);
348
349 data = "<l1 xmlns=\"urn:tests:a\"><a>a</a><b>b</b><c>c</c></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200350 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100351 assert_int_equal(LY_SUCCESS, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev, NULL,
352 LYD_DUP_WITH_PARENTS, &tree2));
Radek Iša56ca9e42020-09-08 18:42:00 +0200353 flag = LYS_CONFIG_W | LYS_SET_ENUM;
354 CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "c", 0, LYS_LEAF, 1, 0, NULL, 0);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100355 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 +0200356 lyd_free_all(tree1);
357 lyd_free_all(tree2);
358
359 data = "<l2 xmlns=\"urn:tests:a\"><c><x>b</x></c></l2>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200360 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Michal Vasko26123192020-11-09 21:02:34 +0100361 assert_int_equal(LY_SUCCESS, lyd_dup_single(tree1->next, NULL, 0, &tree2));
Michal Vaskoeaef7c92023-10-17 10:06:15 +0200362 assert_int_equal(LY_SUCCESS, lyd_dup_single(lyd_child(lyd_child(tree1->next)), (struct lyd_node_inner *)tree2,
363 LYD_DUP_WITH_PARENTS, NULL));
Michal Vasko26123192020-11-09 21:02:34 +0100364 assert_int_equal(LY_SUCCESS, lyd_compare_single(tree1->next, tree2, LYD_COMPARE_FULL_RECURSION));
Radek Krejci22ebdba2019-07-25 13:59:43 +0200365 lyd_free_all(tree1);
366 lyd_free_all(tree2);
367
368 /* invalid */
369 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 +0200370 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1);
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100371 assert_int_equal(LY_EINVAL, lyd_dup_single(((struct lyd_node_inner *)tree1)->child->prev,
372 (struct lyd_node_inner *)tree1->next, LYD_DUP_WITH_PARENTS, NULL));
Michal Vasko7a266772024-01-23 11:02:38 +0100373 CHECK_LOG_CTX("None of the duplicated node \"c\" schema parents match the provided parent \"c\".", NULL, 0);
Radek Krejci22ebdba2019-07-25 13:59:43 +0200374 lyd_free_all(tree1);
Radek Krejci22ebdba2019-07-25 13:59:43 +0200375}
376
Michal Vasko38c2ba72020-07-27 14:46:59 +0200377static void
378test_target(void **state)
379{
Michal Vasko38c2ba72020-07-27 14:46:59 +0200380 const struct lyd_node_term *term;
381 struct lyd_node *tree;
382 struct lyxp_expr *exp;
383 struct ly_path *path;
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200384 const char *path_str = "/a:l2[2]/c/d[3]";
Michal Vasko38c2ba72020-07-27 14:46:59 +0200385 const char *data =
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100386 "<l2 xmlns=\"urn:tests:a\"><c>"
387 " <d>a</d>"
388 " </c></l2>"
389 "<l2 xmlns=\"urn:tests:a\"><c>"
390 " <d>a</d>"
391 " <d>b</d>"
392 " <d>b</d>"
393 " <d>c</d>"
394 "</c></l2>"
395 "<l2 xmlns=\"urn:tests:a\"><c>"
396 "</c></l2>";
Michal Vasko38c2ba72020-07-27 14:46:59 +0200397
Radek Iša56ca9e42020-09-08 18:42:00 +0200398 CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree);
Michal Vaskoed725d72021-06-23 12:03:45 +0200399 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 +0100400 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp));
Michal Vaskoed725d72021-06-23 12:03:45 +0200401 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 +0200402 LY_PATH_TARGET_SINGLE, 1, LY_VALUE_JSON, NULL, &path));
Michal Vasko7ee42f32024-01-22 11:34:21 +0100403 assert_int_equal(LY_SUCCESS, lyd_find_target(path, tree, (struct lyd_node **)&term));
Michal Vasko38c2ba72020-07-27 14:46:59 +0200404
Michal Vaskoe78faec2021-04-08 17:24:43 +0200405 const int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM | LYS_ORDBY_USER;
Radek Iša56ca9e42020-09-08 18:42:00 +0200406
407 CHECK_LYSC_NODE(term->schema, NULL, 0, flag, 1, "d", 0, LYS_LEAFLIST, 1, 0, NULL, 0);
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200408 assert_string_equal(lyd_get_value(&term->node), "b");
409 assert_string_equal(lyd_get_value(term->prev), "b");
Michal Vasko38c2ba72020-07-27 14:46:59 +0200410
411 lyd_free_all(tree);
Michal Vasko68b96342024-09-09 15:24:18 +0200412 ly_path_free(path);
Radek Iša56ca9e42020-09-08 18:42:00 +0200413 lyxp_expr_free(UTEST_LYCTX, exp);
Michal Vasko38c2ba72020-07-27 14:46:59 +0200414}
415
Radek Krejcica989142020-11-05 11:32:22 +0100416static void
417test_list_pos(void **state)
418{
Radek Krejcica989142020-11-05 11:32:22 +0100419 const char *data;
420 struct lyd_node *tree;
421
422 data = "<bar xmlns=\"urn:tests:a\">test</bar>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100423 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b></l1>"
424 "<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
425 "<foo xmlns=\"urn:tests:a\">test</foo>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200426 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 +0100427 assert_int_equal(0, lyd_list_pos(tree));
428 assert_int_equal(1, lyd_list_pos(tree->next));
429 assert_int_equal(2, lyd_list_pos(tree->next->next));
430 assert_int_equal(0, lyd_list_pos(tree->next->next->next));
431 lyd_free_all(tree);
432
433 data = "<ll xmlns=\"urn:tests:a\">one</ll>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100434 "<ll xmlns=\"urn:tests:a\">two</ll>"
435 "<ll xmlns=\"urn:tests:a\">three</ll>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200436 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 +0100437 assert_int_equal(1, lyd_list_pos(tree));
438 assert_int_equal(2, lyd_list_pos(tree->next));
439 assert_int_equal(3, lyd_list_pos(tree->next->next));
440 lyd_free_all(tree);
441
442 data = "<ll xmlns=\"urn:tests:a\">one</ll>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100443 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b></l1>"
444 "<ll xmlns=\"urn:tests:a\">two</ll>"
445 "<l1 xmlns=\"urn:tests:a\"><a>two</a><b>two</b></l1>"
446 "<ll xmlns=\"urn:tests:a\">three</ll>"
447 "<l1 xmlns=\"urn:tests:a\"><a>three</a><b>three</b></l1>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200448 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 +0100449 assert_string_equal("l1", tree->schema->name);
450 assert_int_equal(1, lyd_list_pos(tree));
451 assert_int_equal(2, lyd_list_pos(tree->next));
452 assert_int_equal(3, lyd_list_pos(tree->next->next));
453 assert_string_equal("ll", tree->next->next->next->schema->name);
454 assert_int_equal(1, lyd_list_pos(tree->next->next->next));
455 assert_int_equal(2, lyd_list_pos(tree->next->next->next->next));
456 assert_int_equal(3, lyd_list_pos(tree->next->next->next->next->next));
457 lyd_free_all(tree);
Radek Krejcica989142020-11-05 11:32:22 +0100458}
459
Radek Krejci4233f9b2020-11-05 12:38:35 +0100460static void
461test_first_sibling(void **state)
462{
Radek Krejci4233f9b2020-11-05 12:38:35 +0100463 const char *data;
464 struct lyd_node *tree;
465 struct lyd_node_inner *parent;
466
467 data = "<bar xmlns=\"urn:tests:a\">test</bar>"
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100468 "<l1 xmlns=\"urn:tests:a\"><a>one</a><b>one</b><c>one</c></l1>"
469 "<foo xmlns=\"urn:tests:a\">test</foo>";
Radek Iša56ca9e42020-09-08 18:42:00 +0200470 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 +0100471 assert_ptr_equal(tree, lyd_first_sibling(tree->next));
472 assert_ptr_equal(tree, lyd_first_sibling(tree));
473 assert_ptr_equal(tree, lyd_first_sibling(tree->prev));
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100474 parent = (struct lyd_node_inner *)tree->next;
Radek Krejci4233f9b2020-11-05 12:38:35 +0100475 assert_int_equal(LYS_LIST, parent->schema->nodetype);
476 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child->next));
477 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child));
478 assert_ptr_equal(parent->child, lyd_first_sibling(parent->child->prev));
479 lyd_free_all(tree);
Radek Krejci4233f9b2020-11-05 12:38:35 +0100480}
481
Michal Vasko6b669ff2021-04-30 16:25:36 +0200482static void
483test_find_path(void **state)
484{
485 struct lyd_node *root;
486 const struct lys_module *mod;
487
488 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "c");
489 assert_non_null(mod);
490
491 assert_int_equal(LY_SUCCESS, lyd_new_inner(NULL, mod, "cont", 0, &root));
492 assert_int_equal(LY_SUCCESS, lyd_new_path(root, NULL, "/c:cont/nexthop[gateway='10.0.0.1']", NULL, LYD_NEW_PATH_UPDATE, NULL));
493 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 +0200494 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 +0200495
496 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/nexthop[gateway='10.0.0.1']", 0, NULL));
497 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/nexthop[gateway='2100::1']", 0, NULL));
Michal Vasko15dc9fa2021-05-03 14:33:05 +0200498 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "/c:cont/pref[.='fc00::/64']", 0, NULL));
Michal Vasko32ca49b2023-02-17 15:11:35 +0100499
500 assert_int_equal(LY_EVALID, lyd_find_path(root, "/cont", 0, NULL));
Michal Vasko7a266772024-01-23 11:02:38 +0100501 CHECK_LOG_CTX("Prefix missing for \"cont\" in path.", "/c:cont", 0);
Michal Vasko32ca49b2023-02-17 15:11:35 +0100502 assert_int_equal(LY_SUCCESS, lyd_find_path(root, "nexthop[gateway='2100::1']", 0, NULL));
503
Michal Vasko6b669ff2021-04-30 16:25:36 +0200504 lyd_free_all(root);
505}
506
aPiecek4f07c3e2021-06-11 10:53:07 +0200507static void
508test_data_hash(void **state)
509{
510 struct lyd_node *tree;
511 const char *schema, *data;
512
513 schema =
514 "module test-data-hash {"
515 " yang-version 1.1;"
516 " namespace \"urn:tests:tdh\";"
517 " prefix t;"
518 " container c {"
519 " leaf-list ll {"
520 " type string;"
521 " }"
522 " }"
523 "}";
524
525 UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
526
527 /* The number of <ll/> must be greater or equal to LYD_HT_MIN_ITEMS
528 * for the correct test run. It should guarantee the creation of a hash table.
529 */
530 assert_true(LYD_HT_MIN_ITEMS <= 4);
531 data =
532 "<c xmlns='urn:tests:tdh'>"
533 " <ll/>"
534 " <ll/>"
535 " <ll/>"
536 " <ll/>"
537 "</c>";
538
539 /* The run must not crash due to the assert that checks the hash. */
540 CHECK_PARSE_LYD_PARAM(data, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_EVALID, tree);
Michal Vasko7a266772024-01-23 11:02:38 +0100541 CHECK_LOG_CTX("Duplicate instance of \"ll\".", "/test-data-hash:c/ll[.='']", 1);
aPiecek4f07c3e2021-06-11 10:53:07 +0200542 lyd_free_all(tree);
543}
544
aPiecekdf23eee2021-10-07 12:21:50 +0200545static void
546test_lyxp_vars(void **UNUSED(state))
547{
548 struct lyxp_var *vars;
549
550 /* Test free. */
551 vars = NULL;
552 lyxp_vars_free(vars);
553
554 /* Bad arguments for lyxp_vars_add(). */
555 assert_int_equal(LY_EINVAL, lyxp_vars_set(NULL, "var1", "val1"));
556 assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, NULL, "val1"));
557 assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, "var1", NULL));
558 lyxp_vars_free(vars);
559 vars = NULL;
560
561 /* Add one item. */
562 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1"));
563 assert_int_equal(LY_ARRAY_COUNT(vars), 1);
564 assert_string_equal(vars[0].name, "var1");
565 assert_string_equal(vars[0].value, "val1");
566 lyxp_vars_free(vars);
567 vars = NULL;
568
569 /* Add three items. */
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, "var3", "val3"));
573 assert_int_equal(LY_ARRAY_COUNT(vars), 3);
574 assert_string_equal(vars[0].name, "var1");
575 assert_string_equal(vars[0].value, "val1");
576 assert_string_equal(vars[1].name, "var2");
577 assert_string_equal(vars[1].value, "val2");
578 assert_string_equal(vars[2].name, "var3");
579 assert_string_equal(vars[2].value, "val3");
580 lyxp_vars_free(vars);
581 vars = NULL;
582
583 /* Change value of a variable. */
584 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1"));
585 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var2", "val2"));
586 assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "new_value"));
587 assert_string_equal(vars[0].name, "var1");
588 assert_string_equal(vars[0].value, "new_value");
589 assert_string_equal(vars[1].name, "var2");
590 assert_string_equal(vars[1].value, "val2");
591 lyxp_vars_free(vars);
592 vars = NULL;
593}
594
stewegf9041a22024-01-18 13:29:12 +0100595static void
596test_data_leafref_nodes(void **state)
597{
598 struct lyd_node *tree, *iter;
Michal Vasko17d9cea2024-02-09 13:48:40 +0100599 struct lyd_node_term *target_node = NULL, *leafref_node;
stewegf9041a22024-01-18 13:29:12 +0100600 const struct lyd_leafref_links_rec *rec;
601 const char *schema, *data, *value;
602
603 ly_ctx_set_options(UTEST_LYCTX, LY_CTX_LEAFREF_LINKING);
604
605 schema =
606 "module test-data-hash {"
607 " yang-version 1.1;"
608 " namespace \"urn:tests:tdh\";"
609 " prefix t;"
610 " leaf-list ll {"
611 " type string;"
612 " }"
613 " container c1 {"
614 " leaf ref1 {"
615 " type leafref {"
616 " path \"../../ll\";"
617 " }"
618 " }"
619 " }"
620 " leaf ref2 {"
621 " type leafref {"
622 " path \"../ll\";"
623 " }"
624 " }"
625 "}";
626
627 UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
628
629 data =
630 "{"
631 " \"test-data-hash:ll\": [\"qwe\", \"asd\"],"
632 " \"test-data-hash:c1\": { \"ref1\": \"qwe\"},"
633 " \"test-data-hash:ref2\": \"asd\""
634 "}";
635
636 /* The run must not crash due to the assert that checks the hash. */
637 CHECK_PARSE_LYD_PARAM(data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, tree);
638 LY_LIST_FOR(tree, iter) {
639 if (strcmp(iter->schema->name, "ll") == 0) {
640 value = lyd_get_value(iter);
641 if (strcmp(value, "asd") == 0) {
642 target_node = (struct lyd_node_term *)iter;
643 }
644 }
645 if (strcmp(iter->schema->name, "ref2") == 0) {
646 leafref_node = (struct lyd_node_term *)iter;
647 }
648 }
649
650 /* verify state after leafref plugin validation */
651 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node, &rec));
652 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
steweg67388952024-01-25 12:14:50 +0100653 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
stewegf9041a22024-01-18 13:29:12 +0100654 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
steweg67388952024-01-25 12:14:50 +0100655 assert_int_equal(1, LY_ARRAY_COUNT(rec->target_nodes));
656 assert_ptr_equal(rec->target_nodes[0], target_node);
stewegf9041a22024-01-18 13:29:12 +0100657 /* value modification of target */
658 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)target_node, "ASD"));
659 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node, &rec));
660 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(leafref_node, &rec));
661 /* change back to original value */
662 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)target_node, "asd"));
663 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node, &rec));
664 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(leafref_node, &rec));
665 /* linking the whole tree again */
666 assert_int_equal(LY_SUCCESS, lyd_leafref_link_node_tree(tree));
667 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node, &rec));
668 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
steweg67388952024-01-25 12:14:50 +0100669 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
stewegf9041a22024-01-18 13:29:12 +0100670 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
steweg67388952024-01-25 12:14:50 +0100671 assert_int_equal(1, LY_ARRAY_COUNT(rec->target_nodes));
672 assert_ptr_equal(rec->target_nodes[0], target_node);
stewegf9041a22024-01-18 13:29:12 +0100673 /* value modification of leafref */
674 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)leafref_node, "qwe"));
675 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node, &rec));
676 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(leafref_node, &rec));
677 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)leafref_node, "asd"));
678 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node, &rec));
679 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(leafref_node, &rec));
680 /* linking the whole tree again */
681 assert_int_equal(LY_SUCCESS, lyd_leafref_link_node_tree(tree));
682 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node, &rec));
683 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
steweg67388952024-01-25 12:14:50 +0100684 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
stewegf9041a22024-01-18 13:29:12 +0100685 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
steweg67388952024-01-25 12:14:50 +0100686 assert_int_equal(1, LY_ARRAY_COUNT(rec->target_nodes));
687 assert_ptr_equal(rec->target_nodes[0], target_node);
688 /* freeing whole tree */
689 lyd_free_all(tree);
690}
691
692static void
693test_data_leafref_nodes2(void **state)
694{
695 struct lyd_node *tree, *iter;
696 const char *schema, *data;
Michal Vasko17d9cea2024-02-09 13:48:40 +0100697 struct lyd_node_term *leafref_node = NULL;
steweg67388952024-01-25 12:14:50 +0100698 const struct lyd_node_term *target_node1, *target_node2;
699 const struct lyd_leafref_links_rec *rec;
700
701 ly_ctx_set_options(UTEST_LYCTX, LY_CTX_LEAFREF_LINKING);
702
703 schema =
704 "module test-data-hash {"
705 " yang-version 1.1;"
706 " namespace \"urn:tests:tdh\";"
707 " prefix t;"
708 " list l1 {"
709 " key \"l1 l2\";"
710 " leaf l1 {"
711 " type string;"
712 " }"
713 " leaf l2 {"
714 " type string;"
715 " }"
716 " }"
717 " leaf ref1 {"
718 " type leafref {"
719 " path \"../l1/l1\";"
720 " }"
721 " }"
722 " leaf-list ll1 {"
723 " type string;"
724 " config false;"
725 " }"
726 " leaf ref2 {"
727 " type leafref {"
728 " path \"../ll1\";"
729 " }"
730 " config false;"
731 " }"
732 "}";
733
734 UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, NULL);
735
736 data =
737 "{"
738 " \"test-data-hash:l1\": ["
739 " {\"l1\": \"A\", \"l2\": \"B\"},"
740 " {\"l1\": \"A\", \"l2\": \"C\"}"
741 " ],"
742 " \"test-data-hash:ref1\": \"A\","
743 " \"test-data-hash:ll1\": [\"asd\", \"qwe\", \"asd\"],"
744 " \"test-data-hash:ref2\": \"asd\""
745 "}";
746
747 /* The run must not crash due to the assert that checks the hash. */
748 CHECK_PARSE_LYD_PARAM(data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, tree);
749 LY_LIST_FOR(tree, iter) {
750 if (strcmp(iter->schema->name, "ref1") == 0) {
751 leafref_node = (struct lyd_node_term *)iter;
752 }
753 }
754
755 /* verify state after leafref plugin validation */
756 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
757 assert_int_equal(2, LY_ARRAY_COUNT(rec->target_nodes));
758 target_node1 = rec->target_nodes[0];
759 target_node2 = rec->target_nodes[1];
760 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node1, &rec));
761 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
762 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
763 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node2, &rec));
764 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
765 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
766 /* value modification of leafref to remove all links*/
767 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)leafref_node, "qwe"));
768 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(leafref_node, &rec));
769 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node1, &rec));
770 assert_int_equal(LY_ENOTFOUND, lyd_leafref_get_links(target_node2, &rec));
771 /* linking the whole tree again */
772 assert_int_equal(LY_SUCCESS, lyd_change_term((struct lyd_node *)leafref_node, "A"));
773 assert_int_equal(LY_SUCCESS, lyd_leafref_link_node_tree(tree));
774 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
775 assert_int_equal(2, LY_ARRAY_COUNT(rec->target_nodes));
776 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node1, &rec));
777 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
778 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
779 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node2, &rec));
780 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
781 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
782
783 /* verify duplicated value in leaf-list */
784 LY_LIST_FOR(tree, iter) {
785 if (strcmp(iter->schema->name, "ref2") == 0) {
786 leafref_node = (struct lyd_node_term *)iter;
787 }
788 }
789
790 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(leafref_node, &rec));
791 assert_int_equal(2, LY_ARRAY_COUNT(rec->target_nodes));
792 target_node1 = rec->target_nodes[0];
793 target_node2 = rec->target_nodes[1];
794 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node1, &rec));
795 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
796 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
797 assert_int_equal(LY_SUCCESS, lyd_leafref_get_links(target_node2, &rec));
798 assert_int_equal(1, LY_ARRAY_COUNT(rec->leafref_nodes));
799 assert_ptr_equal(rec->leafref_nodes[0], leafref_node);
stewegf9041a22024-01-18 13:29:12 +0100800 /* freeing whole tree */
801 lyd_free_all(tree);
802}
803
Radek Krejcib4ac5a92020-11-23 17:54:33 +0100804int
805main(void)
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200806{
807 const struct CMUnitTest tests[] = {
Radek Iša56ca9e42020-09-08 18:42:00 +0200808 UTEST(test_compare, setup),
aPiecek24252202021-03-30 12:23:32 +0200809 UTEST(test_compare_diff_ctx, setup),
Radek Iša56ca9e42020-09-08 18:42:00 +0200810 UTEST(test_dup, setup),
811 UTEST(test_target, setup),
812 UTEST(test_list_pos, setup),
813 UTEST(test_first_sibling, setup),
Michal Vasko6b669ff2021-04-30 16:25:36 +0200814 UTEST(test_find_path, setup),
aPiecek4f07c3e2021-06-11 10:53:07 +0200815 UTEST(test_data_hash, setup),
aPiecekdf23eee2021-10-07 12:21:50 +0200816 UTEST(test_lyxp_vars),
stewegf9041a22024-01-18 13:29:12 +0100817 UTEST(test_data_leafref_nodes),
steweg67388952024-01-25 12:14:50 +0100818 UTEST(test_data_leafref_nodes2),
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200819 };
820
821 return cmocka_run_group_tests(tests, NULL, NULL);
822}