blob: 8b79a1c2e3e649a819c237e86cc7c6056fa8ae67 [file] [log] [blame]
Radek Iša56ca9e42020-09-08 18:42:00 +02001/*
aPiecek023f83a2021-05-11 07:37:03 +02002 * @file test_context.c
Radek Iša56ca9e42020-09-08 18:42:00 +02003 * @author: Radek Krejci <rkrejci@cesnet.cz>
4 * @brief unit tests for functions from context.c
5 *
6 * Copyright (c) 2018 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 */
14#define _UTEST_MAIN_
15#include "utests.h"
16
17#include "common.h"
18#include "context.h"
19#include "in.h"
20#include "schema_compile.h"
Radek Krejcief5f7672021-04-01 17:04:12 +020021#include "tests_config.h"
Radek Iša56ca9e42020-09-08 18:42:00 +020022#include "tree_schema_internal.h"
23#include "utests.h"
24
Jan Kundrátd5e4ac82021-12-13 18:28:45 +010025#ifdef _WIN32
26static void
27slashes_to_backslashes(char *path)
28{
29 while ((path = strchr(path, '/'))) {
30 *path++ = '\\';
31 }
32}
33
34static void
35test_searchdirs(void **state)
36{
37 const char * const *list;
38 char *path1 = strdup(TESTS_BIN "/utests");
39 char *path2 = strdup(TESTS_SRC);
40
41 slashes_to_backslashes(path1);
42 slashes_to_backslashes(path2);
43
44 assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(NULL, NULL));
45 CHECK_LOG("Invalid argument ctx (ly_ctx_set_searchdir()).", NULL);
46 assert_null(ly_ctx_get_searchdirs(NULL));
47 CHECK_LOG("Invalid argument ctx (ly_ctx_get_searchdirs()).", NULL);
48 assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(NULL, NULL));
49 CHECK_LOG("Invalid argument ctx (ly_ctx_unset_searchdir()).", NULL);
50
51 /* correct path */
52 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path1));
53 assert_int_equal(1, UTEST_LYCTX->search_paths.count);
54 assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[0]);
55
56 /* duplicated paths */
57 assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, path1));
58 assert_int_equal(1, UTEST_LYCTX->search_paths.count);
59 assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[0]);
60
61 /* another path */
62 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path2));
63 assert_int_equal(2, UTEST_LYCTX->search_paths.count);
64 assert_string_equal(path2, UTEST_LYCTX->search_paths.objs[1]);
65
66 /* get searchpaths */
67 list = ly_ctx_get_searchdirs(UTEST_LYCTX);
68 assert_non_null(list);
69 assert_string_equal(path1, list[0]);
70 assert_string_equal(path2, list[1]);
71 assert_null(list[2]);
72
73 /* removing searchpaths */
74 /* nonexisting */
75 assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(UTEST_LYCTX, "/nonexistingfile"));
76 CHECK_LOG_CTX("Invalid argument value (ly_ctx_unset_searchdir()).", NULL);
77
78 /* first */
79 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path1));
80 assert_int_equal(1, UTEST_LYCTX->search_paths.count);
81 assert_string_not_equal(path1, list[0]);
82
83 /* second */
84 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path2));
85 assert_int_equal(0, UTEST_LYCTX->search_paths.count);
86
87 free(path1);
88 free(path2);
89}
90
91#else
92
Radek Iša56ca9e42020-09-08 18:42:00 +020093static void
94test_searchdirs(void **state)
95{
96 const char * const *list;
97
98 /* invalid arguments */
99 assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(NULL, NULL));
100 CHECK_LOG("Invalid argument ctx (ly_ctx_set_searchdir()).", NULL);
101 assert_null(ly_ctx_get_searchdirs(NULL));
102 CHECK_LOG("Invalid argument ctx (ly_ctx_get_searchdirs()).", NULL);
103 assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(NULL, NULL));
104 CHECK_LOG("Invalid argument ctx (ly_ctx_unset_searchdir()).", NULL);
105
106 /* readable and executable, but not a directory */
107 assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utest_context"));
108 CHECK_LOG_CTX("Given search directory \""TESTS_BIN "/utest_context\" is not a directory.", NULL);
Radek Iša56ca9e42020-09-08 18:42:00 +0200109 /* not existing */
110 assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(UTEST_LYCTX, "/nonexistingfile"));
111 CHECK_LOG_CTX("Unable to use search directory \"/nonexistingfile\" (No such file or directory).", NULL);
112
113 /* ly_set_add() fails */
114 /* no change */
115 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, NULL));
116
117 /* correct path */
118 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests"));
119 assert_int_equal(1, UTEST_LYCTX->search_paths.count);
120 assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[0]);
121
122 /* duplicated paths */
123 assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests"));
124 assert_int_equal(1, UTEST_LYCTX->search_paths.count);
125 assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[0]);
126
127 /* another paths - add 8 to fill the initial buffer of the searchpaths list */
128 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/CMakeFiles"));
129 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../src"));
130 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../CMakeModules"));
131 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../doc"));
132 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC));
133 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN));
134 assert_int_equal(7, UTEST_LYCTX->search_paths.count);
135
136 /* get searchpaths */
137 list = ly_ctx_get_searchdirs(UTEST_LYCTX);
138 assert_non_null(list);
139 assert_string_equal(TESTS_BIN "/utests", list[0]);
140 assert_string_equal(TESTS_BIN "/CMakeFiles", list[1]);
141 assert_string_equal(TESTS_SRC, list[5]);
142 assert_string_equal(TESTS_BIN, list[6]);
143 assert_null(list[7]);
144
145 /* removing searchpaths */
146 /* nonexisting */
147 assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(UTEST_LYCTX, "/nonexistingfile"));
148 CHECK_LOG_CTX("Invalid argument value (ly_ctx_unset_searchdir()).", NULL);
149 /* first */
150 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_BIN "/utests"));
151 assert_string_not_equal(TESTS_BIN "/utests", list[0]);
152 assert_int_equal(6, UTEST_LYCTX->search_paths.count);
153 /* middle */
154 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_SRC));
155 assert_int_equal(5, UTEST_LYCTX->search_paths.count);
156 /* last */
157 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_BIN));
158 assert_int_equal(4, UTEST_LYCTX->search_paths.count);
159 /* all */
160 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL));
161 assert_int_equal(0, UTEST_LYCTX->search_paths.count);
162
163 /* again - no change */
164 assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL));
165
166 /* cleanup */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200167 ly_ctx_destroy(UTEST_LYCTX);
Radek Iša56ca9e42020-09-08 18:42:00 +0200168
169 /* test searchdir list in ly_ctx_new() */
170 assert_int_equal(LY_EINVAL, ly_ctx_new("/nonexistingfile", 0, &UTEST_LYCTX));
171 CHECK_LOG("Unable to use search directory \"/nonexistingfile\" (No such file or directory).", NULL);
Jan Kundráta3ea1932021-12-13 18:45:50 +0100172 assert_int_equal(LY_SUCCESS,
173 ly_ctx_new(TESTS_SRC PATH_SEPARATOR TESTS_BIN PATH_SEPARATOR TESTS_BIN PATH_SEPARATOR TESTS_SRC,
174 LY_CTX_DISABLE_SEARCHDIRS, &UTEST_LYCTX));
Radek Iša56ca9e42020-09-08 18:42:00 +0200175 assert_int_equal(2, UTEST_LYCTX->search_paths.count);
176 assert_string_equal(TESTS_SRC, UTEST_LYCTX->search_paths.objs[0]);
177 assert_string_equal(TESTS_BIN, UTEST_LYCTX->search_paths.objs[1]);
178}
179
Jan Kundrátd5e4ac82021-12-13 18:28:45 +0100180#endif
181
Radek Iša56ca9e42020-09-08 18:42:00 +0200182static void
183test_options(void **state)
184{
185 /* use own context with extra flags */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200186 ly_ctx_destroy(UTEST_LYCTX);
Radek Iša56ca9e42020-09-08 18:42:00 +0200187
188 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0xffff, &UTEST_LYCTX));
189
190 /* invalid arguments */
191 assert_int_equal(0, ly_ctx_get_options(NULL));
192 CHECK_LOG("Invalid argument ctx (ly_ctx_get_options()).", NULL);
193
194 assert_int_equal(LY_EINVAL, ly_ctx_set_options(NULL, 0));
195 CHECK_LOG("Invalid argument ctx (ly_ctx_set_options()).", NULL);
196 assert_int_equal(LY_EINVAL, ly_ctx_unset_options(NULL, 0));
197 CHECK_LOG("Invalid argument ctx (ly_ctx_unset_options()).", NULL);
198
Radek Iša56ca9e42020-09-08 18:42:00 +0200199 /* unset */
200 /* LY_CTX_ALL_IMPLEMENTED */
201 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED);
202 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_ALL_IMPLEMENTED));
203 assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED);
204
205 /* LY_CTX_REF_IMPLEMENTED */
206 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED);
207 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_REF_IMPLEMENTED));
208 assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED);
209
210 /* LY_CTX_DISABLE_SEARCHDIRS */
211 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS);
212 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIRS));
213 assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS);
214
215 /* LY_CTX_DISABLE_SEARCHDIR_CWD */
216 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD);
217 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIR_CWD));
218 assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD);
219
220 /* LY_CTX_PREFER_SEARCHDIRS */
221 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS);
222 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_PREFER_SEARCHDIRS));
223 assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS);
224
225 assert_int_equal(UTEST_LYCTX->flags, ly_ctx_get_options(UTEST_LYCTX));
226
227 /* set back */
228 /* LY_CTX_ALL_IMPLEMENTED */
229 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_ALL_IMPLEMENTED));
230 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED);
231
232 /* LY_CTX_REF_IMPLEMENTED */
233 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_REF_IMPLEMENTED));
234 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED);
235
236 /* LY_CTX_DISABLE_SEARCHDIRS */
237 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIRS));
238 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS);
239
240 /* LY_CTX_DISABLE_SEARCHDIR_CWD */
241 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIR_CWD));
242 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD);
243
244 /* LY_CTX_PREFER_SEARCHDIRS */
245 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_PREFER_SEARCHDIRS));
246 assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS);
247
248 assert_int_equal(UTEST_LYCTX->flags, ly_ctx_get_options(UTEST_LYCTX));
249}
250
251static LY_ERR
252test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name),
253 const char *UNUSED(sub_rev), void *user_data, LYS_INFORMAT *format,
254 const char **module_data, void (**free_module_data)(void *model_data, void *user_data))
255{
256 *module_data = user_data;
257 *format = LYS_IN_YANG;
258 *free_module_data = NULL;
259 return LY_SUCCESS;
260}
261
262static void
263test_models(void **state)
264{
265 struct ly_in *in;
266 const char *str;
267 struct lys_module *mod1, *mod2;
268 struct lys_glob_unres unres = {0};
269
270 /* use own context with extra flags */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200271 ly_ctx_destroy(UTEST_LYCTX);
Radek Iša56ca9e42020-09-08 18:42:00 +0200272
273 /* invalid arguments */
Michal Vasko794ab4b2021-03-31 09:42:19 +0200274 assert_int_equal(0, ly_ctx_get_change_count(NULL));
275 CHECK_LOG("Invalid argument ctx (ly_ctx_get_change_count()).", NULL);
Radek Iša56ca9e42020-09-08 18:42:00 +0200276
277 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &UTEST_LYCTX));
Michal Vasko794ab4b2021-03-31 09:42:19 +0200278 assert_int_equal(UTEST_LYCTX->change_count, ly_ctx_get_change_count(UTEST_LYCTX));
Radek Iša56ca9e42020-09-08 18:42:00 +0200279
280 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module x {namespace urn:x;prefix x;}", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200281 assert_int_equal(LY_EINVAL, lys_parse_in(UTEST_LYCTX, in, 4, NULL, NULL, &unres.creating, &mod1));
Michal Vaskof4258e12021-06-15 12:11:42 +0200282 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200283 ly_in_free(in, 0);
284 CHECK_LOG_CTX("Invalid schema input format.", NULL);
285
286 /* import callback */
287 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, (void *)(str = "test"));
288 assert_ptr_equal(test_imp_clb, UTEST_LYCTX->imp_clb);
289 assert_ptr_equal(str, UTEST_LYCTX->imp_clb_data);
290 assert_ptr_equal(test_imp_clb, ly_ctx_get_module_imp_clb(UTEST_LYCTX, (void **)&str));
291 assert_string_equal("test", str);
292
293 ly_ctx_set_module_imp_clb(UTEST_LYCTX, NULL, NULL);
294 assert_null(UTEST_LYCTX->imp_clb);
295 assert_null(UTEST_LYCTX->imp_clb_data);
296
297 /* name collision of module and submodule */
298 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to a {prefix a;} revision 2018-10-30;}");
299 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module y {namespace urn:y;prefix y;include y;}", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200300 assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
Michal Vaskof4258e12021-06-15 12:11:42 +0200301 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200302 ly_in_free(in, 0);
Radek Krejci8297b792020-08-16 14:49:05 +0200303 CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL,
304 "Name collision between module and submodule of name \"y\".", "Line number 1.");
Radek Iša56ca9e42020-09-08 18:42:00 +0200305
306 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module a {namespace urn:a;prefix a;include y;revision 2018-10-30; }", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200307 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
Radek Iša56ca9e42020-09-08 18:42:00 +0200308 ly_in_free(in, 0);
309 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module y {namespace urn:y;prefix y;}", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200310 assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
Michal Vaskof4258e12021-06-15 12:11:42 +0200311 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200312 ly_in_free(in, 0);
Radek Krejci8297b792020-08-16 14:49:05 +0200313 CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL,
314 "Name collision between module and submodule of name \"y\".", "Line number 1.");
Radek Iša56ca9e42020-09-08 18:42:00 +0200315
316 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to b {prefix b;}}");
317 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module b {namespace urn:b;prefix b;include y;}", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200318 assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
Michal Vaskof4258e12021-06-15 12:11:42 +0200319 lys_unres_glob_revert(UTEST_LYCTX, &unres);
320 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200321 ly_in_free(in, 0);
Radek Krejci8297b792020-08-16 14:49:05 +0200322 CHECK_LOG_CTX("Parsing module \"b\" failed.", NULL,
323 "Including \"y\" submodule into \"b\" failed.", NULL,
324 "Parsing submodule failed.", NULL,
Radek Iša56ca9e42020-09-08 18:42:00 +0200325 "Name collision between submodules of name \"y\".", "Line number 1.");
326
327 /* selecting correct revision of the submodules */
328 ly_ctx_reset_latests(UTEST_LYCTX);
329 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to a {prefix a;} revision 2018-10-31;}");
330 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module a {namespace urn:a;prefix a;include y; revision 2018-10-31;}", &in));
Michal Vaskodd992582021-06-10 14:34:57 +0200331 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2));
Michal Vaskof4258e12021-06-15 12:11:42 +0200332 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200333 ly_in_free(in, 0);
334 assert_string_equal("2018-10-31", mod2->parsed->includes[0].submodule->revs[0].date);
335
336 /* reloading module in case only the compiled module resists in the context */
337 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module w {namespace urn:w;prefix w;revision 2018-10-24;}", &in));
Michal Vasko4de7d072021-07-09 09:13:18 +0200338 assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod1));
Radek Iša56ca9e42020-09-08 18:42:00 +0200339 ly_in_free(in, 0);
Radek Iša56ca9e42020-09-08 18:42:00 +0200340 assert_non_null(mod1->compiled);
341 assert_non_null(mod1->parsed);
342
343#if 0
344 /* TODO in case we are able to remove the parsed schema, here we will test how it will handle missing import parsed schema */
345
346 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in));
347 /* mod1->parsed is necessary to compile mod2 because of possible groupings, typedefs, ... */
348 ly_ctx_set_module_imp_clb(UTEST_LYCTX, NULL, NULL);
349 assert_int_equal(LY_ENOTFOUND, lys_create_module(UTEST_LYCTX, in, LYS_IN_YANG, 1, NULL, NULL, &mod2));
350 /*logbuf_assert("Unable to reload \"w\" module to import it into \"z\", source data not found.");*/
351 CHECK_LOG_CTX("Recompilation of module \"w\" failed.", NULL);
352 assert_null(mod2);
353 ly_in_free(in, 0);
354#endif
355
356 assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in));
357 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module w {namespace urn:w;prefix w;revision 2018-10-24;}");
Michal Vasko4de7d072021-07-09 09:13:18 +0200358 assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod2));
Radek Iša56ca9e42020-09-08 18:42:00 +0200359 ly_in_free(in, 0);
360 assert_non_null(mod2);
361 assert_non_null(mod1->parsed);
362 assert_string_equal("w", mod1->name);
363}
364
365static void
366test_imports(void **state)
367{
aPiecekd4911ee2021-07-30 07:40:24 +0200368 struct lys_module *mod1, *mod2, *mod3, *import;
aPiecek9f8c7e72021-07-28 12:01:56 +0200369 char *str;
aPiecekd4911ee2021-07-30 07:40:24 +0200370 uint16_t ctx_options;
Radek Iša56ca9e42020-09-08 18:42:00 +0200371
372 /* use own context with extra flags */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200373 ly_ctx_destroy(UTEST_LYCTX);
aPiecekd4911ee2021-07-30 07:40:24 +0200374 ctx_options = LY_CTX_DISABLE_SEARCHDIRS | LY_CTX_NO_YANGLIBRARY;
Radek Iša56ca9e42020-09-08 18:42:00 +0200375
aPiecekd4911ee2021-07-30 07:40:24 +0200376 /* Import callback provides newer revision of module 'a',
377 * however the older revision is implemented soon and therefore it is preferred. */
378 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX));
Radek Iša56ca9e42020-09-08 18:42:00 +0200379 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module a {namespace urn:a; prefix a; revision 2019-09-17;}");
380 assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module a {namespace urn:a;prefix a;revision 2019-09-16;}",
381 LYS_IN_YANG, &mod1));
aPiecek8ca21bd2021-07-26 14:31:01 +0200382 assert_true(LYS_MOD_LATEST_REV & mod1->latest_revision);
Radek Iša56ca9e42020-09-08 18:42:00 +0200383 assert_int_equal(1, mod1->implemented);
384 assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module b {namespace urn:b;prefix b;import a {prefix a;}}",
385 LYS_IN_YANG, &mod2));
aPiecekd4911ee2021-07-30 07:40:24 +0200386 assert_ptr_equal(mod1, mod2->parsed->imports[0].module);
387 assert_true((LYS_MOD_LATEST_REV | LYS_MOD_IMPORTED_REV) & mod1->latest_revision);
388 assert_string_equal("2019-09-16", mod1->revision);
389 assert_int_equal(1, mod1->implemented);
Radek Iša56ca9e42020-09-08 18:42:00 +0200390 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-16"));
Radek Krejci90ed21e2021-04-12 14:47:46 +0200391 ly_ctx_destroy(UTEST_LYCTX);
Radek Iša56ca9e42020-09-08 18:42:00 +0200392
aPiecekd4911ee2021-07-30 07:40:24 +0200393 /* Import callback provides older revision of module 'a' and it is
394 * imported by another module, so it is preferred even if newer
395 * revision is implemented later. */
396 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX));
397 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module a {namespace urn:a; prefix a; revision 2019-09-16;}");
Radek Iša56ca9e42020-09-08 18:42:00 +0200398 assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module b {namespace urn:b;prefix b;import a {prefix a;}}",
399 LYS_IN_YANG, &mod2));
aPiecekd4911ee2021-07-30 07:40:24 +0200400 assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module a {namespace urn:a;prefix a;revision 2019-09-17;}",
401 LYS_IN_YANG, &mod1));
402 ly_log_level(LY_LLVRB);
403 assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module c {namespace urn:c;prefix c;import a {prefix a;}}",
404 LYS_IN_YANG, &mod3));
405 CHECK_LOG("Implemented module \"a@2019-09-17\" is not used for import, revision \"2019-09-16\" is imported instead.", NULL);
406 ly_log_level(LY_LLWRN);
407 assert_true(LYS_MOD_LATEST_SEARCHDIRS & mod1->latest_revision);
408 assert_int_equal(1, mod1->implemented);
Radek Iša56ca9e42020-09-08 18:42:00 +0200409 import = mod2->parsed->imports[0].module;
aPiecekd4911ee2021-07-30 07:40:24 +0200410 assert_true(LYS_MOD_IMPORTED_REV & import->latest_revision);
411 assert_string_equal("2019-09-16", import->revision);
412 assert_int_equal(0, import->implemented);
413 import = mod3->parsed->imports[0].module;
414 assert_string_equal("2019-09-16", import->revision);
415 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-16"));
416 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-17"));
417 assert_string_equal("2019-09-17", ly_ctx_get_module_implemented(UTEST_LYCTX, "a")->revision);
aPiecek9f8c7e72021-07-28 12:01:56 +0200418 ly_ctx_destroy(UTEST_LYCTX);
419
420 /* check of circular dependency */
aPiecekd4911ee2021-07-30 07:40:24 +0200421 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX));
aPiecek9f8c7e72021-07-28 12:01:56 +0200422 str = "module a {namespace urn:a; prefix a;"
423 "import b {prefix b;}"
424 "}";
425 ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, str);
426 str = "module b { yang-version 1.1; namespace urn:b; prefix b;"
427 "import a {prefix a;}"
428 "}";
429 assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, str, LYS_IN_YANG, NULL));
Radek Iša56ca9e42020-09-08 18:42:00 +0200430}
431
432static void
433test_get_models(void **state)
434{
435 struct lys_module *mod, *mod2;
436 const char *str0 = "module a {namespace urn:a;prefix a;}";
437 const char *str1 = "module a {namespace urn:a;prefix a;revision 2018-10-23;}";
438 const char *str2 = "module a {namespace urn:a;prefix a;revision 2018-10-23;revision 2018-10-24;}";
439 struct ly_in *in0, *in1, *in2;
440 struct lys_glob_unres unres = {0};
441
442 unsigned int index = 0;
Michal Vaskoaac267d2022-01-17 13:34:48 +0100443 const char *names[] = {
444 "ietf-yang-metadata", "yang", "ietf-inet-types", "ietf-yang-types", "ietf-yang-schema-mount",
445 "ietf-datastores", "ietf-yang-library", "a", "a", "a"
446 };
Radek Iša56ca9e42020-09-08 18:42:00 +0200447
448 assert_int_equal(LY_SUCCESS, ly_in_new_memory(str0, &in0));
449 assert_int_equal(LY_SUCCESS, ly_in_new_memory(str1, &in1));
450 assert_int_equal(LY_SUCCESS, ly_in_new_memory(str2, &in2));
451
452 /* invalid arguments */
453 assert_ptr_equal(NULL, ly_ctx_get_module(NULL, NULL, NULL));
454 CHECK_LOG("Invalid argument ctx (ly_ctx_get_module()).", NULL);
455 assert_ptr_equal(NULL, ly_ctx_get_module(UTEST_LYCTX, NULL, NULL));
456 CHECK_LOG_CTX("Invalid argument name (ly_ctx_get_module()).", NULL);
457 assert_ptr_equal(NULL, ly_ctx_get_module_ns(NULL, NULL, NULL));
458 CHECK_LOG("Invalid argument ctx (ly_ctx_get_module_ns()).", NULL);
459 assert_ptr_equal(NULL, ly_ctx_get_module_ns(UTEST_LYCTX, NULL, NULL));
460 CHECK_LOG_CTX("Invalid argument ns (ly_ctx_get_module_ns()).", NULL);
461 assert_null(ly_ctx_get_module(UTEST_LYCTX, "nonsence", NULL));
462
463 /* internal modules */
464 assert_null(ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-yang-types"));
465 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "yang");
466 assert_non_null(mod);
467 assert_non_null(mod->parsed);
468 assert_string_equal("yang", mod->name);
469 mod2 = ly_ctx_get_module_implemented_ns(UTEST_LYCTX, mod->ns);
470 assert_ptr_equal(mod, mod2);
471 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-yang-metadata", "2016-08-05"));
472 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-yang-types", "2013-07-15"));
473 assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-inet-types", "2013-07-15"));
474 assert_non_null(ly_ctx_get_module_ns(UTEST_LYCTX, "urn:ietf:params:xml:ns:yang:ietf-datastores", "2018-02-14"));
475
476 /* select module by revision */
Michal Vasko4de7d072021-07-09 09:13:18 +0200477 assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, &mod));
Radek Iša56ca9e42020-09-08 18:42:00 +0200478 /* invalid attempts - implementing module of the same name and inserting the same module */
Michal Vaskodd992582021-06-10 14:34:57 +0200479 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in2, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2));
Michal Vasko4e205e82021-06-08 14:01:47 +0200480 assert_int_equal(LY_EDENIED, lys_implement(mod2, NULL, &unres));
Michal Vaskofda52ac2022-01-21 14:13:40 +0100481 CHECK_LOG_CTX("Module \"a@2018-10-24\" is already implemented in revision \"2018-10-23\".", NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +0200482 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200483 ly_in_reset(in1);
484 /* it is already there, fine */
Michal Vaskodd992582021-06-10 14:34:57 +0200485 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, NULL, &unres.creating, NULL));
Radek Iša56ca9e42020-09-08 18:42:00 +0200486 /* insert the second module only as imported, not implemented */
Michal Vaskof4258e12021-06-15 12:11:42 +0200487 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200488 ly_in_reset(in2);
Michal Vaskodd992582021-06-10 14:34:57 +0200489 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in2, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2));
Michal Vaskof4258e12021-06-15 12:11:42 +0200490 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200491 assert_non_null(mod2);
492 assert_ptr_not_equal(mod, mod2);
493 mod = ly_ctx_get_module_latest(UTEST_LYCTX, "a");
494 assert_ptr_equal(mod, mod2);
495 mod2 = ly_ctx_get_module_latest_ns(UTEST_LYCTX, mod->ns);
496 assert_ptr_equal(mod, mod2);
497 /* work with module with no revision */
Michal Vaskodd992582021-06-10 14:34:57 +0200498 assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in0, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod));
Michal Vaskof4258e12021-06-15 12:11:42 +0200499 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200500 assert_ptr_equal(mod, ly_ctx_get_module(UTEST_LYCTX, "a", NULL));
501 assert_ptr_not_equal(mod, ly_ctx_get_module_latest(UTEST_LYCTX, "a"));
502
503 str1 = "submodule b {belongs-to a {prefix a;}}";
504 ly_in_free(in1, 0);
505 assert_int_equal(LY_SUCCESS, ly_in_new_memory(str1, &in1));
Michal Vaskodd992582021-06-10 14:34:57 +0200506 assert_int_equal(LY_EINVAL, lys_parse_in(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod));
Radek Iša56ca9e42020-09-08 18:42:00 +0200507 CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +0200508 lys_unres_glob_erase(&unres);
Radek Iša56ca9e42020-09-08 18:42:00 +0200509
510 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(UTEST_LYCTX, &index))) {
511 assert_string_equal(names[index - 1], mod->name);
512 }
Michal Vaskoaac267d2022-01-17 13:34:48 +0100513 assert_int_equal(10, index);
Radek Iša56ca9e42020-09-08 18:42:00 +0200514
515 /* cleanup */
516 ly_in_free(in0, 0);
517 ly_in_free(in1, 0);
518 ly_in_free(in2, 0);
519}
520
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200521static void
522test_ylmem(void **state)
523{
524#define DATA_YANG_LIBRARY_START "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"\
525 " <module-set>\n"\
526 " <name>complete</name>\n"\
527 " <module>\n"\
528 " <name>yang</name>\n"\
529 " <revision>2021-04-07</revision>\n"\
530 " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"\
531 " </module>\n"\
532 " <module>\n"\
533 " <name>ietf-yang-library</name>\n"\
534 " <revision>2019-01-04</revision>\n"\
535 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n"\
536 " </module>\n"
537
538#define DATA_YANG_BASE_IMPORTS " <import-only-module>\n"\
539 " <name>ietf-yang-metadata</name>\n"\
540 " <revision>2016-08-05</revision>\n"\
541 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n"\
542 " </import-only-module>\n"\
543 " <import-only-module>\n"\
544 " <name>ietf-inet-types</name>\n"\
545 " <revision>2013-07-15</revision>\n"\
546 " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n"\
547 " </import-only-module>\n"\
548 " <import-only-module>\n"\
549 " <name>ietf-yang-types</name>\n"\
550 " <revision>2013-07-15</revision>\n"\
551 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n"\
552 " </import-only-module>\n"\
553 " <import-only-module>\n"\
554 " <name>ietf-datastores</name>\n"\
555 " <revision>2018-02-14</revision>\n"\
556 " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n"\
557 " </import-only-module>\n"
558
559#define DATA_YANG_SCHEMA_MODULE_STATE " </module-set>\n"\
560 " <schema>\n"\
561 " <name>complete</name>\n"\
562 " <module-set>complete</module-set>\n"\
563 " </schema>\n"\
564 " <content-id>9</content-id>\n"\
565 "</yang-library>\n"\
566 "<modules-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"\
567 " <module-set-id>12</module-set-id>\n"\
568 " <module>\n"\
569 " <name>ietf-yang-metadata</name>\n"\
570 " <revision>2016-08-05</revision>\n"\
571 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n"\
572 " <conformance-type>import</conformance-type>\n"\
573 " </module>\n"\
574 " <module>\n"\
575 " <name>yang</name>\n"\
576 " <revision>2020-06-17</revision>\n"\
577 " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"\
578 " <conformance-type>implement</conformance-type>\n"\
579 " </module>\n"\
580 " <module>\n"\
581 " <name>ietf-inet-types</name>\n"\
582 " <revision>2013-07-15</revision>\n"\
583 " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n"\
584 " <conformance-type>import</conformance-type>\n"\
585 " </module>\n"\
586 " <module>\n"\
587 " <name>ietf-yang-types</name>\n"\
588 " <revision>2013-07-15</revision>\n"\
589 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n"\
590 " <conformance-type>import</conformance-type>\n"\
591 " </module>\n"\
592 " <module>\n"\
593 " <name>ietf-yang-library</name>\n"\
594 " <revision>2019-01-04</revision>\n"\
595 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n"\
596 " <conformance-type>implement</conformance-type>\n"\
597 " </module>\n"\
598 " <module>\n"\
599 " <name>ietf-datastores</name>\n"\
600 " <revision>2018-02-14</revision>\n"\
601 " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n"\
602 " <conformance-type>import</conformance-type>\n"\
603 " </module>\n"
604
605 const char *yanglibrary_only =
606 DATA_YANG_LIBRARY_START
607 DATA_YANG_BASE_IMPORTS
608 DATA_YANG_SCHEMA_MODULE_STATE
609 "</modules-state>\n";
610
611 const char *with_netconf =
612 DATA_YANG_LIBRARY_START
613 " <module>\n"
614 " <name>ietf-netconf</name>\n"
615 " <revision>2011-06-01</revision>\n"
616 " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n"
617 " </module>\n"
618 DATA_YANG_BASE_IMPORTS
619 " <import-only-module>\n"
620 " <name>ietf-netconf-acm</name>\n"
621 " <revision>2018-02-14</revision>\n"
622 " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n"
623 " </import-only-module>\n"
624 DATA_YANG_SCHEMA_MODULE_STATE
625 " <module>\n"
626 " <name>ietf-netconf</name>\n"
627 " <revision>2011-06-01</revision>\n"
628 " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n"
629 " <conformance-type>implement</conformance-type>\n"
630 " </module>\n"
631 " <module>\n"
632 " <name>ietf-netconf-acm</name>\n"
633 " <revision>2018-02-14</revision>\n"
634 " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n"
635 " <conformance-type>import</conformance-type>\n"
636 " </module>\n"
637 "</modules-state>";
638
Michal Vasko22e0f3a2021-09-22 12:19:23 +0200639 char *with_netconf_features = malloc(8096);
640 strcpy(with_netconf_features,
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200641 DATA_YANG_LIBRARY_START
642 " <module>\n"
643 " <name>ietf-netconf</name>\n"
644 " <revision>2011-06-01</revision>\n"
645 " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n"
646 " <feature>writable-running</feature>\n"
647 " <feature>candidate</feature>\n"
648 " <feature>confirmed-commit</feature>\n"
649 " <feature>rollback-on-error</feature>\n"
650 " <feature>validate</feature>\n"
651 " <feature>startup</feature>\n"
652 " <feature>url</feature>\n"
653 " <feature>xpath</feature>\n"
654 " </module>\n"
655 " <import-only-module>\n"
656 " <name>ietf-yang-metadata</name>\n"
657 " <revision>2016-08-05</revision>\n"
658 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n"
659 " </import-only-module>\n"
660 " <import-only-module>\n"
661 " <name>ietf-inet-types</name>\n"
662 " <revision>2013-07-15</revision>\n"
663 " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n"
664 " </import-only-module>\n"
665 " <import-only-module>\n"
666 " <name>ietf-yang-types</name>\n"
667 " <revision>2013-07-15</revision>\n"
668 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n"
669 " </import-only-module>\n"
670 " <import-only-module>\n"
671 " <name>ietf-datastores</name>\n"
672 " <revision>2018-02-14</revision>\n"
673 " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n"
674 " </import-only-module>\n"
675 " <import-only-module>\n"
676 " <name>ietf-netconf-acm</name>\n"
677 " <revision>2018-02-14</revision>\n"
678 " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n"
Michal Vasko22e0f3a2021-09-22 12:19:23 +0200679 " </import-only-module>\n");
680 strcpy(with_netconf_features + strlen(with_netconf_features),
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200681 DATA_YANG_SCHEMA_MODULE_STATE
682 " <module>\n"
683 " <name>ietf-netconf</name>\n"
684 " <revision>2011-06-01</revision>\n"
685 " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n"
686 " <feature>writable-running</feature>\n"
687 " <feature>candidate</feature>\n"
688 " <feature>confirmed-commit</feature>\n"
689 " <feature>rollback-on-error</feature>\n"
690 " <feature>validate</feature>\n"
691 " <feature>startup</feature>\n"
692 " <feature>url</feature>\n"
693 " <feature>xpath</feature>\n"
694 " <conformance-type>implement</conformance-type>\n"
695 " </module>\n"
696 " <module>\n"
697 " <name>ietf-netconf-acm</name>\n"
698 " <revision>2018-02-14</revision>\n"
699 " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n"
700 " <conformance-type>import</conformance-type>\n"
701 " </module>\n"
Michal Vasko22e0f3a2021-09-22 12:19:23 +0200702 "</modules-state>");
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200703
704 const char *garbage_revision =
705 "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"
706 " <module-set>\n"
707 " <name>complete</name>\n"
708 " <module>\n"
709 " <name>yang</name>\n"
710 " <revision>2020-06-17</revision>\n"
711 " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"
712 " </module>\n"
713 " <module>\n"
714 " <name>ietf-yang-library</name>\n"
715 " <revision>2019-01-01</revision>\n"
716 " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n"
717 " </module>\n"
718 DATA_YANG_BASE_IMPORTS
719 DATA_YANG_SCHEMA_MODULE_STATE
720 "</modules-state>\n";
721
722 const char *no_yanglibrary =
723 "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"
724 " <module-set>\n"
725 " <name>complete</name>\n"
726 " <module>\n"
727 " <name>yang</name>\n"
728 " <revision>2021-04-07</revision>\n"
729 " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"
730 " </module>\n"
731 DATA_YANG_BASE_IMPORTS
732 DATA_YANG_SCHEMA_MODULE_STATE
733 "</modules-state>\n";
734
735 (void) state;
736 /* seperate context to avoid double free during teadown */
737 struct ly_ctx *ctx_test = NULL;
738
739 /* test invalid parameters */
740 assert_int_equal(LY_EINVAL, ly_ctx_new_ylpath(NULL, NULL, LYD_XML, 0, &ctx_test));
741 assert_int_equal(LY_EINVAL, ly_ctx_new_ylpath(NULL, TESTS_SRC, LYD_XML, 0, NULL));
742 assert_int_equal(LY_ESYS, ly_ctx_new_ylpath(NULL, TESTS_SRC "garbage", LYD_XML, 0, &ctx_test));
743
744 /* basic test with ietf-yang-library-only */
745 assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", yanglibrary_only, LYD_XML, 0, &ctx_test));
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200746 assert_non_null(ly_ctx_get_module(ctx_test, "ietf-yang-library", "2019-01-04"));
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200747 assert_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"));
Radek Krejci90ed21e2021-04-12 14:47:46 +0200748 ly_ctx_destroy(ctx_test);
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200749
750 /* test loading module, should also import other module */
751 assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf, LYD_XML, 0, &ctx_test));
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200752 assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"));
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200753 assert_int_equal(1, ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01")->implemented);
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200754 assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14"));
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200755 assert_int_equal(0, ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14")->implemented);
756 assert_int_equal(LY_ENOT, lys_feature_value(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"), "url"));
Radek Krejci90ed21e2021-04-12 14:47:46 +0200757 ly_ctx_destroy(ctx_test);
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200758
759 /* test loading module with feature if they are present */
760 assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf_features, LYD_XML, 0, &ctx_test));
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200761 assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"));
762 assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14"));
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200763 assert_int_equal(LY_SUCCESS, lys_feature_value(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"), "url"));
Radek Krejci90ed21e2021-04-12 14:47:46 +0200764 ly_ctx_destroy(ctx_test);
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200765
766 /* test with not matching revision */
767 assert_int_equal(LY_EINVAL, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", garbage_revision, LYD_XML, 0, &ctx_test));
768
769 /* test data containing ietf-yang-library which conflicts with the option */
770 assert_int_equal(LY_EINVAL, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf_features, LYD_XML, LY_CTX_NO_YANGLIBRARY, &ctx_test));
771
772 /* test creating without ietf-yang-library */
773 assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", no_yanglibrary, LYD_XML, LY_CTX_NO_YANGLIBRARY, &ctx_test));
774 assert_int_equal(NULL, ly_ctx_get_module(ctx_test, "ietf-yang-library", "2019-01-04"));
Radek Krejci90ed21e2021-04-12 14:47:46 +0200775 ly_ctx_destroy(ctx_test);
Michal Vasko22e0f3a2021-09-22 12:19:23 +0200776 free(with_netconf_features);
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +0200777}
778
aPiecekbb96b802021-04-12 08:12:52 +0200779static LY_ERR
780check_node_priv_parsed_is_set(struct lysc_node *node, void *data, ly_bool *UNUSED(dfs_continue))
781{
782 const struct lysp_node *pnode;
783 const char ***iter;
784
785 pnode = (const struct lysp_node *)node->priv;
786 CHECK_POINTER(pnode, 1);
787 iter = (const char ***)data;
788 CHECK_POINTER(**iter, 1);
789 CHECK_STRING(pnode->name, **iter);
790 (*iter)++;
791
792 return LY_SUCCESS;
793}
794
795static LY_ERR
796check_node_priv_parsed_not_set(struct lysc_node *node, void *UNUSED(data), ly_bool *UNUSED(dfs_continue))
797{
798 CHECK_POINTER(node->priv, 0);
799 return LY_SUCCESS;
800}
801
aPiecekfcfec0f2021-04-23 12:47:30 +0200802static void
803check_ext_instance_priv_parsed_is_set(struct lysc_ext_instance *ext)
804{
805 LY_ARRAY_COUNT_TYPE u, v;
806 struct lysc_ext_substmt *substmts;
807 struct lysc_node *cnode;
808 const char **iter;
809 const char *check[] = {
810 "tmp_cont", "lf", NULL
811 };
812
813 LY_ARRAY_FOR(ext, u) {
814 substmts = ext[u].substmts;
815 LY_ARRAY_FOR(substmts, v) {
816 if (substmts && substmts[v].storage && LY_STMT_IS_NODE(substmts[v].stmt)) {
817 cnode = *(struct lysc_node **)substmts[v].storage;
818 iter = check;
819 assert_int_equal(LY_SUCCESS, lysc_tree_dfs_full(cnode, check_node_priv_parsed_is_set, &iter));
820 }
821 }
822 }
823}
824
825static void
826check_ext_instance_priv_parsed_not_set(struct lysc_ext_instance *ext)
827{
828 LY_ARRAY_COUNT_TYPE u, v;
829 struct lysc_ext_substmt *substmts;
830 struct lysc_node *cnode;
831
832 LY_ARRAY_FOR(ext, u) {
833 substmts = ext[u].substmts;
834 LY_ARRAY_FOR(substmts, v) {
835 if (substmts && substmts[v].storage && LY_STMT_IS_NODE(substmts[v].stmt)) {
836 cnode = *(struct lysc_node **)substmts[v].storage;
837 if (cnode) {
838 CHECK_POINTER((struct lysp_node *)cnode->priv, 0);
839 }
840 }
841 }
842 }
843}
844
aPiecekbb96b802021-04-12 08:12:52 +0200845/**
846 * @brief Testing of LY_CTX_SET_PRIV_PARSED.
847 */
848static void
849test_set_priv_parsed(void **state)
850{
Michal Vasko4de7d072021-07-09 09:13:18 +0200851 struct lys_module *mod;
aPiecekbb96b802021-04-12 08:12:52 +0200852 const char *schema_a;
853 const char **iter;
854 const char *check[] = {
855 "cont", "contnotif", "augleaf", "contx", "grpleaf", "l1",
856 "l1a", "l1b", "l1c", "foo1", "ll", "any", "l2",
857 "l2c", "l2cx", "ch", "cas", "casx", "oper",
858 "input", "inparam", "output", "outparam", "n1", NULL
859 };
860
861 /* each node must have a unique name. */
862 schema_a = "module a {\n"
863 " namespace urn:tests:a;\n"
864 " prefix a;yang-version 1.1;\n"
aPiecekfcfec0f2021-04-23 12:47:30 +0200865 "\n"
866 " import ietf-restconf {\n"
867 " prefix rc;\n"
868 " revision-date 2017-01-26;\n"
869 " }\n"
870 "\n"
871 " rc:yang-data \"tmp\" {\n"
872 " container tmp_cont {\n"
873 " leaf lf {\n"
874 " type string;\n"
875 " }\n"
876 " }\n"
877 " }\n"
aPiecekbb96b802021-04-12 08:12:52 +0200878 " container cont {\n"
879 " notification contnotif;\n"
880 " leaf-list contx {\n"
881 " type string;\n"
882 " }\n"
883 " uses grp;\n"
884 " }\n"
885 " list l1 {\n"
886 " key \"l1a l1b\";\n"
887 " leaf l1a {\n"
888 " type string;\n"
889 " }\n"
890 " leaf l1b {\n"
891 " type string;\n"
892 " }\n"
893 " leaf l1c {\n"
894 " type string;\n"
895 " }\n"
896 " }\n"
897 " feature f1;\n"
898 " feature f2;\n"
899 " leaf foo1 {\n"
900 " type uint16;\n"
901 " if-feature f1;\n"
902 " }\n"
903 " leaf foo2 {\n"
904 " type uint16;\n"
905 " }\n"
906 " leaf foo3 {\n"
907 " type uint16;\n"
908 " if-feature f2;\n"
909 " }\n"
910 " leaf-list ll {\n"
911 " type string;\n"
912 " }\n"
913 " anydata any {\n"
914 " config false;\n"
915 " }\n"
916 " list l2 {\n"
917 " config false;\n"
918 " container l2c {\n"
919 " leaf l2cx {\n"
920 " type string;\n"
921 " }\n"
922 " }\n"
923 " }\n"
924 " choice ch {\n"
925 " case cas {\n"
926 " leaf casx {\n"
927 " type string;\n"
928 " }\n"
929 " }\n"
930 " }\n"
931 " rpc oper {\n"
932 " input {\n"
933 " leaf inparam {\n"
934 " type string;\n"
935 " }\n"
936 " }\n"
937 " output {\n"
938 " leaf outparam {\n"
939 " type int8;\n"
940 " }\n"
941 " }\n"
942 " }\n"
943 " notification n1;\n"
944 " grouping grp {\n"
945 " leaf grpleaf {\n"
946 " type uint16;\n"
947 " }\n"
948 " }\n"
949 " augment /cont {\n"
950 " leaf augleaf {\n"
951 " type uint16;\n"
952 " }\n"
953 " }\n"
954 " deviation /a:foo2 {\n"
955 " deviate not-supported;\n"
956 " }\n"
957 "}\n";
958
959 /* use own context with extra flags */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200960 ly_ctx_destroy(UTEST_LYCTX);
aPiecekbb96b802021-04-12 08:12:52 +0200961 const char *feats[] = {"f1", NULL};
Radek Krejciddbc4812021-04-13 21:18:02 +0200962
aPiecekbb96b802021-04-12 08:12:52 +0200963 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_SET_PRIV_PARSED, &UTEST_LYCTX));
aPiecekfcfec0f2021-04-23 12:47:30 +0200964 assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG));
965 assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-restconf", "2017-01-26", NULL));
aPiecekbb96b802021-04-12 08:12:52 +0200966 UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, feats, NULL);
967
968 print_message("[ ] create context\n");
969 mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL);
970 iter = check;
971 assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_is_set, &iter));
aPiecekfcfec0f2021-04-23 12:47:30 +0200972 check_ext_instance_priv_parsed_is_set(mod->compiled->exts);
aPiecekbb96b802021-04-12 08:12:52 +0200973
974 print_message("[ ] unset option\n");
975 assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_SET_PRIV_PARSED));
976 mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL);
977 iter = check;
978 assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_not_set, &iter));
aPiecekfcfec0f2021-04-23 12:47:30 +0200979 check_ext_instance_priv_parsed_not_set(mod->compiled->exts);
aPiecekbb96b802021-04-12 08:12:52 +0200980
981 print_message("[ ] set option\n");
982 assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_SET_PRIV_PARSED));
983 mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL);
984 iter = check;
985 assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_is_set, &iter));
aPiecekfcfec0f2021-04-23 12:47:30 +0200986 check_ext_instance_priv_parsed_is_set(mod->compiled->exts);
aPiecekbb96b802021-04-12 08:12:52 +0200987}
988
Michal Vasko01db7de2021-04-16 12:23:30 +0200989static void
990test_explicit_compile(void **state)
991{
992 uint32_t i;
Michal Vasko4de7d072021-07-09 09:13:18 +0200993 struct lys_module *mod;
Michal Vasko01db7de2021-04-16 12:23:30 +0200994 const char *schema_a = "module a {\n"
995 " namespace urn:tests:a;\n"
996 " prefix a;yang-version 1.1;\n"
997 " feature f1;\n"
998 " feature f2;\n"
999 " leaf foo1 {\n"
1000 " type uint16;\n"
1001 " if-feature f1;\n"
1002 " }\n"
1003 " leaf foo2 {\n"
1004 " type uint16;\n"
1005 " }\n"
1006 " container cont {\n"
1007 " leaf foo3 {\n"
1008 " type string;\n"
1009 " }\n"
1010 " }\n"
1011 "}\n";
1012 const char *schema_b = "module b {\n"
1013 " namespace urn:tests:b;\n"
1014 " prefix b;yang-version 1.1;\n"
1015 " import a {\n"
1016 " prefix a;\n"
1017 " }\n"
1018 " augment /a:cont {\n"
1019 " leaf augleaf {\n"
1020 " type uint16;\n"
1021 " }\n"
1022 " }\n"
1023 "}\n";
1024 const char *schema_c = "module c {\n"
1025 " namespace urn:tests:c;\n"
1026 " prefix c;yang-version 1.1;\n"
1027 " import a {\n"
1028 " prefix a;\n"
1029 " }\n"
1030 " deviation /a:foo2 {\n"
1031 " deviate not-supported;\n"
1032 " }\n"
1033 "}\n";
1034
1035 /* use own context with extra flags */
1036 ly_ctx_destroy(UTEST_LYCTX);
1037 const char *feats[] = {"f1", NULL};
1038
1039 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_EXPLICIT_COMPILE, &UTEST_LYCTX));
1040 UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, &mod);
1041 UTEST_ADD_MODULE(schema_b, LYS_IN_YANG, NULL, NULL);
1042 UTEST_ADD_MODULE(schema_c, LYS_IN_YANG, NULL, NULL);
1043 assert_int_equal(LY_SUCCESS, lys_set_implemented((struct lys_module *)mod, feats));
1044
Michal Vaskodd992582021-06-10 14:34:57 +02001045 /* none of the modules should be compiled */
Michal Vasko01db7de2021-04-16 12:23:30 +02001046 i = 0;
1047 while ((mod = ly_ctx_get_module_iter(UTEST_LYCTX, &i))) {
Michal Vaskodd992582021-06-10 14:34:57 +02001048 assert_null(mod->compiled);
Michal Vasko01db7de2021-04-16 12:23:30 +02001049 }
1050
1051 assert_int_equal(LY_SUCCESS, ly_ctx_compile(UTEST_LYCTX));
1052
1053 /* check internal modules */
1054 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "yang");
1055 assert_non_null(mod);
1056 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-datastores");
1057 assert_non_null(mod);
1058 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-yang-library");
1059 assert_non_null(mod);
1060
1061 /* check test modules */
1062 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "a");
1063 assert_non_null(mod);
1064 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "b");
1065 assert_non_null(mod);
1066 mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "c");
1067 assert_non_null(mod);
1068}
1069
Radek Iša56ca9e42020-09-08 18:42:00 +02001070int
1071main(void)
1072{
1073 const struct CMUnitTest tests[] = {
1074 UTEST(test_searchdirs),
1075 UTEST(test_options),
1076 UTEST(test_models),
1077 UTEST(test_imports),
1078 UTEST(test_get_models),
Tadeáš Vintrlíkea268182021-04-07 13:53:32 +02001079 UTEST(test_ylmem),
aPiecekbb96b802021-04-12 08:12:52 +02001080 UTEST(test_set_priv_parsed),
Michal Vasko01db7de2021-04-16 12:23:30 +02001081 UTEST(test_explicit_compile),
Radek Iša56ca9e42020-09-08 18:42:00 +02001082 };
1083
1084 return cmocka_run_group_tests(tests, NULL, NULL);
1085}