blob: 90fb86fa0ca8b3d7c47f38ce961d471c2a4d9d85 [file] [log] [blame]
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001/*
2 * @file test_parser_yang.c
3 * @author: Radek Krejci <rkrejci@cesnet.cz>
4 * @brief unit tests for functions from parser_yang.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
Radek Krejcidd4e8d42018-10-16 14:55:43 +020015#include <stdarg.h>
16#include <stddef.h>
17#include <setjmp.h>
18#include <cmocka.h>
19
20#include <stdio.h>
21#include <string.h>
22
Radek Krejci2d7a47b2019-05-16 13:34:10 +020023#include "../../src/common.h"
24#include "../../src/tree_schema_internal.h"
25#include "../../src/xpath.h"
Radek Krejcia1911222019-07-22 17:24:50 +020026#include "../../src/plugins_types.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020027
28void lysc_feature_free(struct ly_ctx *ctx, struct lysc_feature *feat);
David Sedlák1b623122019-08-05 15:27:49 +020029void lys_parser_ctx_free(struct lys_parser_ctx *ctx);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020030
31LY_ERR lys_path_token(const char **path, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len,
32 int *parent_times, int *has_predicate);
Radek Krejcidd4e8d42018-10-16 14:55:43 +020033
34#define BUFSIZE 1024
35char logbuf[BUFSIZE] = {0};
36
37/* set to 0 to printing error messages to stderr instead of checking them in code */
38#define ENABLE_LOGGER_CHECKING 1
39
40#if ENABLE_LOGGER_CHECKING
41static void
42logger(LY_LOG_LEVEL level, const char *msg, const char *path)
43{
44 (void) level; /* unused */
45
Radek Krejci87616bb2018-10-31 13:30:52 +010046 if (path && path[0]) {
Radek Krejcidd4e8d42018-10-16 14:55:43 +020047 snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
48 } else {
49 strncpy(logbuf, msg, BUFSIZE - 1);
50 }
51}
52#endif
53
54static int
55logger_setup(void **state)
56{
57 (void) state; /* unused */
58#if ENABLE_LOGGER_CHECKING
59 ly_set_log_clb(logger, 1);
60#endif
61 return 0;
62}
63
Radek Krejci4f28eda2018-11-12 11:46:16 +010064static int
65logger_teardown(void **state)
66{
67 (void) state; /* unused */
68#if ENABLE_LOGGER_CHECKING
69 if (*state) {
70 fprintf(stderr, "%s\n", logbuf);
71 }
72#endif
73 return 0;
74}
75
Radek Krejcidd4e8d42018-10-16 14:55:43 +020076void
77logbuf_clean(void)
78{
79 logbuf[0] = '\0';
80}
81
82#if ENABLE_LOGGER_CHECKING
Radek Krejci16c0f822018-11-16 10:46:10 +010083# define logbuf_assert(str) assert_string_equal(logbuf, str);logbuf_clean()
Radek Krejcidd4e8d42018-10-16 14:55:43 +020084#else
85# define logbuf_assert(str)
86#endif
87
Radek Krejcid05cbd92018-12-05 14:26:40 +010088static LY_ERR test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name),
89 const char *UNUSED(sub_rev), void *user_data, LYS_INFORMAT *format,
90 const char **module_data, void (**free_module_data)(void *model_data, void *user_data))
91{
92 *module_data = user_data;
93 *format = LYS_IN_YANG;
94 *free_module_data = NULL;
95 return LY_SUCCESS;
96}
97
Radek Krejcidd4e8d42018-10-16 14:55:43 +020098static void
David Sedlák1b623122019-08-05 15:27:49 +020099reset_mod(struct lys_module *module)
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100100{
David Sedlák1b623122019-08-05 15:27:49 +0200101 struct ly_ctx *ctx = module->ctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100102 lysc_module_free(module->compiled, NULL);
103 lysp_module_free(module->parsed);
104
David Sedlák1b623122019-08-05 15:27:49 +0200105 FREE_STRING(ctx, module->name);
106 FREE_STRING(ctx, module->ns);
107 FREE_STRING(ctx, module->prefix);
108 FREE_STRING(ctx, module->filepath);
109 FREE_STRING(ctx, module->org);
110 FREE_STRING(ctx, module->contact);
111 FREE_STRING(ctx, module->dsc);
112 FREE_STRING(ctx, module->ref);
113 FREE_ARRAY(ctx, module->off_features, lysc_feature_free);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100114
115 memset(module, 0, sizeof *module);
116 module->ctx = ctx;
Radek Krejci096235c2019-01-11 11:12:19 +0100117 module->implemented = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100118}
119
120static void
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200121test_module(void **state)
122{
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100123 *state = test_module;
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200124
125 const char *str;
David Sedlák1b623122019-08-05 15:27:49 +0200126 struct lys_parser_ctx *ctx = NULL;
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200127 struct lys_module mod = {0};
Radek Krejci151a5b72018-10-19 14:21:44 +0200128 struct lysc_feature *f;
129 struct lysc_iffeature *iff;
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200130
131 str = "module test {namespace urn:test; prefix t;"
Radek Krejci151a5b72018-10-19 14:21:44 +0200132 "feature f1;feature f2 {if-feature f1;}}";
David Sedlák1b623122019-08-05 15:27:49 +0200133 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &mod.ctx));
134 reset_mod(&mod);
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200135
Radek Krejcif8f882a2018-10-31 14:51:15 +0100136 assert_int_equal(LY_EINVAL, lys_compile(NULL, 0));
137 logbuf_assert("Invalid argument mod (lys_compile()).");
138 assert_int_equal(LY_EINVAL, lys_compile(&mod, 0));
139 logbuf_assert("Invalid argument mod->parsed (lys_compile()).");
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100140 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, str, &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200141 lys_parser_ctx_free(ctx);
Radek Krejci096235c2019-01-11 11:12:19 +0100142 mod.implemented = 0;
143 assert_int_equal(LY_SUCCESS, lys_compile(&mod, 0));
144 assert_null(mod.compiled);
145 mod.implemented = 1;
Radek Krejcif8f882a2018-10-31 14:51:15 +0100146 assert_int_equal(LY_SUCCESS, lys_compile(&mod, 0));
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200147 assert_non_null(mod.compiled);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100148 assert_string_equal("test", mod.name);
149 assert_string_equal("urn:test", mod.ns);
150 assert_string_equal("t", mod.prefix);
Radek Krejci151a5b72018-10-19 14:21:44 +0200151 /* features */
152 assert_non_null(mod.compiled->features);
153 assert_int_equal(2, LY_ARRAY_SIZE(mod.compiled->features));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200154 f = &mod.compiled->features[1];
Radek Krejci151a5b72018-10-19 14:21:44 +0200155 assert_non_null(f->iffeatures);
156 assert_int_equal(1, LY_ARRAY_SIZE(f->iffeatures));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200157 iff = &f->iffeatures[0];
Radek Krejci151a5b72018-10-19 14:21:44 +0200158 assert_non_null(iff->expr);
159 assert_non_null(iff->features);
160 assert_int_equal(1, LY_ARRAY_SIZE(iff->features));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200161 assert_ptr_equal(&mod.compiled->features[0], iff->features[0]);
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200162
Radek Krejci86d106e2018-10-18 09:53:19 +0200163 lysc_module_free(mod.compiled, NULL);
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200164
Radek Krejcif8f882a2018-10-31 14:51:15 +0100165 assert_int_equal(LY_SUCCESS, lys_compile(&mod, LYSC_OPT_FREE_SP));
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200166 assert_non_null(mod.compiled);
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200167
Radek Krejci86d106e2018-10-18 09:53:19 +0200168 lysc_module_free(mod.compiled, NULL);
169 mod.compiled = NULL;
170
Radek Krejci151a5b72018-10-19 14:21:44 +0200171 /* submodules cannot be compiled directly */
Radek Krejci86d106e2018-10-18 09:53:19 +0200172 str = "submodule test {belongs-to xxx {prefix x;}}";
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100173 assert_int_equal(LY_EINVAL, yang_parse_module(&ctx, str, &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200174 lys_parser_ctx_free(ctx);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100175 logbuf_assert("Input data contains submodule which cannot be parsed directly without its main module.");
176 assert_null(mod.parsed);
David Sedlák1b623122019-08-05 15:27:49 +0200177 reset_mod(&mod);
Radek Krejci76b3e962018-12-14 17:01:25 +0100178
179 /* data definition name collision in top level */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100180 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module aa {namespace urn:aa;prefix aa;"
181 "leaf a {type string;} container a{presence x;}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200182 lys_parser_ctx_free(ctx);
Radek Krejci76b3e962018-12-14 17:01:25 +0100183 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200184 logbuf_assert("Duplicate identifier \"a\" of data definition/RPC/action/Notification statement. /aa:a");
Radek Krejci76b3e962018-12-14 17:01:25 +0100185 assert_null(mod.compiled);
David Sedlák1b623122019-08-05 15:27:49 +0200186 reset_mod(&mod);
Radek Krejci76b3e962018-12-14 17:01:25 +0100187
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100188 *state = NULL;
David Sedlák1b623122019-08-05 15:27:49 +0200189 ly_ctx_destroy(mod.ctx, NULL);
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200190}
191
Radek Krejci151a5b72018-10-19 14:21:44 +0200192static void
193test_feature(void **state)
194{
Radek Krejcid05cbd92018-12-05 14:26:40 +0100195 *state = test_feature;
Radek Krejci151a5b72018-10-19 14:21:44 +0200196
David Sedlák1b623122019-08-05 15:27:49 +0200197 struct lys_parser_ctx *ctx = NULL;
Radek Krejci1aefdf72018-11-01 11:01:39 +0100198 struct lys_module mod = {0}, *modp;
Radek Krejci151a5b72018-10-19 14:21:44 +0200199 const char *str;
200 struct lysc_feature *f, *f1;
201
202 str = "module a {namespace urn:a;prefix a;yang-version 1.1;\n"
203 "feature f1 {description test1;reference test2;status current;} feature f2; feature f3;\n"
Radek Krejci87616bb2018-10-31 13:30:52 +0100204 "feature orfeature {if-feature \"f1 or f2\";}\n"
205 "feature andfeature {if-feature \"f1 and f2\";}\n"
Radek Krejci151a5b72018-10-19 14:21:44 +0200206 "feature f6 {if-feature \"not f1\";}\n"
Radek Krejcidde18c52018-10-24 14:43:04 +0200207 "feature f7 {if-feature \"(f2 and f3) or (not f1)\";}\n"
Radek Krejci87616bb2018-10-31 13:30:52 +0100208 "feature f8 {if-feature \"f1 or f2 or f3 or orfeature or andfeature\";}\n"
209 "feature f9 {if-feature \"not not f1\";}}";
Radek Krejci151a5b72018-10-19 14:21:44 +0200210
David Sedlák1b623122019-08-05 15:27:49 +0200211 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &mod.ctx));
212 reset_mod(&mod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100213
214 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, str, &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200215 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100216 assert_int_equal(LY_SUCCESS, lys_compile(&mod, 0));
Radek Krejci151a5b72018-10-19 14:21:44 +0200217 assert_non_null(mod.compiled);
218 assert_non_null(mod.compiled->features);
Radek Krejci87616bb2018-10-31 13:30:52 +0100219 assert_int_equal(9, LY_ARRAY_SIZE(mod.compiled->features));
Radek Krejci151a5b72018-10-19 14:21:44 +0200220 /* all features are disabled by default */
221 LY_ARRAY_FOR(mod.compiled->features, struct lysc_feature, f) {
222 assert_int_equal(0, lysc_feature_value(f));
223 }
224 /* enable f1 */
225 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "f1"));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200226 f1 = &mod.compiled->features[0];
Radek Krejci151a5b72018-10-19 14:21:44 +0200227 assert_int_equal(1, lysc_feature_value(f1));
228
Radek Krejci87616bb2018-10-31 13:30:52 +0100229 /* enable orfeature */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200230 f = &mod.compiled->features[3];
Radek Krejci151a5b72018-10-19 14:21:44 +0200231 assert_int_equal(0, lysc_feature_value(f));
Radek Krejci87616bb2018-10-31 13:30:52 +0100232 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "orfeature"));
Radek Krejci151a5b72018-10-19 14:21:44 +0200233 assert_int_equal(1, lysc_feature_value(f));
234
Radek Krejci87616bb2018-10-31 13:30:52 +0100235 /* enable andfeature - no possible since f2 is disabled */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200236 f = &mod.compiled->features[4];
Radek Krejci151a5b72018-10-19 14:21:44 +0200237 assert_int_equal(0, lysc_feature_value(f));
Radek Krejci87616bb2018-10-31 13:30:52 +0100238 assert_int_equal(LY_EDENIED, lys_feature_enable(&mod, "andfeature"));
239 logbuf_assert("Feature \"andfeature\" cannot be enabled since it is disabled by its if-feature condition(s).");
Radek Krejci151a5b72018-10-19 14:21:44 +0200240 assert_int_equal(0, lysc_feature_value(f));
241
242 /* first enable f2, so f5 can be enabled then */
243 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "f2"));
Radek Krejci87616bb2018-10-31 13:30:52 +0100244 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "andfeature"));
Radek Krejci151a5b72018-10-19 14:21:44 +0200245 assert_int_equal(1, lysc_feature_value(f));
246
247 /* f1 is enabled, so f6 cannot be enabled */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200248 f = &mod.compiled->features[5];
Radek Krejci151a5b72018-10-19 14:21:44 +0200249 assert_int_equal(0, lysc_feature_value(f));
250 assert_int_equal(LY_EDENIED, lys_feature_enable(&mod, "f6"));
251 logbuf_assert("Feature \"f6\" cannot be enabled since it is disabled by its if-feature condition(s).");
252 assert_int_equal(0, lysc_feature_value(f));
253
Radek Krejci87616bb2018-10-31 13:30:52 +0100254 /* so disable f1 - andfeature will became also disabled */
Radek Krejci151a5b72018-10-19 14:21:44 +0200255 assert_int_equal(1, lysc_feature_value(f1));
Radek Krejci151a5b72018-10-19 14:21:44 +0200256 assert_int_equal(LY_SUCCESS, lys_feature_disable(&mod, "f1"));
257 assert_int_equal(0, lysc_feature_value(f1));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200258 assert_int_equal(0, lysc_feature_value(&mod.compiled->features[4]));
Radek Krejci87616bb2018-10-31 13:30:52 +0100259 /* while orfeature is stille enabled */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200260 assert_int_equal(1, lysc_feature_value(&mod.compiled->features[3]));
Radek Krejci151a5b72018-10-19 14:21:44 +0200261 /* and finally f6 can be enabled */
Radek Krejci151a5b72018-10-19 14:21:44 +0200262 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "f6"));
Radek Krejci2c4e7172018-10-19 15:56:26 +0200263 assert_int_equal(1, lysc_feature_value(&mod.compiled->features[5]));
Radek Krejci151a5b72018-10-19 14:21:44 +0200264
265 /* complex evaluation of f7: f1 and f3 are disabled, while f2 is enabled */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200266 assert_int_equal(1, lysc_iffeature_value(&mod.compiled->features[6].iffeatures[0]));
Radek Krejcidde18c52018-10-24 14:43:04 +0200267 /* long evaluation of f8 to need to reallocate internal stack for operators */
268 assert_int_equal(1, lysc_iffeature_value(&mod.compiled->features[7].iffeatures[0]));
Radek Krejci151a5b72018-10-19 14:21:44 +0200269
Radek Krejci87616bb2018-10-31 13:30:52 +0100270 /* double negation of disabled f1 -> disabled */
271 assert_int_equal(0, lysc_iffeature_value(&mod.compiled->features[8].iffeatures[0]));
272
Radek Krejci38920282018-11-01 09:24:16 +0100273 /* disable all features */
274 assert_int_equal(LY_SUCCESS, lys_feature_disable(&mod, "*"));
275 LY_ARRAY_FOR(mod.compiled->features, struct lysc_feature, f) {
276 assert_int_equal(0, lys_feature_value(&mod, f->name));
277 }
278 /* re-setting already set feature */
279 assert_int_equal(LY_SUCCESS, lys_feature_disable(&mod, "f1"));
280 assert_int_equal(0, lys_feature_value(&mod, "f1"));
281
282 /* enabling feature that cannot be enabled due to its if-features */
Radek Krejci1aefdf72018-11-01 11:01:39 +0100283 assert_int_equal(LY_SUCCESS, lys_feature_enable(&mod, "f1"));
284 assert_int_equal(LY_EDENIED, lys_feature_enable(&mod, "andfeature"));
285 logbuf_assert("Feature \"andfeature\" cannot be enabled since it is disabled by its if-feature condition(s).");
Radek Krejcica3db002018-11-01 10:31:01 +0100286 assert_int_equal(LY_EDENIED, lys_feature_enable(&mod, "*"));
287 logbuf_assert("Feature \"f6\" cannot be enabled since it is disabled by its if-feature condition(s).");
Radek Krejci1aefdf72018-11-01 11:01:39 +0100288 /* test if not changed */
289 assert_int_equal(1, lys_feature_value(&mod, "f1"));
290 assert_int_equal(0, lys_feature_value(&mod, "f2"));
Radek Krejci38920282018-11-01 09:24:16 +0100291
David Sedlák1b623122019-08-05 15:27:49 +0200292 assert_non_null(modp = lys_parse_mem(mod.ctx, "module b {namespace urn:b;prefix b;"
Radek Krejci0af46292019-01-11 16:02:31 +0100293 "feature f1 {if-feature f2;}feature f2;}", LYS_IN_YANG));
294 assert_non_null(modp->compiled);
295 assert_non_null(modp->compiled->features);
296 assert_int_equal(2, LY_ARRAY_SIZE(modp->compiled->features));
297 assert_non_null(modp->compiled->features[0].iffeatures);
298 assert_int_equal(1, LY_ARRAY_SIZE(modp->compiled->features[0].iffeatures));
299 assert_non_null(modp->compiled->features[0].iffeatures[0].features);
300 assert_int_equal(1, LY_ARRAY_SIZE(modp->compiled->features[0].iffeatures[0].features));
301 assert_ptr_equal(&modp->compiled->features[1], modp->compiled->features[0].iffeatures[0].features[0]);
302 assert_non_null(modp->compiled->features);
303 assert_int_equal(2, LY_ARRAY_SIZE(modp->compiled->features));
304 assert_non_null(modp->compiled->features[1].depfeatures);
305 assert_int_equal(1, LY_ARRAY_SIZE(modp->compiled->features[1].depfeatures));
306 assert_ptr_equal(&modp->compiled->features[0], modp->compiled->features[1].depfeatures[0]);
307
Radek Krejci1aefdf72018-11-01 11:01:39 +0100308 /* invalid reference */
Radek Krejci38920282018-11-01 09:24:16 +0100309 assert_int_equal(LY_EINVAL, lys_feature_enable(&mod, "xxx"));
310 logbuf_assert("Feature \"xxx\" not found in module \"a\".");
311
David Sedlák1b623122019-08-05 15:27:49 +0200312 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100313
314 /* some invalid expressions */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100315 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f{if-feature f1;}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200316 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100317 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200318 logbuf_assert("Invalid value \"f1\" of if-feature - unable to find feature \"f1\". /b:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200319 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100320
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100321 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f1; feature f2{if-feature 'f and';}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200322 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100323 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200324 logbuf_assert("Invalid value \"f and\" of if-feature - unexpected end of expression. /b:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200325 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100326
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100327 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f{if-feature 'or';}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200328 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100329 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200330 logbuf_assert("Invalid value \"or\" of if-feature - unexpected end of expression. /b:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200331 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100332
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100333 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f1; feature f2{if-feature '(f1';}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200334 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100335 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200336 logbuf_assert("Invalid value \"(f1\" of if-feature - non-matching opening and closing parentheses. /b:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200337 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100338
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100339 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f1; feature f2{if-feature 'f1)';}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200340 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100341 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200342 logbuf_assert("Invalid value \"f1)\" of if-feature - non-matching opening and closing parentheses. /b:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200343 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100344
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100345 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{yang-version 1.1;namespace urn:b; prefix b; feature f1; feature f2{if-feature ---;}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200346 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100347 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200348 logbuf_assert("Invalid value \"---\" of if-feature - unable to find feature \"---\". /b:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200349 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100350
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100351 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{namespace urn:b; prefix b; feature f1; feature f2{if-feature 'not f1';}}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200352 lys_parser_ctx_free(ctx);
Radek Krejcif8f882a2018-10-31 14:51:15 +0100353 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200354 logbuf_assert("Invalid value \"not f1\" of if-feature - YANG 1.1 expression in YANG 1.0 module. /b:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200355 reset_mod(&mod);
Radek Krejci87616bb2018-10-31 13:30:52 +0100356
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100357 assert_int_equal(LY_SUCCESS, yang_parse_module(&ctx, "module b{namespace urn:b; prefix b; feature f1; feature f1;}", &mod));
David Sedlák1b623122019-08-05 15:27:49 +0200358 lys_parser_ctx_free(ctx);
Radek Krejcid05cbd92018-12-05 14:26:40 +0100359 assert_int_equal(LY_EVALID, lys_compile(&mod, 0));
Radek Krejci327de162019-06-14 12:52:07 +0200360 logbuf_assert("Duplicate identifier \"f1\" of feature statement. /b:{feature='f1'}");
David Sedlák1b623122019-08-05 15:27:49 +0200361 reset_mod(&mod);
Radek Krejcid05cbd92018-12-05 14:26:40 +0100362
David Sedlák1b623122019-08-05 15:27:49 +0200363 ly_ctx_set_module_imp_clb(mod.ctx, test_imp_clb, "submodule sz {belongs-to z {prefix z;} feature f1;}");
364 assert_null(lys_parse_mem(mod.ctx, "module z{namespace urn:z; prefix z; include sz;feature f1;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200365 logbuf_assert("Duplicate identifier \"f1\" of feature statement. /z:{feature='f1'}");
Radek Krejcid05cbd92018-12-05 14:26:40 +0100366
David Sedlák1b623122019-08-05 15:27:49 +0200367 assert_null(lys_parse_mem(mod.ctx, "module aa{namespace urn:aa; prefix aa; feature f1 {if-feature f2;} feature f2 {if-feature f1;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200368 logbuf_assert("Feature \"f1\" is indirectly referenced from itself. /aa:{feature='f2'}");
David Sedlák1b623122019-08-05 15:27:49 +0200369 assert_null(lys_parse_mem(mod.ctx, "module ab{namespace urn:ab; prefix ab; feature f1 {if-feature f1;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200370 logbuf_assert("Feature \"f1\" is referenced from itself. /ab:{feature='f1'}");
Radek Krejci09a1fc52019-02-13 10:55:17 +0100371
David Sedlák1b623122019-08-05 15:27:49 +0200372 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f {if-feature ();}}", LYS_IN_YANG));
Radek Krejci6788abc2019-06-14 13:56:49 +0200373 logbuf_assert("Invalid value \"()\" of if-feature - number of features in expression does not match the required number "
374 "of operands for the operations. /bb:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200375 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f1; feature f {if-feature 'f1(';}}", LYS_IN_YANG));
Radek Krejci6788abc2019-06-14 13:56:49 +0200376 logbuf_assert("Invalid value \"f1(\" of if-feature - non-matching opening and closing parentheses. /bb:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200377 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f1; feature f {if-feature 'and f1';}}", LYS_IN_YANG));
Radek Krejci6788abc2019-06-14 13:56:49 +0200378 logbuf_assert("Invalid value \"and f1\" of if-feature - missing feature/expression before \"and\" operation. /bb:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200379 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f1; feature f {if-feature 'f1 not ';}}", LYS_IN_YANG));
Radek Krejci6788abc2019-06-14 13:56:49 +0200380 logbuf_assert("Invalid value \"f1 not \" of if-feature - unexpected end of expression. /bb:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200381 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f1; feature f {if-feature 'f1 not not ';}}", LYS_IN_YANG));
Radek Krejci6788abc2019-06-14 13:56:49 +0200382 logbuf_assert("Invalid value \"f1 not not \" of if-feature - unexpected end of expression. /bb:{feature='f'}");
David Sedlák1b623122019-08-05 15:27:49 +0200383 assert_null(lys_parse_mem(mod.ctx, "module bb{yang-version 1.1; namespace urn:bb; prefix bb; feature f1; feature f2; "
Radek Krejci6788abc2019-06-14 13:56:49 +0200384 "feature f {if-feature 'or f1 f2';}}", LYS_IN_YANG));
385 logbuf_assert("Invalid value \"or f1 f2\" of if-feature - missing feature/expression before \"or\" operation. /bb:{feature='f'}");
386
Radek Krejci1aefdf72018-11-01 11:01:39 +0100387 /* import reference */
David Sedlák1b623122019-08-05 15:27:49 +0200388 assert_non_null(modp = lys_parse_mem(mod.ctx, str, LYS_IN_YANG));
Radek Krejci1aefdf72018-11-01 11:01:39 +0100389 assert_int_equal(LY_SUCCESS, lys_feature_enable(modp, "f1"));
David Sedlák1b623122019-08-05 15:27:49 +0200390 assert_non_null(modp = lys_parse_mem(mod.ctx, "module c{namespace urn:c; prefix c; import a {prefix a;} feature f1; feature f2{if-feature 'a:f1';}}", LYS_IN_YANG));
Radek Krejci1aefdf72018-11-01 11:01:39 +0100391 assert_int_equal(LY_SUCCESS, lys_feature_enable(modp, "f2"));
392 assert_int_equal(0, lys_feature_value(modp, "f1"));
393 assert_int_equal(1, lys_feature_value(modp, "f2"));
394
Radek Krejcid05cbd92018-12-05 14:26:40 +0100395 *state = NULL;
David Sedlák1b623122019-08-05 15:27:49 +0200396 ly_ctx_destroy(mod.ctx, NULL);
Radek Krejci151a5b72018-10-19 14:21:44 +0200397}
Radek Krejcidd4e8d42018-10-16 14:55:43 +0200398
Radek Krejci478020e2018-10-30 16:02:14 +0100399static void
400test_identity(void **state)
401{
Radek Krejci7f2a5362018-11-28 13:05:37 +0100402 *state = test_identity;
Radek Krejci478020e2018-10-30 16:02:14 +0100403
404 struct ly_ctx *ctx;
Radek Krejci1aefdf72018-11-01 11:01:39 +0100405 struct lys_module *mod1, *mod2;
Radek Krejci478020e2018-10-30 16:02:14 +0100406
407 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
Radek Krejci4d483a82019-01-17 13:12:50 +0100408 assert_non_null(mod1 = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a; identity a1;}", LYS_IN_YANG));
409 assert_non_null(mod2 = lys_parse_mem(ctx, "module b {yang-version 1.1;namespace urn:b;prefix b; import a {prefix a;}"
410 "identity b1; identity b2; identity b3 {base b1; base b:b2; base a:a1;}"
411 "identity b4 {base b:b1; base b3;}}", LYS_IN_YANG));
Radek Krejci478020e2018-10-30 16:02:14 +0100412
413 assert_non_null(mod1->compiled);
414 assert_non_null(mod1->compiled->identities);
415 assert_non_null(mod2->compiled);
416 assert_non_null(mod2->compiled->identities);
417
418 assert_non_null(mod1->compiled->identities[0].derived);
419 assert_int_equal(1, LY_ARRAY_SIZE(mod1->compiled->identities[0].derived));
420 assert_ptr_equal(mod1->compiled->identities[0].derived[0], &mod2->compiled->identities[2]);
421 assert_non_null(mod2->compiled->identities[0].derived);
422 assert_int_equal(2, LY_ARRAY_SIZE(mod2->compiled->identities[0].derived));
423 assert_ptr_equal(mod2->compiled->identities[0].derived[0], &mod2->compiled->identities[2]);
424 assert_ptr_equal(mod2->compiled->identities[0].derived[1], &mod2->compiled->identities[3]);
425 assert_non_null(mod2->compiled->identities[1].derived);
426 assert_int_equal(1, LY_ARRAY_SIZE(mod2->compiled->identities[1].derived));
427 assert_ptr_equal(mod2->compiled->identities[1].derived[0], &mod2->compiled->identities[2]);
428 assert_non_null(mod2->compiled->identities[2].derived);
429 assert_int_equal(1, LY_ARRAY_SIZE(mod2->compiled->identities[2].derived));
430 assert_ptr_equal(mod2->compiled->identities[2].derived[0], &mod2->compiled->identities[3]);
431
Radek Krejci4d483a82019-01-17 13:12:50 +0100432 assert_non_null(mod2 = lys_parse_mem(ctx, "module c {yang-version 1.1;namespace urn:c;prefix c;"
433 "identity c2 {base c1;} identity c1;}", LYS_IN_YANG));
434 assert_int_equal(1, LY_ARRAY_SIZE(mod2->compiled->identities[1].derived));
435 assert_ptr_equal(mod2->compiled->identities[1].derived[0], &mod2->compiled->identities[0]);
436
437 assert_null(lys_parse_mem(ctx, "module aa{namespace urn:aa; prefix aa; identity i1;identity i1;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200438 logbuf_assert("Duplicate identifier \"i1\" of identity statement. /aa:{identity='i1'}");
Radek Krejcid05cbd92018-12-05 14:26:40 +0100439
Radek Krejci4d483a82019-01-17 13:12:50 +0100440 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "submodule sbb {belongs-to bb {prefix bb;} identity i1;}");
441 assert_null(lys_parse_mem(ctx, "module bb{namespace urn:bb; prefix bb; include sbb;identity i1;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200442 logbuf_assert("Duplicate identifier \"i1\" of identity statement. /bb:{identity='i1'}");
Radek Krejcid05cbd92018-12-05 14:26:40 +0100443
Radek Krejci38222632019-02-12 16:55:05 +0100444 assert_null(lys_parse_mem(ctx, "module cc{namespace urn:cc; prefix cc; identity i1 {base i2;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200445 logbuf_assert("Unable to find base (i2) of identity \"i1\". /cc:{identity='i1'}");
Radek Krejci38222632019-02-12 16:55:05 +0100446
447 assert_null(lys_parse_mem(ctx, "module dd{namespace urn:dd; prefix dd; identity i1 {base i1;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200448 logbuf_assert("Identity \"i1\" is derived from itself. /dd:{identity='i1'}");
Radek Krejci38222632019-02-12 16:55:05 +0100449 assert_null(lys_parse_mem(ctx, "module de{namespace urn:de; prefix de; identity i1 {base i2;}identity i2 {base i3;}identity i3 {base i1;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200450 logbuf_assert("Identity \"i1\" is indirectly derived from itself. /de:{identity='i3'}");
Radek Krejci38222632019-02-12 16:55:05 +0100451
Radek Krejci7f2a5362018-11-28 13:05:37 +0100452 *state = NULL;
Radek Krejci478020e2018-10-30 16:02:14 +0100453 ly_ctx_destroy(ctx, NULL);
454}
455
Radek Krejcibd8d9ba2018-11-02 16:06:26 +0100456static void
457test_node_container(void **state)
458{
459 (void) state; /* unused */
460
461 struct ly_ctx *ctx;
462 struct lys_module *mod;
463 struct lysc_node_container *cont;
464
465 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
466 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;container c;}", LYS_IN_YANG));
Radek Krejcibd8d9ba2018-11-02 16:06:26 +0100467 assert_non_null(mod->compiled);
468 assert_non_null((cont = (struct lysc_node_container*)mod->compiled->data));
469 assert_int_equal(LYS_CONTAINER, cont->nodetype);
470 assert_string_equal("c", cont->name);
471 assert_true(cont->flags & LYS_CONFIG_W);
472 assert_true(cont->flags & LYS_STATUS_CURR);
473
Radek Krejci98094b32018-11-02 16:21:47 +0100474 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;container c {config false; status deprecated; container child;}}", LYS_IN_YANG));
Radek Krejci98094b32018-11-02 16:21:47 +0100475 logbuf_assert("Missing explicit \"deprecated\" status that was already specified in parent, inheriting.");
Radek Krejcibd8d9ba2018-11-02 16:06:26 +0100476 assert_non_null(mod->compiled);
477 assert_non_null((cont = (struct lysc_node_container*)mod->compiled->data));
478 assert_true(cont->flags & LYS_CONFIG_R);
Radek Krejci98094b32018-11-02 16:21:47 +0100479 assert_true(cont->flags & LYS_STATUS_DEPRC);
Radek Krejcibd8d9ba2018-11-02 16:06:26 +0100480 assert_non_null((cont = (struct lysc_node_container*)cont->child));
481 assert_int_equal(LYS_CONTAINER, cont->nodetype);
482 assert_true(cont->flags & LYS_CONFIG_R);
Radek Krejci98094b32018-11-02 16:21:47 +0100483 assert_true(cont->flags & LYS_STATUS_DEPRC);
Radek Krejcibd8d9ba2018-11-02 16:06:26 +0100484 assert_string_equal("child", cont->name);
485
486 ly_ctx_destroy(ctx, NULL);
487}
488
Radek Krejci0e5d8382018-11-28 16:37:53 +0100489static void
490test_node_leaflist(void **state)
491{
492 *state = test_node_leaflist;
493
494 struct ly_ctx *ctx;
495 struct lys_module *mod;
496 struct lysc_type *type;
497 struct lysc_node_leaflist *ll;
Radek Krejci1c0c3442019-07-23 16:08:47 +0200498 struct lysc_node_leaf *l;
Radek Krejcia1911222019-07-22 17:24:50 +0200499 const char *dflt;
500 int dynamic;
Radek Krejci0e5d8382018-11-28 16:37:53 +0100501
502 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
503
504 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;"
505 "typedef mytype {type union {type leafref {path ../target;} type string;}}"
506 "leaf-list ll1 {type union {type decimal64 {fraction-digits 2;} type mytype;}}"
507 "leaf-list ll2 {type leafref {path ../target;}}"
508 "leaf target {type int8;}}",
509 LYS_IN_YANG));
Radek Krejci0e5d8382018-11-28 16:37:53 +0100510 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
511 assert_non_null(type);
512 assert_int_equal(1, type->refcount);
513 assert_int_equal(LY_TYPE_UNION, type->basetype);
514 assert_non_null(((struct lysc_type_union*)type)->types);
515 assert_int_equal(3, LY_ARRAY_SIZE(((struct lysc_type_union*)type)->types));
516 assert_int_equal(LY_TYPE_DEC64, ((struct lysc_type_union*)type)->types[0]->basetype);
517 assert_int_equal(LY_TYPE_LEAFREF, ((struct lysc_type_union*)type)->types[1]->basetype);
518 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_union*)type)->types[2]->basetype);
519 assert_non_null(((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[1])->realtype);
520 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[1])->realtype->basetype);
521 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
522 assert_non_null(type);
523 assert_int_equal(1, type->refcount);
524 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
525 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
526 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_leafref*)type)->realtype->basetype);
527
Radek Krejci6bb080b2018-11-28 17:23:41 +0100528 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;leaf-list ll {type string;}}", LYS_IN_YANG));
Radek Krejci0e5d8382018-11-28 16:37:53 +0100529 assert_non_null(mod->compiled);
530 assert_non_null((ll = (struct lysc_node_leaflist*)mod->compiled->data));
531 assert_int_equal(0, ll->min);
532 assert_int_equal((uint32_t)-1, ll->max);
533
Radek Krejci6bb080b2018-11-28 17:23:41 +0100534 assert_non_null(mod = lys_parse_mem(ctx, "module c {yang-version 1.1;namespace urn:c;prefix c;typedef mytype {type int8;default 10;}"
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100535 "leaf-list ll1 {type mytype;default 1; default 1; config false;}"
Radek Krejcia6d57732018-11-29 13:40:37 +0100536 "leaf-list ll2 {type mytype; ordered-by user;}}", LYS_IN_YANG));
Radek Krejci6bb080b2018-11-28 17:23:41 +0100537 assert_non_null(mod->compiled);
538 assert_non_null((ll = (struct lysc_node_leaflist*)mod->compiled->data));
539 assert_non_null(ll->dflts);
Radek Krejcia1911222019-07-22 17:24:50 +0200540 assert_int_equal(6, ll->type->refcount); /* 3x type's reference, 3x default value's reference (typedef's default does not reference own type) */
Radek Krejci6bb080b2018-11-28 17:23:41 +0100541 assert_int_equal(2, LY_ARRAY_SIZE(ll->dflts));
Radek Krejcia1911222019-07-22 17:24:50 +0200542 assert_string_equal("1", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LYD_XML, NULL, NULL, &dynamic));
543 assert_int_equal(0, dynamic);
544 assert_string_equal("1", dflt = ll->dflts[1]->realtype->plugin->print(ll->dflts[1], LYD_XML, NULL, NULL, &dynamic));
545 assert_int_equal(0, dynamic);
Radek Krejci93dcc392019-02-19 10:43:38 +0100546 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_DFLT | LYS_SET_CONFIG, ll->flags);
Radek Krejci6bb080b2018-11-28 17:23:41 +0100547 assert_non_null((ll = (struct lysc_node_leaflist*)mod->compiled->data->next));
548 assert_non_null(ll->dflts);
Radek Krejcia1911222019-07-22 17:24:50 +0200549 assert_int_equal(6, ll->type->refcount); /* 3x type's reference, 3x default value's reference */
Radek Krejci6bb080b2018-11-28 17:23:41 +0100550 assert_int_equal(1, LY_ARRAY_SIZE(ll->dflts));
Radek Krejcia1911222019-07-22 17:24:50 +0200551 assert_string_equal("10", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LYD_XML, NULL, NULL, &dynamic));
552 assert_int_equal(0, dynamic);
Radek Krejcia6d57732018-11-29 13:40:37 +0100553 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_USER, ll->flags);
554
Radek Krejcifc11bd72019-04-11 16:00:05 +0200555 /* ordered-by is ignored for state data, RPC/action output parameters and notification content */
Radek Krejcia6d57732018-11-29 13:40:37 +0100556 assert_non_null(mod = lys_parse_mem(ctx, "module d {yang-version 1.1;namespace urn:d;prefix d;"
557 "leaf-list ll {config false; type string; ordered-by user;}}", LYS_IN_YANG));
Radek Krejcia6d57732018-11-29 13:40:37 +0100558 /* but warning is present: */
Radek Krejci327de162019-06-14 12:52:07 +0200559 logbuf_assert("The ordered-by statement is ignored in lists representing state data (/d:ll).");
Radek Krejcia6d57732018-11-29 13:40:37 +0100560 assert_non_null(mod->compiled);
561 assert_non_null((ll = (struct lysc_node_leaflist*)mod->compiled->data));
Radek Krejci93dcc392019-02-19 10:43:38 +0100562 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_CONFIG, ll->flags);
Radek Krejcifc11bd72019-04-11 16:00:05 +0200563 logbuf_clean();
564
565 assert_non_null(mod = lys_parse_mem(ctx, "module e {yang-version 1.1;namespace urn:e;prefix e;"
566 "rpc oper {output {leaf-list ll {type string; ordered-by user;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200567 logbuf_assert("The ordered-by statement is ignored in lists representing RPC/action output parameters (/e:oper/output/ll).");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200568 logbuf_clean();
569
570 assert_non_null(mod = lys_parse_mem(ctx, "module f {yang-version 1.1;namespace urn:f;prefix f;"
571 "notification event {leaf-list ll {type string; ordered-by user;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200572 logbuf_assert("The ordered-by statement is ignored in lists representing notification content (/f:event/ll).");
Radek Krejci6bb080b2018-11-28 17:23:41 +0100573
Radek Krejci1c0c3442019-07-23 16:08:47 +0200574 /* forward reference in default */
575 assert_non_null(mod = lys_parse_mem(ctx, "module g {yang-version 1.1; namespace urn:g;prefix g;"
576 "leaf ref {type instance-identifier {require-instance true;} default \"/g:g\";}"
577 "leaf-list g {type string;}}", LYS_IN_YANG));
578 assert_non_null(l = (struct lysc_node_leaf*)mod->compiled->data);
579 assert_string_equal("ref", l->name);
580 assert_non_null(l->dflt);
581 assert_null(l->dflt->canonized);
582
Radek Krejci6bb080b2018-11-28 17:23:41 +0100583 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +0100584 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;leaf-list ll {type empty;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200585 logbuf_assert("Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules. /aa:ll");
Radek Krejci6bb080b2018-11-28 17:23:41 +0100586
Radek Krejci096235c2019-01-11 11:12:19 +0100587 assert_null(lys_parse_mem(ctx, "module bb {yang-version 1.1;namespace urn:bb;prefix bb;leaf-list ll {type empty; default x;}}", LYS_IN_YANG));
Radek Krejcia1911222019-07-22 17:24:50 +0200588 logbuf_assert("Invalid leaf-lists's default value \"x\" which does not fit the type (Invalid empty value \"x\".). /bb:ll");
Radek Krejci6bb080b2018-11-28 17:23:41 +0100589
590 assert_non_null(mod = lys_parse_mem(ctx, "module cc {yang-version 1.1;namespace urn:cc;prefix cc;"
591 "leaf-list ll {config false;type string; default one;default two;default one;}}", LYS_IN_YANG));
Radek Krejci6bb080b2018-11-28 17:23:41 +0100592 assert_non_null(mod->compiled);
593 assert_non_null((ll = (struct lysc_node_leaflist*)mod->compiled->data));
594 assert_non_null(ll->dflts);
595 assert_int_equal(3, LY_ARRAY_SIZE(ll->dflts));
Radek Krejci096235c2019-01-11 11:12:19 +0100596 assert_null(lys_parse_mem(ctx, "module dd {yang-version 1.1;namespace urn:dd;prefix dd;"
597 "leaf-list ll {type string; default one;default two;default one;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200598 logbuf_assert("Configuration leaf-list has multiple defaults of the same value \"one\". /dd:ll");
Radek Krejci6bb080b2018-11-28 17:23:41 +0100599
Radek Krejci1c0c3442019-07-23 16:08:47 +0200600 assert_null(lys_parse_mem(ctx, "module ee {yang-version 1.1; namespace urn:ee;prefix ee;"
601 "leaf ref {type instance-identifier {require-instance true;} default \"/ee:g\";}}", LYS_IN_YANG));
602 logbuf_assert("Invalid default - value does not fit the type "
603 "(Invalid instance-identifier \"/ee:g\" value - path \"/ee:g\" does not exists in the YANG schema.). /ee:ref");
604
Radek Krejci0e5d8382018-11-28 16:37:53 +0100605 *state = NULL;
606 ly_ctx_destroy(ctx, NULL);
607}
608
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100609static void
610test_node_list(void **state)
611{
612 *state = test_node_list;
613
614 struct ly_ctx *ctx;
615 struct lys_module *mod;
616 struct lysc_node_list *list;
Radek Krejci0fe9b512019-07-26 17:51:05 +0200617 struct lysc_node *child;
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100618
619 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
620
621 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;feature f;"
Radek Krejci0fe9b512019-07-26 17:51:05 +0200622 "list l1 {key \"x y\"; ordered-by user; leaf y{type string;if-feature f;} leaf x {type string; when 1;}}"
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100623 "list l2 {config false;leaf value {type string;}}}", LYS_IN_YANG));
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100624 list = (struct lysc_node_list*)mod->compiled->data;
625 assert_non_null(list);
Radek Krejci0fe9b512019-07-26 17:51:05 +0200626 assert_non_null(list->child);
627 assert_string_equal("x", list->child->name);
628 assert_true(list->child->flags & LYS_KEY);
629 assert_string_equal("y", list->child->next->name);
630 assert_true(list->child->next->flags & LYS_KEY);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100631 assert_non_null(list->child);
632 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_USER, list->flags);
633 assert_true(list->child->flags & LYS_KEY);
634 assert_true(list->child->next->flags & LYS_KEY);
635 list = (struct lysc_node_list*)mod->compiled->data->next;
636 assert_non_null(list);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100637 assert_non_null(list->child);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100638 assert_false(list->child->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +0200639 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_CONFIG | LYS_KEYLESS, list->flags);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100640
641 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;"
642 "list l {key a; unique \"a c/b:b\"; unique \"c/e d\";"
Radek Krejci665421c2018-12-05 08:03:39 +0100643 "leaf a {type string; default x;} leaf d {type string;config false;}"
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100644 "container c {leaf b {type string;}leaf e{type string;config false;}}}}", LYS_IN_YANG));
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100645 list = (struct lysc_node_list*)mod->compiled->data;
646 assert_non_null(list);
647 assert_string_equal("l", list->name);
Radek Krejci0fe9b512019-07-26 17:51:05 +0200648 assert_string_equal("a", list->child->name);
649 assert_true(list->child->flags & LYS_KEY);
650 assert_null(((struct lysc_node_leaf*)list->child)->dflt);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100651 assert_non_null(list->uniques);
652 assert_int_equal(2, LY_ARRAY_SIZE(list->uniques));
653 assert_int_equal(2, LY_ARRAY_SIZE(list->uniques[0]));
654 assert_string_equal("a", list->uniques[0][0]->name);
655 assert_true(list->uniques[0][0]->flags & LYS_UNIQUE);
656 assert_string_equal("b", list->uniques[0][1]->name);
657 assert_true(list->uniques[0][1]->flags & LYS_UNIQUE);
658 assert_int_equal(2, LY_ARRAY_SIZE(list->uniques[1]));
659 assert_string_equal("e", list->uniques[1][0]->name);
660 assert_true(list->uniques[1][0]->flags & LYS_UNIQUE);
661 assert_string_equal("d", list->uniques[1][1]->name);
662 assert_true(list->uniques[1][1]->flags & LYS_UNIQUE);
663
Radek Krejci665421c2018-12-05 08:03:39 +0100664 assert_non_null(mod = lys_parse_mem(ctx, "module c {yang-version 1.1;namespace urn:c;prefix c;"
665 "list l {key a;leaf a {type empty;}}}", LYS_IN_YANG));
Radek Krejci665421c2018-12-05 08:03:39 +0100666 list = (struct lysc_node_list*)mod->compiled->data;
667 assert_non_null(list);
668 assert_string_equal("l", list->name);
Radek Krejci0fe9b512019-07-26 17:51:05 +0200669 assert_string_equal("a", list->child->name);
670 assert_true(list->child->flags & LYS_KEY);
671 assert_int_equal(LY_TYPE_EMPTY, ((struct lysc_node_leaf*)list->child)->type->basetype);
672
673 /* keys order */
674 assert_non_null(mod = lys_parse_mem(ctx, "module d {yang-version 1.1;namespace urn:d;prefix d;"
675 "list l {key \"d b c\";leaf a {type string;} leaf b {type string;} leaf c {type string;} leaf d {type string;}}}", LYS_IN_YANG));
676 list = (struct lysc_node_list*)mod->compiled->data;
677 assert_non_null(list);
678 assert_string_equal("l", list->name);
679 assert_non_null(child = list->child);
680 assert_string_equal("d", child->name);
681 assert_true(child->flags & LYS_KEY);
682 assert_non_null(child = child->next);
683 assert_string_equal("b", child->name);
684 assert_true(child->flags & LYS_KEY);
685 assert_non_null(child = child->next);
686 assert_string_equal("c", child->name);
687 assert_true(child->flags & LYS_KEY);
688 assert_non_null(child = child->next);
689 assert_string_equal("a", child->name);
690 assert_false(child->flags & LYS_KEY);
Radek Krejci665421c2018-12-05 08:03:39 +0100691
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100692 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +0100693 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;list l;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200694 logbuf_assert("Missing key in list representing configuration data. /aa:l");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100695
Radek Krejci096235c2019-01-11 11:12:19 +0100696 assert_null(lys_parse_mem(ctx, "module bb {yang-version 1.1; namespace urn:bb;prefix bb;"
697 "list l {key x; leaf x {type string; when 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200698 logbuf_assert("List's key must not have any \"when\" statement. /bb:l/x");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100699
Radek Krejci096235c2019-01-11 11:12:19 +0100700 assert_null(lys_parse_mem(ctx, "module cc {yang-version 1.1;namespace urn:cc;prefix cc;feature f;"
701 "list l {key x; leaf x {type string; if-feature f;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200702 logbuf_assert("List's key must not have any \"if-feature\" statement. /cc:l/x");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100703
Radek Krejci096235c2019-01-11 11:12:19 +0100704 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;"
705 "list l {key x; leaf x {type string; config false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200706 logbuf_assert("Key of the configuration list must not be status leaf. /dd:l/x");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100707
Radek Krejci096235c2019-01-11 11:12:19 +0100708 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;"
709 "list l {config false;key x; leaf x {type string; config true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200710 logbuf_assert("Configuration node cannot be child of any state data node. /ee:l/x");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100711
Radek Krejci096235c2019-01-11 11:12:19 +0100712 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;"
713 "list l {key x; leaf-list x {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200714 logbuf_assert("The list's key \"x\" not found. /ff:l");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100715
Radek Krejci096235c2019-01-11 11:12:19 +0100716 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;"
717 "list l {key x; unique y;leaf x {type string;} leaf-list y {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200718 logbuf_assert("Unique's descendant-schema-nodeid \"y\" refers to leaf-list node instead of a leaf. /gg:l");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100719
Radek Krejci096235c2019-01-11 11:12:19 +0100720 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh;"
721 "list l {key x; unique \"x y\";leaf x {type string;} leaf y {config false; type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200722 logbuf_assert("Unique statement \"x y\" refers to leafs with different config type. /hh:l");
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100723
Radek Krejci096235c2019-01-11 11:12:19 +0100724 assert_null(lys_parse_mem(ctx, "module ii {namespace urn:ii;prefix ii;"
725 "list l {key x; unique a:x;leaf x {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200726 logbuf_assert("Invalid descendant-schema-nodeid value \"a:x\" - prefix \"a\" not defined in module \"ii\". /ii:l");
Radek Krejci665421c2018-12-05 08:03:39 +0100727
Radek Krejci096235c2019-01-11 11:12:19 +0100728 assert_null(lys_parse_mem(ctx, "module jj {namespace urn:jj;prefix jj;"
729 "list l {key x; unique c/x;leaf x {type string;}container c {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200730 logbuf_assert("Invalid descendant-schema-nodeid value \"c/x\" - target node not found. /jj:l");
Radek Krejci665421c2018-12-05 08:03:39 +0100731
Radek Krejci096235c2019-01-11 11:12:19 +0100732 assert_null( lys_parse_mem(ctx, "module kk {namespace urn:kk;prefix kk;"
733 "list l {key x; unique c^y;leaf x {type string;}container c {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200734 logbuf_assert("Invalid descendant-schema-nodeid value \"c^\" - missing \"/\" as node-identifier separator. /kk:l");
Radek Krejci665421c2018-12-05 08:03:39 +0100735
Radek Krejci096235c2019-01-11 11:12:19 +0100736 assert_null(lys_parse_mem(ctx, "module ll {namespace urn:ll;prefix ll;"
737 "list l {key \"x y x\";leaf x {type string;}leaf y {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200738 logbuf_assert("Duplicated key identifier \"x\". /ll:l");
Radek Krejci665421c2018-12-05 08:03:39 +0100739
Radek Krejci096235c2019-01-11 11:12:19 +0100740 assert_null(lys_parse_mem(ctx, "module mm {namespace urn:mm;prefix mm;"
741 "list l {key x;leaf x {type empty;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200742 logbuf_assert("List's key cannot be of \"empty\" type until it is in YANG 1.1 module. /mm:l/x");
Radek Krejci665421c2018-12-05 08:03:39 +0100743
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100744 *state = NULL;
745 ly_ctx_destroy(ctx, NULL);
746}
747
Radek Krejci056d0a82018-12-06 16:57:25 +0100748static void
749test_node_choice(void **state)
750{
751 *state = test_node_choice;
752
753 struct ly_ctx *ctx;
754 struct lys_module *mod;
755 struct lysc_node_choice *ch;
756 struct lysc_node_case *cs;
757
758 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
759
760 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;feature f;"
Radek Krejci18f2b8a2018-12-12 16:41:21 +0100761 "choice ch {default a:b; case a {leaf a1 {type string;}leaf a2 {type string;}}"
762 "leaf b {type string;}}}", LYS_IN_YANG));
Radek Krejci056d0a82018-12-06 16:57:25 +0100763 ch = (struct lysc_node_choice*)mod->compiled->data;
764 assert_non_null(ch);
Radek Krejci01342af2019-01-03 15:18:08 +0100765 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR, ch->flags);
Radek Krejci056d0a82018-12-06 16:57:25 +0100766 cs = ch->cases;
767 assert_non_null(cs);
768 assert_string_equal("a", cs->name);
769 assert_ptr_equal(ch, cs->parent);
770 assert_non_null(cs->child);
Radek Krejci18f2b8a2018-12-12 16:41:21 +0100771 assert_string_equal("a1", cs->child->name);
772 assert_non_null(cs->child->next);
773 assert_string_equal("a2", cs->child->next->name);
Radek Krejci056d0a82018-12-06 16:57:25 +0100774 assert_ptr_equal(cs, cs->child->parent);
775 cs = (struct lysc_node_case*)cs->next;
776 assert_non_null(cs);
777 assert_string_equal("b", cs->name);
Radek Krejci01342af2019-01-03 15:18:08 +0100778 assert_int_equal(LYS_STATUS_CURR | LYS_SET_DFLT, cs->flags);
Radek Krejci056d0a82018-12-06 16:57:25 +0100779 assert_ptr_equal(ch, cs->parent);
780 assert_non_null(cs->child);
781 assert_string_equal("b", cs->child->name);
782 assert_ptr_equal(cs, cs->child->parent);
Radek Krejci18f2b8a2018-12-12 16:41:21 +0100783 assert_ptr_equal(ch->cases->child->next, cs->child->prev);
784 assert_ptr_equal(ch->cases->child->next->next, cs->child);
Radek Krejci056d0a82018-12-06 16:57:25 +0100785 assert_ptr_equal(ch->cases->child->prev, cs->child);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100786 assert_ptr_equal(ch->dflt, cs);
Radek Krejci056d0a82018-12-06 16:57:25 +0100787
Radek Krejci096235c2019-01-11 11:12:19 +0100788 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;"
789 "choice ch {case a {leaf x {type string;}}leaf x {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200790 logbuf_assert("Duplicate identifier \"x\" of data definition/RPC/action/Notification statement. /aa:ch/x/x");
Radek Krejci096235c2019-01-11 11:12:19 +0100791 assert_null(lys_parse_mem(ctx, "module aa2 {namespace urn:aa2;prefix aa;"
792 "choice ch {case a {leaf y {type string;}}case b {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200793 logbuf_assert("Duplicate identifier \"y\" of data definition/RPC/action/Notification statement. /aa2:ch/b/y");
Radek Krejci096235c2019-01-11 11:12:19 +0100794 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;"
795 "choice ch {case a {leaf x {type string;}}leaf a {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200796 logbuf_assert("Duplicate identifier \"a\" of case statement. /bb:ch/a");
Radek Krejci096235c2019-01-11 11:12:19 +0100797 assert_null(lys_parse_mem(ctx, "module bb2 {namespace urn:bb2;prefix bb;"
798 "choice ch {case b {leaf x {type string;}}case b {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200799 logbuf_assert("Duplicate identifier \"b\" of case statement. /bb2:ch/b");
Radek Krejci056d0a82018-12-06 16:57:25 +0100800
Radek Krejci096235c2019-01-11 11:12:19 +0100801 assert_null(lys_parse_mem(ctx, "module ca {namespace urn:ca;prefix ca;"
802 "choice ch {default c;case a {leaf x {type string;}}case b {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200803 logbuf_assert("Default case \"c\" not found. /ca:ch");
Radek Krejci096235c2019-01-11 11:12:19 +0100804 assert_null(lys_parse_mem(ctx, "module cb {namespace urn:cb;prefix cb; import a {prefix a;}"
805 "choice ch {default a:a;case a {leaf x {type string;}}case b {leaf y {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200806 logbuf_assert("Invalid default case referencing a case from different YANG module (by prefix \"a\"). /cb:ch");
Radek Krejci096235c2019-01-11 11:12:19 +0100807 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;"
808 "choice ch {default a;case a {leaf x {mandatory true;type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200809 logbuf_assert("Mandatory node \"x\" under the default case \"a\". /cc:ch");
Radek Krejcia9026eb2018-12-12 16:04:47 +0100810 /* TODO check with mandatory nodes from augment placed into the case */
811
Radek Krejci056d0a82018-12-06 16:57:25 +0100812 *state = NULL;
813 ly_ctx_destroy(ctx, NULL);
814}
815
Radek Krejci9800fb82018-12-13 14:26:23 +0100816static void
817test_node_anydata(void **state)
818{
819 *state = test_node_anydata;
820
821 struct ly_ctx *ctx;
822 struct lys_module *mod;
823 struct lysc_node_anydata *any;
824
825 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
826
827 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1;namespace urn:a;prefix a;"
828 "anydata any {config false;mandatory true;}}", LYS_IN_YANG));
Radek Krejci9800fb82018-12-13 14:26:23 +0100829 any = (struct lysc_node_anydata*)mod->compiled->data;
830 assert_non_null(any);
831 assert_int_equal(LYS_ANYDATA, any->nodetype);
Radek Krejci93dcc392019-02-19 10:43:38 +0100832 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_MAND_TRUE | LYS_SET_CONFIG, any->flags);
Radek Krejci9800fb82018-12-13 14:26:23 +0100833
834 logbuf_clean();
835 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;"
836 "anyxml any;}", LYS_IN_YANG));
Radek Krejci9800fb82018-12-13 14:26:23 +0100837 any = (struct lysc_node_anydata*)mod->compiled->data;
838 assert_non_null(any);
839 assert_int_equal(LYS_ANYXML, any->nodetype);
840 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR, any->flags);
841 logbuf_assert("Use of anyxml to define configuration data is not recommended."); /* warning */
842
843 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +0100844 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;anydata any;}", LYS_IN_YANG));
Radek Krejci9800fb82018-12-13 14:26:23 +0100845 logbuf_assert("Invalid keyword \"anydata\" as a child of \"module\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
846
847 *state = NULL;
848 ly_ctx_destroy(ctx, NULL);
849}
850
Radek Krejcif538ce52019-03-05 10:46:14 +0100851static void
852test_action(void **state)
853{
854 *state = test_action;
855
856 struct ly_ctx *ctx;
857 struct lys_module *mod;
858 const struct lysc_action *rpc;
859
860 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
861
862 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;"
863 "rpc a {input {leaf x {type int8;} leaf y {type int8;}} output {leaf result {type int16;}}}}", LYS_IN_YANG));
864 rpc = mod->compiled->rpcs;
865 assert_non_null(rpc);
866 assert_int_equal(1, LY_ARRAY_SIZE(rpc));
867 assert_int_equal(LYS_ACTION, rpc->nodetype);
868 assert_int_equal(LYS_STATUS_CURR, rpc->flags);
869 assert_string_equal("a", rpc->name);
870
871 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1; namespace urn:b;prefix b; container top {"
872 "action b {input {leaf x {type int8;} leaf y {type int8;}} output {leaf result {type int16;}}}}}", LYS_IN_YANG));
873 rpc = lysc_node_actions(mod->compiled->data);
874 assert_non_null(rpc);
875 assert_int_equal(1, LY_ARRAY_SIZE(rpc));
876 assert_int_equal(LYS_ACTION, rpc->nodetype);
877 assert_int_equal(LYS_STATUS_CURR, rpc->flags);
878 assert_string_equal("b", rpc->name);
879
880 /* invalid */
881 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;container top {action x;}}", LYS_IN_YANG));
882 logbuf_assert("Invalid keyword \"action\" as a child of \"container\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
883
Radek Krejci8cce8532019-03-05 11:27:45 +0100884 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;leaf x{type string;} rpc x;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200885 logbuf_assert("Duplicate identifier \"x\" of data definition/RPC/action/Notification statement. /bb:x");
Radek Krejci8cce8532019-03-05 11:27:45 +0100886 assert_null(lys_parse_mem(ctx, "module cc {yang-version 1.1; namespace urn:cc;prefix cc;container c {leaf y {type string;} action y;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200887 logbuf_assert("Duplicate identifier \"y\" of data definition/RPC/action/Notification statement. /cc:c/y");
Radek Krejci8cce8532019-03-05 11:27:45 +0100888 assert_null(lys_parse_mem(ctx, "module dd {yang-version 1.1; namespace urn:dd;prefix dd;container c {action z; action z;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200889 logbuf_assert("Duplicate identifier \"z\" of data definition/RPC/action/Notification statement. /dd:c/z");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200890 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "submodule eesub {belongs-to ee {prefix ee;} notification w;}");
Radek Krejci8cce8532019-03-05 11:27:45 +0100891 assert_null(lys_parse_mem(ctx, "module ee {yang-version 1.1; namespace urn:ee;prefix ee;include eesub; rpc w;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200892 logbuf_assert("Duplicate identifier \"w\" of data definition/RPC/action/Notification statement. /ee:w");
Radek Krejci8cce8532019-03-05 11:27:45 +0100893
Radek Krejcifc11bd72019-04-11 16:00:05 +0200894 assert_null(lys_parse_mem(ctx, "module ff {yang-version 1.1; namespace urn:ff;prefix ff; rpc test {input {container a {leaf b {type string;}}}}"
895 "augment /test/input/a {action invalid {input {leaf x {type string;}}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200896 logbuf_assert("Action \"invalid\" is placed inside another RPC/action. /ff:{augment='/test/input/a'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200897
898 assert_null(lys_parse_mem(ctx, "module gg {yang-version 1.1; namespace urn:gg;prefix gg; notification test {container a {leaf b {type string;}}}"
899 "augment /test/a {action invalid {input {leaf x {type string;}}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200900 logbuf_assert("Action \"invalid\" is placed inside Notification. /gg:{augment='/test/a'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200901
902 assert_null(lys_parse_mem(ctx, "module hh {yang-version 1.1; namespace urn:hh;prefix hh; notification test {container a {uses grp;}}"
903 "grouping grp {action invalid {input {leaf x {type string;}}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200904 logbuf_assert("Action \"invalid\" is placed inside Notification. /hh:test/a/{uses='grp'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200905
906 *state = NULL;
907 ly_ctx_destroy(ctx, NULL);
908}
909
910static void
911test_notification(void **state)
912{
913 *state = test_notification;
914
915 struct ly_ctx *ctx;
916 struct lys_module *mod;
917 const struct lysc_notif *notif;
918
919 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
920
921 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;"
922 "notification a1 {leaf x {type int8;}} notification a2;}", LYS_IN_YANG));
923 notif = mod->compiled->notifs;
924 assert_non_null(notif);
925 assert_int_equal(2, LY_ARRAY_SIZE(notif));
926 assert_int_equal(LYS_NOTIF, notif->nodetype);
927 assert_int_equal(LYS_STATUS_CURR, notif->flags);
928 assert_string_equal("a1", notif->name);
929 assert_non_null(notif->data);
930 assert_string_equal("x", notif->data->name);
931 assert_int_equal(LYS_NOTIF, notif[1].nodetype);
932 assert_int_equal(LYS_STATUS_CURR, notif[1].flags);
933 assert_string_equal("a2", notif[1].name);
934 assert_null(notif[1].data);
935
936 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1; namespace urn:b;prefix b; container top {"
937 "notification b1 {leaf x {type int8;}} notification b2;}}", LYS_IN_YANG));
938 notif = lysc_node_notifs(mod->compiled->data);
939 assert_non_null(notif);
940 assert_int_equal(2, LY_ARRAY_SIZE(notif));
941 assert_int_equal(LYS_NOTIF, notif->nodetype);
942 assert_int_equal(LYS_STATUS_CURR, notif->flags);
943 assert_string_equal("b1", notif->name);
944 assert_non_null(notif->data);
945 assert_string_equal("x", notif->data->name);
946 assert_int_equal(LYS_NOTIF, notif[1].nodetype);
947 assert_int_equal(LYS_STATUS_CURR, notif[1].flags);
948 assert_string_equal("b2", notif[1].name);
949 assert_null(notif[1].data);
950
951 /* invalid */
952 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;container top {notification x;}}", LYS_IN_YANG));
953 logbuf_assert("Invalid keyword \"notification\" as a child of \"container\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
954
955 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;leaf x{type string;} notification x;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200956 logbuf_assert("Duplicate identifier \"x\" of data definition/RPC/action/Notification statement. /bb:x");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200957 assert_null(lys_parse_mem(ctx, "module cc {yang-version 1.1; namespace urn:cc;prefix cc;container c {leaf y {type string;} notification y;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200958 logbuf_assert("Duplicate identifier \"y\" of data definition/RPC/action/Notification statement. /cc:c/y");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200959 assert_null(lys_parse_mem(ctx, "module dd {yang-version 1.1; namespace urn:dd;prefix dd;container c {notification z; notification z;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200960 logbuf_assert("Duplicate identifier \"z\" of data definition/RPC/action/Notification statement. /dd:c/z");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200961 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "submodule eesub {belongs-to ee {prefix ee;} rpc w;}");
962 assert_null(lys_parse_mem(ctx, "module ee {yang-version 1.1; namespace urn:ee;prefix ee;include eesub; notification w;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200963 logbuf_assert("Duplicate identifier \"w\" of data definition/RPC/action/Notification statement. /ee:w");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200964
965 assert_null(lys_parse_mem(ctx, "module ff {yang-version 1.1; namespace urn:ff;prefix ff; rpc test {input {container a {leaf b {type string;}}}}"
966 "augment /test/input/a {notification invalid {leaf x {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200967 logbuf_assert("Notification \"invalid\" is placed inside RPC/action. /ff:{augment='/test/input/a'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200968
969 assert_null(lys_parse_mem(ctx, "module gg {yang-version 1.1; namespace urn:gg;prefix gg; notification test {container a {leaf b {type string;}}}"
970 "augment /test/a {notification invalid {leaf x {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200971 logbuf_assert("Notification \"invalid\" is placed inside another Notification. /gg:{augment='/test/a'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200972
973 assert_null(lys_parse_mem(ctx, "module hh {yang-version 1.1; namespace urn:hh;prefix hh; rpc test {input {container a {uses grp;}}}"
974 "grouping grp {notification invalid {leaf x {type string;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +0200975 logbuf_assert("Notification \"invalid\" is placed inside RPC/action. /hh:test/input/a/{uses='grp'}/invalid");
Radek Krejcifc11bd72019-04-11 16:00:05 +0200976
Radek Krejcif538ce52019-03-05 10:46:14 +0100977 *state = NULL;
978 ly_ctx_destroy(ctx, NULL);
979}
980
Radek Krejci0f07bed2018-11-13 14:01:40 +0100981/**
982 * actually the same as length restriction (tested in test_type_length()), so just check the correct handling in appropriate types,
983 * do not test the expression itself
984 */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100985static void
Radek Krejci0f07bed2018-11-13 14:01:40 +0100986test_type_range(void **state)
Radek Krejci4f28eda2018-11-12 11:46:16 +0100987{
Radek Krejci0f07bed2018-11-13 14:01:40 +0100988 *state = test_type_range;
989
990 struct ly_ctx *ctx;
991 struct lys_module *mod;
992 struct lysc_type *type;
993
994 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
995
996 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;leaf l {type int8 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +0100997 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
998 assert_non_null(type);
999 assert_int_equal(LY_TYPE_INT8, type->basetype);
1000 assert_non_null(((struct lysc_type_num*)type)->range);
1001 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1002 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1003 assert_int_equal(-128, ((struct lysc_type_num*)type)->range->parts[0].min_64);
1004 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_64);
1005 assert_int_equal(127, ((struct lysc_type_num*)type)->range->parts[1].min_64);
1006 assert_int_equal(127, ((struct lysc_type_num*)type)->range->parts[1].max_64);
1007
1008 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;leaf l {type int16 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001009 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1010 assert_non_null(type);
1011 assert_int_equal(LY_TYPE_INT16, type->basetype);
1012 assert_non_null(((struct lysc_type_num*)type)->range);
1013 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1014 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1015 assert_int_equal(-32768, ((struct lysc_type_num*)type)->range->parts[0].min_64);
1016 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_64);
1017 assert_int_equal(32767, ((struct lysc_type_num*)type)->range->parts[1].min_64);
1018 assert_int_equal(32767, ((struct lysc_type_num*)type)->range->parts[1].max_64);
1019
1020 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c;leaf l {type int32 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001021 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1022 assert_non_null(type);
1023 assert_int_equal(LY_TYPE_INT32, type->basetype);
1024 assert_non_null(((struct lysc_type_num*)type)->range);
1025 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1026 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1027 assert_int_equal(INT64_C(-2147483648), ((struct lysc_type_num*)type)->range->parts[0].min_64);
1028 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_64);
1029 assert_int_equal(INT64_C(2147483647), ((struct lysc_type_num*)type)->range->parts[1].min_64);
1030 assert_int_equal(INT64_C(2147483647), ((struct lysc_type_num*)type)->range->parts[1].max_64);
1031
1032 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d;leaf l {type int64 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001033 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1034 assert_non_null(type);
1035 assert_int_equal(LY_TYPE_INT64, type->basetype);
1036 assert_non_null(((struct lysc_type_num*)type)->range);
1037 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1038 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1039 assert_int_equal(INT64_C(-9223372036854775807) - INT64_C(1), ((struct lysc_type_num*)type)->range->parts[0].min_64);
1040 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_64);
1041 assert_int_equal(INT64_C(9223372036854775807), ((struct lysc_type_num*)type)->range->parts[1].min_64);
1042 assert_int_equal(INT64_C(9223372036854775807), ((struct lysc_type_num*)type)->range->parts[1].max_64);
1043
1044 assert_non_null(mod = lys_parse_mem(ctx, "module e {namespace urn:e;prefix e;leaf l {type uint8 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001045 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1046 assert_non_null(type);
1047 assert_int_equal(LY_TYPE_UINT8, type->basetype);
1048 assert_non_null(((struct lysc_type_num*)type)->range);
1049 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1050 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1051 assert_int_equal(0, ((struct lysc_type_num*)type)->range->parts[0].min_u64);
1052 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_u64);
1053 assert_int_equal(255, ((struct lysc_type_num*)type)->range->parts[1].min_u64);
1054 assert_int_equal(255, ((struct lysc_type_num*)type)->range->parts[1].max_u64);
1055
1056 assert_non_null(mod = lys_parse_mem(ctx, "module f {namespace urn:f;prefix f;leaf l {type uint16 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001057 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1058 assert_non_null(type);
1059 assert_int_equal(LY_TYPE_UINT16, type->basetype);
1060 assert_non_null(((struct lysc_type_num*)type)->range);
1061 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1062 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1063 assert_int_equal(0, ((struct lysc_type_num*)type)->range->parts[0].min_u64);
1064 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_u64);
1065 assert_int_equal(65535, ((struct lysc_type_num*)type)->range->parts[1].min_u64);
1066 assert_int_equal(65535, ((struct lysc_type_num*)type)->range->parts[1].max_u64);
1067
1068 assert_non_null(mod = lys_parse_mem(ctx, "module g {namespace urn:g;prefix g;leaf l {type uint32 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001069 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1070 assert_non_null(type);
1071 assert_int_equal(LY_TYPE_UINT32, type->basetype);
1072 assert_non_null(((struct lysc_type_num*)type)->range);
1073 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1074 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1075 assert_int_equal(0, ((struct lysc_type_num*)type)->range->parts[0].min_u64);
1076 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_u64);
1077 assert_int_equal(UINT64_C(4294967295), ((struct lysc_type_num*)type)->range->parts[1].min_u64);
1078 assert_int_equal(UINT64_C(4294967295), ((struct lysc_type_num*)type)->range->parts[1].max_u64);
1079
1080 assert_non_null(mod = lys_parse_mem(ctx, "module h {namespace urn:h;prefix h;leaf l {type uint64 {range min..10|max;}}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001081 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1082 assert_non_null(type);
1083 assert_int_equal(LY_TYPE_UINT64, type->basetype);
1084 assert_non_null(((struct lysc_type_num*)type)->range);
1085 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1086 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1087 assert_int_equal(0, ((struct lysc_type_num*)type)->range->parts[0].min_u64);
1088 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_u64);
1089 assert_int_equal(UINT64_C(18446744073709551615), ((struct lysc_type_num*)type)->range->parts[1].min_u64);
1090 assert_int_equal(UINT64_C(18446744073709551615), ((struct lysc_type_num*)type)->range->parts[1].max_u64);
1091
1092 assert_non_null(mod = lys_parse_mem(ctx, "module i {namespace urn:i;prefix i;typedef mytype {type uint8 {range 10..100;}}"
1093 "typedef mytype2 {type mytype;} leaf l {type mytype2;}}", LYS_IN_YANG));
Radek Krejci0f07bed2018-11-13 14:01:40 +01001094 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1095 assert_non_null(type);
1096 assert_int_equal(3, type->refcount);
1097 assert_int_equal(LY_TYPE_UINT8, type->basetype);
1098 assert_non_null(((struct lysc_type_num*)type)->range);
1099 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1100 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1101
Radek Krejcif1394042019-01-08 10:53:34 +01001102 assert_non_null(mod = lys_parse_mem(ctx, "module j {namespace urn:j;prefix j;"
1103 "typedef mytype {type uint8 {range 1..100{description \"one to hundred\";reference A;}}}"
1104 "leaf l {type mytype {range 1..10 {description \"one to ten\";reference B;}}}}", LYS_IN_YANG));
Radek Krejcif1394042019-01-08 10:53:34 +01001105 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1106 assert_non_null(type);
1107 assert_int_equal(1, type->refcount);
1108 assert_int_equal(LY_TYPE_UINT8, type->basetype);
1109 assert_non_null(((struct lysc_type_num*)type)->range);
1110 assert_string_equal("one to ten", ((struct lysc_type_num*)type)->range->dsc);
1111 assert_string_equal("B", ((struct lysc_type_num*)type)->range->ref);
1112 assert_non_null(((struct lysc_type_num*)type)->range->parts);
1113 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_num*)type)->range->parts));
1114 assert_int_equal(1, ((struct lysc_type_num*)type)->range->parts[0].min_u64);
1115 assert_int_equal(10, ((struct lysc_type_num*)type)->range->parts[0].max_u64);
1116
Radek Krejci0f07bed2018-11-13 14:01:40 +01001117 *state = NULL;
1118 ly_ctx_destroy(ctx, NULL);
1119}
1120
1121static void
1122test_type_length(void **state)
1123{
1124 *state = test_type_length;
Radek Krejci4f28eda2018-11-12 11:46:16 +01001125
1126 struct ly_ctx *ctx;
1127 struct lys_module *mod;
1128 struct lysc_type *type;
1129
1130 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1131
Radek Krejcic5ddcc02018-11-12 13:28:18 +01001132 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;leaf l {type binary {length min {error-app-tag errortag;error-message error;}}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001133 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1134 assert_non_null(type);
1135 assert_non_null(((struct lysc_type_bin*)type)->length);
1136 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
Radek Krejcic5ddcc02018-11-12 13:28:18 +01001137 assert_string_equal("errortag", ((struct lysc_type_bin*)type)->length->eapptag);
1138 assert_string_equal("error", ((struct lysc_type_bin*)type)->length->emsg);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001139 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1140 assert_int_equal(0, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1141 assert_int_equal(0, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1142
1143 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;leaf l {type binary {length max;}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001144 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1145 assert_non_null(type);
1146 assert_non_null(((struct lysc_type_bin*)type)->length);
1147 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1148 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
Radek Krejci0fe20752018-11-27 11:33:24 +01001149 assert_int_equal(UINT64_C(18446744073709551615), ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1150 assert_int_equal(UINT64_C(18446744073709551615), ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001151
1152 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c;leaf l {type binary {length min..max;}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001153 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1154 assert_non_null(type);
1155 assert_non_null(((struct lysc_type_bin*)type)->length);
1156 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1157 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1158 assert_int_equal(0, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
Radek Krejci0fe20752018-11-27 11:33:24 +01001159 assert_int_equal(UINT64_C(18446744073709551615), ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001160
1161 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d;leaf l {type binary {length 5;}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001162 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1163 assert_non_null(type);
1164 assert_non_null(((struct lysc_type_bin*)type)->length);
1165 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1166 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1167 assert_int_equal(5, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1168 assert_int_equal(5, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1169
1170 assert_non_null(mod = lys_parse_mem(ctx, "module e {namespace urn:e;prefix e;leaf l {type binary {length 1..10;}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001171 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1172 assert_non_null(type);
1173 assert_non_null(((struct lysc_type_bin*)type)->length);
1174 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1175 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1176 assert_int_equal(1, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1177 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1178
1179 assert_non_null(mod = lys_parse_mem(ctx, "module f {namespace urn:f;prefix f;leaf l {type binary {length 1..10|20..30;}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001180 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1181 assert_non_null(type);
1182 assert_non_null(((struct lysc_type_bin*)type)->length);
1183 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1184 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1185 assert_int_equal(1, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1186 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1187 assert_int_equal(20, ((struct lysc_type_bin*)type)->length->parts[1].min_u64);
1188 assert_int_equal(30, ((struct lysc_type_bin*)type)->length->parts[1].max_u64);
1189
1190 assert_non_null(mod = lys_parse_mem(ctx, "module g {namespace urn:g;prefix g;leaf l {type binary {length \"16 | 32\";}}}", LYS_IN_YANG));
Radek Krejci4f28eda2018-11-12 11:46:16 +01001191 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1192 assert_non_null(type);
1193 assert_non_null(((struct lysc_type_bin*)type)->length);
1194 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1195 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1196 assert_int_equal(16, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1197 assert_int_equal(16, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1198 assert_int_equal(32, ((struct lysc_type_bin*)type)->length->parts[1].min_u64);
1199 assert_int_equal(32, ((struct lysc_type_bin*)type)->length->parts[1].max_u64);
1200
Radek Krejcib31c8992018-11-12 16:29:16 +01001201 assert_non_null(mod = lys_parse_mem(ctx, "module h {namespace urn:h;prefix h;typedef mytype {type binary {length 10;}}"
1202 "leaf l {type mytype {length \"10\";}}}", LYS_IN_YANG));
Radek Krejcib31c8992018-11-12 16:29:16 +01001203 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1204 assert_non_null(type);
1205 assert_non_null(((struct lysc_type_bin*)type)->length);
1206 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1207 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1208 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1209 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1210
1211 assert_non_null(mod = lys_parse_mem(ctx, "module i {namespace urn:i;prefix i;typedef mytype {type binary {length 10..100;}}"
1212 "leaf l {type mytype {length \"50\";}}}", LYS_IN_YANG));
Radek Krejcib31c8992018-11-12 16:29:16 +01001213 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1214 assert_non_null(type);
1215 assert_non_null(((struct lysc_type_bin*)type)->length);
1216 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1217 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1218 assert_int_equal(50, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1219 assert_int_equal(50, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1220
1221 assert_non_null(mod = lys_parse_mem(ctx, "module j {namespace urn:j;prefix j;typedef mytype {type binary {length 10..100;}}"
1222 "leaf l {type mytype {length \"10..30|60..100\";}}}", LYS_IN_YANG));
Radek Krejcib31c8992018-11-12 16:29:16 +01001223 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1224 assert_non_null(type);
1225 assert_non_null(((struct lysc_type_bin*)type)->length);
1226 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1227 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1228 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1229 assert_int_equal(30, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1230 assert_int_equal(60, ((struct lysc_type_bin*)type)->length->parts[1].min_u64);
1231 assert_int_equal(100, ((struct lysc_type_bin*)type)->length->parts[1].max_u64);
1232
1233 assert_non_null(mod = lys_parse_mem(ctx, "module k {namespace urn:k;prefix k;typedef mytype {type binary {length 10..100;}}"
Radek Krejci56aa27c2018-11-13 14:21:59 +01001234 "leaf l {type mytype {length \"10..80\";}}leaf ll {type mytype;}}", LYS_IN_YANG));
Radek Krejcib31c8992018-11-12 16:29:16 +01001235 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1236 assert_non_null(type);
Radek Krejci56aa27c2018-11-13 14:21:59 +01001237 assert_int_equal(1, type->refcount);
Radek Krejcib31c8992018-11-12 16:29:16 +01001238 assert_non_null(((struct lysc_type_bin*)type)->length);
1239 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1240 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1241 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
Radek Krejci56aa27c2018-11-13 14:21:59 +01001242 assert_int_equal(80, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
Radek Krejcib31c8992018-11-12 16:29:16 +01001243 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
1244 assert_non_null(type);
Radek Krejci56aa27c2018-11-13 14:21:59 +01001245 assert_int_equal(2, type->refcount);
Radek Krejcib31c8992018-11-12 16:29:16 +01001246 assert_non_null(((struct lysc_type_bin*)type)->length);
1247 assert_non_null(((struct lysc_type_bin*)type)->length->parts);
1248 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_bin*)type)->length->parts));
1249 assert_int_equal(10, ((struct lysc_type_bin*)type)->length->parts[0].min_u64);
1250 assert_int_equal(100, ((struct lysc_type_bin*)type)->length->parts[0].max_u64);
1251
Radek Krejci56aa27c2018-11-13 14:21:59 +01001252 assert_non_null(mod = lys_parse_mem(ctx, "module l {namespace urn:l;prefix l;typedef mytype {type string {length 10..100;}}"
1253 "typedef mytype2 {type mytype {pattern '[0-9]*';}} leaf l {type mytype2 {pattern '[0-4]*';}}}", LYS_IN_YANG));
Radek Krejci9a191e62018-11-13 13:19:56 +01001254 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1255 assert_non_null(type);
1256 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejci56aa27c2018-11-13 14:21:59 +01001257 assert_int_equal(1, type->refcount);
Radek Krejcicda74152018-11-13 15:27:32 +01001258 assert_non_null(((struct lysc_type_str*)type)->length);
1259 assert_non_null(((struct lysc_type_str*)type)->length->parts);
1260 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->length->parts));
1261 assert_int_equal(10, ((struct lysc_type_str*)type)->length->parts[0].min_u64);
1262 assert_int_equal(100, ((struct lysc_type_str*)type)->length->parts[0].max_u64);
Radek Krejci9a191e62018-11-13 13:19:56 +01001263
Radek Krejci5969f272018-11-23 10:03:58 +01001264 assert_non_null(mod = lys_parse_mem(ctx, "module m {namespace urn:m;prefix m;typedef mytype {type string {length 10;}}"
1265 "leaf l {type mytype {length min..max;}}}", LYS_IN_YANG));
Radek Krejci5969f272018-11-23 10:03:58 +01001266 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1267 assert_non_null(type);
1268 assert_int_equal(LY_TYPE_STRING, type->basetype);
1269 assert_int_equal(1, type->refcount);
1270 assert_non_null(((struct lysc_type_str*)type)->length);
1271 assert_non_null(((struct lysc_type_str*)type)->length->parts);
1272 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->length->parts));
1273 assert_int_equal(10, ((struct lysc_type_str*)type)->length->parts[0].min_u64);
1274 assert_int_equal(10, ((struct lysc_type_str*)type)->length->parts[0].max_u64);
1275
Radek Krejci4f28eda2018-11-12 11:46:16 +01001276 /* invalid values */
Radek Krejci096235c2019-01-11 11:12:19 +01001277 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;leaf l {type binary {length -10;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001278 logbuf_assert("Invalid length restriction - value \"-10\" does not fit the type limitations. /aa:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001279 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;leaf l {type binary {length 18446744073709551616;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001280 logbuf_assert("Invalid length restriction - invalid value \"18446744073709551616\". /bb:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001281 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;leaf l {type binary {length \"max .. 10\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001282 logbuf_assert("Invalid length restriction - unexpected data after max keyword (.. 10). /cc:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001283 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;leaf l {type binary {length 50..10;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001284 logbuf_assert("Invalid length restriction - values are not in ascending order (10). /dd:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001285 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;leaf l {type binary {length \"50 | 10\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001286 logbuf_assert("Invalid length restriction - values are not in ascending order (10). /ee:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001287 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;leaf l {type binary {length \"x\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001288 logbuf_assert("Invalid length restriction - unexpected data (x). /ff:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001289 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;leaf l {type binary {length \"50 | min\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001290 logbuf_assert("Invalid length restriction - unexpected data before min keyword (50 | ). /gg:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001291 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh;leaf l {type binary {length \"| 50\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001292 logbuf_assert("Invalid length restriction - unexpected beginning of the expression (| 50). /hh:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001293 assert_null(lys_parse_mem(ctx, "module ii {namespace urn:ii;prefix ii;leaf l {type binary {length \"10 ..\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001294 logbuf_assert("Invalid length restriction - unexpected end of the expression after \"..\" (10 ..). /ii:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001295 assert_null(lys_parse_mem(ctx, "module jj {namespace urn:jj;prefix jj;leaf l {type binary {length \".. 10\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001296 logbuf_assert("Invalid length restriction - unexpected \"..\" without a lower bound. /jj:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001297 assert_null(lys_parse_mem(ctx, "module kk {namespace urn:kk;prefix kk;leaf l {type binary {length \"10 |\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001298 logbuf_assert("Invalid length restriction - unexpected end of the expression (10 |). /kk:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001299 assert_null(lys_parse_mem(ctx, "module kl {namespace urn:kl;prefix kl;leaf l {type binary {length \"10..20 | 15..30\";}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001300 logbuf_assert("Invalid length restriction - values are not in ascending order (15). /kl:l");
Radek Krejcib31c8992018-11-12 16:29:16 +01001301
Radek Krejci096235c2019-01-11 11:12:19 +01001302 assert_null(lys_parse_mem(ctx, "module ll {namespace urn:ll;prefix ll;typedef mytype {type binary {length 10;}}"
1303 "leaf l {type mytype {length 11;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001304 logbuf_assert("Invalid length restriction - the derived restriction (11) is not equally or more limiting. /ll:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001305 assert_null(lys_parse_mem(ctx, "module mm {namespace urn:mm;prefix mm;typedef mytype {type binary {length 10..100;}}"
1306 "leaf l {type mytype {length 1..11;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001307 logbuf_assert("Invalid length restriction - the derived restriction (1..11) is not equally or more limiting. /mm:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001308 assert_null(lys_parse_mem(ctx, "module nn {namespace urn:nn;prefix nn;typedef mytype {type binary {length 10..100;}}"
1309 "leaf l {type mytype {length 20..110;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001310 logbuf_assert("Invalid length restriction - the derived restriction (20..110) is not equally or more limiting. /nn:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001311 assert_null(lys_parse_mem(ctx, "module oo {namespace urn:oo;prefix oo;typedef mytype {type binary {length 10..100;}}"
1312 "leaf l {type mytype {length 20..30|110..120;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001313 logbuf_assert("Invalid length restriction - the derived restriction (20..30|110..120) is not equally or more limiting. /oo:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001314 assert_null(lys_parse_mem(ctx, "module pp {namespace urn:pp;prefix pp;typedef mytype {type binary {length 10..11;}}"
Radek Krejcib31c8992018-11-12 16:29:16 +01001315 "leaf l {type mytype {length 15;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001316 logbuf_assert("Invalid length restriction - the derived restriction (15) is not equally or more limiting. /pp:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001317 assert_null(lys_parse_mem(ctx, "module qq {namespace urn:qq;prefix qq;typedef mytype {type binary {length 10..20|30..40;}}"
Radek Krejcib31c8992018-11-12 16:29:16 +01001318 "leaf l {type mytype {length 15..35;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001319 logbuf_assert("Invalid length restriction - the derived restriction (15..35) is not equally or more limiting. /qq:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001320 assert_null(lys_parse_mem(ctx, "module rr {namespace urn:rr;prefix rr;typedef mytype {type binary {length 10;}}"
Radek Krejci6489bbe2018-11-12 17:05:19 +01001321 "leaf l {type mytype {length 10..35;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001322 logbuf_assert("Invalid length restriction - the derived restriction (10..35) is not equally or more limiting. /rr:l");
Radek Krejcib31c8992018-11-12 16:29:16 +01001323
Radek Krejci327de162019-06-14 12:52:07 +02001324 assert_null(lys_parse_mem(ctx, "module ss {namespace urn:ss;prefix ss;leaf l {type binary {pattern '[0-9]*';}}}", LYS_IN_YANG));
1325 logbuf_assert("Invalid type restrictions for binary type. /ss:l");
Radek Krejci495903e2018-11-13 11:30:45 +01001326
Radek Krejci4f28eda2018-11-12 11:46:16 +01001327 *state = NULL;
1328 ly_ctx_destroy(ctx, NULL);
1329}
1330
Radek Krejcicda74152018-11-13 15:27:32 +01001331static void
1332test_type_pattern(void **state)
1333{
1334 *state = test_type_pattern;
1335
1336 struct ly_ctx *ctx;
1337 struct lys_module *mod;
1338 struct lysc_type *type;
1339
1340 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1341
Radek Krejci027d5802018-11-14 16:57:28 +01001342 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1; namespace urn:a;prefix a;leaf l {type string {"
Radek Krejcicda74152018-11-13 15:27:32 +01001343 "pattern .* {error-app-tag errortag;error-message error;}"
1344 "pattern [0-9].*[0-9] {modifier invert-match;}}}}", LYS_IN_YANG));
Radek Krejcicda74152018-11-13 15:27:32 +01001345 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1346 assert_non_null(type);
1347 assert_non_null(((struct lysc_type_str*)type)->patterns);
1348 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->patterns));
1349 assert_string_equal("errortag", ((struct lysc_type_str*)type)->patterns[0]->eapptag);
1350 assert_string_equal("error", ((struct lysc_type_str*)type)->patterns[0]->emsg);
Radek Krejci54579462019-04-30 12:47:06 +02001351 assert_string_equal(".*", ((struct lysc_type_str*)type)->patterns[0]->expr);
Radek Krejcicda74152018-11-13 15:27:32 +01001352 assert_int_equal(0, ((struct lysc_type_str*)type)->patterns[0]->inverted);
1353 assert_null(((struct lysc_type_str*)type)->patterns[1]->eapptag);
1354 assert_null(((struct lysc_type_str*)type)->patterns[1]->emsg);
Radek Krejci54579462019-04-30 12:47:06 +02001355 assert_string_equal("[0-9].*[0-9]", ((struct lysc_type_str*)type)->patterns[1]->expr);
Radek Krejcicda74152018-11-13 15:27:32 +01001356 assert_int_equal(1, ((struct lysc_type_str*)type)->patterns[1]->inverted);
1357
1358 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;typedef mytype {type string {pattern '[0-9]*';}}"
1359 "typedef mytype2 {type mytype {length 10;}} leaf l {type mytype2 {pattern '[0-4]*';}}}", LYS_IN_YANG));
Radek Krejcicda74152018-11-13 15:27:32 +01001360 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1361 assert_non_null(type);
1362 assert_int_equal(LY_TYPE_STRING, type->basetype);
1363 assert_int_equal(1, type->refcount);
1364 assert_non_null(((struct lysc_type_str*)type)->patterns);
1365 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->patterns));
Radek Krejci54579462019-04-30 12:47:06 +02001366 assert_string_equal("[0-9]*", ((struct lysc_type_str*)type)->patterns[0]->expr);
Radek Krejcicda74152018-11-13 15:27:32 +01001367 assert_int_equal(3, ((struct lysc_type_str*)type)->patterns[0]->refcount);
Radek Krejci54579462019-04-30 12:47:06 +02001368 assert_string_equal("[0-4]*", ((struct lysc_type_str*)type)->patterns[1]->expr);
Radek Krejcicda74152018-11-13 15:27:32 +01001369 assert_int_equal(1, ((struct lysc_type_str*)type)->patterns[1]->refcount);
1370
Radek Krejci04bc1e92018-11-14 14:28:13 +01001371 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c;typedef mytype {type string {pattern '[0-9]*';}}"
1372 "leaf l {type mytype {length 10;}}}", LYS_IN_YANG));
Radek Krejci04bc1e92018-11-14 14:28:13 +01001373 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1374 assert_non_null(type);
1375 assert_int_equal(LY_TYPE_STRING, type->basetype);
1376 assert_int_equal(1, type->refcount);
1377 assert_non_null(((struct lysc_type_str*)type)->patterns);
1378 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->patterns));
Radek Krejci54579462019-04-30 12:47:06 +02001379 assert_string_equal("[0-9]*", ((struct lysc_type_str*)type)->patterns[0]->expr);
Radek Krejci04bc1e92018-11-14 14:28:13 +01001380 assert_int_equal(2, ((struct lysc_type_str*)type)->patterns[0]->refcount);
1381
Radek Krejcicda74152018-11-13 15:27:32 +01001382 /* test substitutions */
Radek Krejci04bc1e92018-11-14 14:28:13 +01001383 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d;leaf l {type string {"
Radek Krejcicda74152018-11-13 15:27:32 +01001384 "pattern '^\\p{IsLatinExtended-A}$';}}}", LYS_IN_YANG));
Radek Krejcicda74152018-11-13 15:27:32 +01001385 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1386 assert_non_null(type);
1387 assert_non_null(((struct lysc_type_str*)type)->patterns);
1388 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_str*)type)->patterns));
Radek Krejci54579462019-04-30 12:47:06 +02001389 assert_string_equal("^\\p{IsLatinExtended-A}$", ((struct lysc_type_str*)type)->patterns[0]->expr);
Radek Krejcicda74152018-11-13 15:27:32 +01001390 /* TODO check some data "^ř$" */
1391
1392 *state = NULL;
1393 ly_ctx_destroy(ctx, NULL);
1394}
1395
Radek Krejci8b764662018-11-14 14:15:13 +01001396static void
1397test_type_enum(void **state)
1398{
1399 *state = test_type_enum;
1400
1401 struct ly_ctx *ctx;
1402 struct lys_module *mod;
1403 struct lysc_type *type;
1404
1405 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1406
Radek Krejci027d5802018-11-14 16:57:28 +01001407 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1; namespace urn:a;prefix a;feature f; leaf l {type enumeration {"
Radek Krejci8b764662018-11-14 14:15:13 +01001408 "enum automin; enum min {value -2147483648;}enum one {if-feature f; value 1;}"
1409 "enum two; enum seven {value 7;}enum eight;}}}", LYS_IN_YANG));
Radek Krejci8b764662018-11-14 14:15:13 +01001410 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1411 assert_non_null(type);
1412 assert_int_equal(LY_TYPE_ENUM, type->basetype);
1413 assert_non_null(((struct lysc_type_enum*)type)->enums);
1414 assert_int_equal(6, LY_ARRAY_SIZE(((struct lysc_type_enum*)type)->enums));
1415 assert_non_null(((struct lysc_type_enum*)type)->enums[2].iffeatures);
1416 assert_string_equal("automin", ((struct lysc_type_enum*)type)->enums[0].name);
1417 assert_int_equal(0, ((struct lysc_type_enum*)type)->enums[0].value);
1418 assert_string_equal("min", ((struct lysc_type_enum*)type)->enums[1].name);
1419 assert_int_equal(-2147483648, ((struct lysc_type_enum*)type)->enums[1].value);
1420 assert_string_equal("one", ((struct lysc_type_enum*)type)->enums[2].name);
1421 assert_int_equal(1, ((struct lysc_type_enum*)type)->enums[2].value);
1422 assert_string_equal("two", ((struct lysc_type_enum*)type)->enums[3].name);
1423 assert_int_equal(2, ((struct lysc_type_enum*)type)->enums[3].value);
1424 assert_string_equal("seven", ((struct lysc_type_enum*)type)->enums[4].name);
1425 assert_int_equal(7, ((struct lysc_type_enum*)type)->enums[4].value);
1426 assert_string_equal("eight", ((struct lysc_type_enum*)type)->enums[5].name);
1427 assert_int_equal(8, ((struct lysc_type_enum*)type)->enums[5].value);
1428
Radek Krejci027d5802018-11-14 16:57:28 +01001429 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1; namespace urn:b;prefix b;feature f; typedef mytype {type enumeration {"
1430 "enum 11; enum min {value -2147483648;}enum x$&;"
Radek Krejci8b764662018-11-14 14:15:13 +01001431 "enum two; enum seven {value 7;}enum eight;}} leaf l { type mytype {enum seven;enum eight;}}}",
1432 LYS_IN_YANG));
Radek Krejci8b764662018-11-14 14:15:13 +01001433 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1434 assert_non_null(type);
1435 assert_int_equal(LY_TYPE_ENUM, type->basetype);
1436 assert_non_null(((struct lysc_type_enum*)type)->enums);
1437 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_enum*)type)->enums));
1438 assert_string_equal("seven", ((struct lysc_type_enum*)type)->enums[0].name);
1439 assert_int_equal(7, ((struct lysc_type_enum*)type)->enums[0].value);
1440 assert_string_equal("eight", ((struct lysc_type_enum*)type)->enums[1].name);
1441 assert_int_equal(8, ((struct lysc_type_enum*)type)->enums[1].value);
1442
1443
1444 /* invalid cases */
Radek Krejci027d5802018-11-14 16:57:28 +01001445 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; feature f; leaf l {type enumeration {"
1446 "enum one {if-feature f;}}}}", LYS_IN_YANG));
1447 logbuf_assert("Invalid keyword \"if-feature\" as a child of \"enum\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
Radek Krejci8b764662018-11-14 14:15:13 +01001448 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1449 "enum one {value -2147483649;}}}}", LYS_IN_YANG));
1450 logbuf_assert("Invalid value \"-2147483649\" of \"value\". Line number 1.");
1451 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1452 "enum one {value 2147483648;}}}}", LYS_IN_YANG));
1453 logbuf_assert("Invalid value \"2147483648\" of \"value\". Line number 1.");
1454 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1455 "enum one; enum one;}}}", LYS_IN_YANG));
1456 logbuf_assert("Duplicate identifier \"one\" of enum statement. Line number 1.");
1457 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1458 "enum '';}}}", LYS_IN_YANG));
1459 logbuf_assert("Enum name must not be zero-length. Line number 1.");
1460 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1461 "enum ' x';}}}", LYS_IN_YANG));
1462 logbuf_assert("Enum name must not have any leading or trailing whitespaces (\" x\"). Line number 1.");
1463 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1464 "enum 'x ';}}}", LYS_IN_YANG));
1465 logbuf_assert("Enum name must not have any leading or trailing whitespaces (\"x \"). Line number 1.");
1466 assert_non_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type enumeration {"
1467 "enum 'inva\nlid';}}}", LYS_IN_YANG));
1468 logbuf_assert("Control characters in enum name should be avoided (\"inva\nlid\", character number 5).");
1469
Radek Krejci096235c2019-01-11 11:12:19 +01001470 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb; leaf l {type enumeration;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001471 logbuf_assert("Missing enum substatement for enumeration type. /bb:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001472
Radek Krejci096235c2019-01-11 11:12:19 +01001473 assert_null(lys_parse_mem(ctx, "module cc {yang-version 1.1;namespace urn:cc;prefix cc;typedef mytype {type enumeration {enum one;}}"
Radek Krejci8b764662018-11-14 14:15:13 +01001474 "leaf l {type mytype {enum two;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001475 logbuf_assert("Invalid enumeration - derived type adds new item \"two\". /cc:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001476
Radek Krejci096235c2019-01-11 11:12:19 +01001477 assert_null(lys_parse_mem(ctx, "module dd {yang-version 1.1;namespace urn:dd;prefix dd;typedef mytype {type enumeration {enum one;}}"
Radek Krejci8b764662018-11-14 14:15:13 +01001478 "leaf l {type mytype {enum one {value 1;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001479 logbuf_assert("Invalid enumeration - value of the item \"one\" has changed from 0 to 1 in the derived type. /dd:l");
Radek Krejci096235c2019-01-11 11:12:19 +01001480 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;leaf l {type enumeration {enum x {value 2147483647;}enum y;}}}",
Radek Krejci8b764662018-11-14 14:15:13 +01001481 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001482 logbuf_assert("Invalid enumeration - it is not possible to auto-assign enum value for \"y\" since the highest value is already 2147483647. /ee:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001483
Radek Krejci096235c2019-01-11 11:12:19 +01001484 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;leaf l {type enumeration {enum x {value 1;}enum y {value 1;}}}}",
Radek Krejci8b764662018-11-14 14:15:13 +01001485 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001486 logbuf_assert("Invalid enumeration - value 1 collide in items \"y\" and \"x\". /ff:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001487
Radek Krejci096235c2019-01-11 11:12:19 +01001488 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;typedef mytype {type enumeration;}"
Radek Krejci04bc1e92018-11-14 14:28:13 +01001489 "leaf l {type mytype {enum one;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001490 logbuf_assert("Missing enum substatement for enumeration type mytype. /gg:l");
Radek Krejci04bc1e92018-11-14 14:28:13 +01001491
Radek Krejci096235c2019-01-11 11:12:19 +01001492 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh; typedef mytype {type enumeration {enum one;}}"
Radek Krejci027d5802018-11-14 16:57:28 +01001493 "leaf l {type mytype {enum one;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001494 logbuf_assert("Enumeration type can be subtyped only in YANG 1.1 modules. /hh:l");
Radek Krejci027d5802018-11-14 16:57:28 +01001495
Radek Krejci8b764662018-11-14 14:15:13 +01001496 *state = NULL;
1497 ly_ctx_destroy(ctx, NULL);
1498}
1499
1500static void
1501test_type_bits(void **state)
1502{
1503 *state = test_type_bits;
1504
1505 struct ly_ctx *ctx;
1506 struct lys_module *mod;
1507 struct lysc_type *type;
1508
1509 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1510
Radek Krejci027d5802018-11-14 16:57:28 +01001511 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1; namespace urn:a;prefix a;feature f; leaf l {type bits {"
Radek Krejci8b764662018-11-14 14:15:13 +01001512 "bit automin; bit one {if-feature f; position 1;}"
1513 "bit two; bit seven {position 7;}bit eight;}}}", LYS_IN_YANG));
Radek Krejci8b764662018-11-14 14:15:13 +01001514 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1515 assert_non_null(type);
1516 assert_int_equal(LY_TYPE_BITS, type->basetype);
1517 assert_non_null(((struct lysc_type_bits*)type)->bits);
1518 assert_int_equal(5, LY_ARRAY_SIZE(((struct lysc_type_bits*)type)->bits));
1519 assert_non_null(((struct lysc_type_bits*)type)->bits[1].iffeatures);
1520 assert_string_equal("automin", ((struct lysc_type_bits*)type)->bits[0].name);
1521 assert_int_equal(0, ((struct lysc_type_bits*)type)->bits[0].position);
1522 assert_string_equal("one", ((struct lysc_type_bits*)type)->bits[1].name);
1523 assert_int_equal(1, ((struct lysc_type_bits*)type)->bits[1].position);
1524 assert_string_equal("two", ((struct lysc_type_bits*)type)->bits[2].name);
1525 assert_int_equal(2, ((struct lysc_type_bits*)type)->bits[2].position);
1526 assert_string_equal("seven", ((struct lysc_type_bits*)type)->bits[3].name);
1527 assert_int_equal(7, ((struct lysc_type_bits*)type)->bits[3].position);
1528 assert_string_equal("eight", ((struct lysc_type_bits*)type)->bits[4].name);
1529 assert_int_equal(8, ((struct lysc_type_bits*)type)->bits[4].position);
1530
Radek Krejci027d5802018-11-14 16:57:28 +01001531 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1;namespace urn:b;prefix b;feature f; typedef mytype {type bits {"
David Sedlák9fb515f2019-07-11 10:33:58 +02001532 "bit automin; bit one;bit two; bit seven {position 7;}bit eight;}} leaf l { type mytype {bit eight;bit seven;bit automin;}}}",
Radek Krejci8b764662018-11-14 14:15:13 +01001533 LYS_IN_YANG));
Radek Krejci8b764662018-11-14 14:15:13 +01001534 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1535 assert_non_null(type);
1536 assert_int_equal(LY_TYPE_BITS, type->basetype);
1537 assert_non_null(((struct lysc_type_bits*)type)->bits);
Radek Krejci027d5802018-11-14 16:57:28 +01001538 assert_int_equal(3, LY_ARRAY_SIZE(((struct lysc_type_bits*)type)->bits));
1539 assert_string_equal("automin", ((struct lysc_type_bits*)type)->bits[0].name);
1540 assert_int_equal(0, ((struct lysc_type_bits*)type)->bits[0].position);
1541 assert_string_equal("seven", ((struct lysc_type_bits*)type)->bits[1].name);
1542 assert_int_equal(7, ((struct lysc_type_bits*)type)->bits[1].position);
1543 assert_string_equal("eight", ((struct lysc_type_bits*)type)->bits[2].name);
1544 assert_int_equal(8, ((struct lysc_type_bits*)type)->bits[2].position);
Radek Krejci8b764662018-11-14 14:15:13 +01001545
1546
1547 /* invalid cases */
Radek Krejci027d5802018-11-14 16:57:28 +01001548 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; feature f; leaf l {type bits {"
1549 "bit one {if-feature f;}}}}", LYS_IN_YANG));
1550 logbuf_assert("Invalid keyword \"if-feature\" as a child of \"bit\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
Radek Krejci8b764662018-11-14 14:15:13 +01001551 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type bits {"
1552 "bit one {position -1;}}}}", LYS_IN_YANG));
1553 logbuf_assert("Invalid value \"-1\" of \"position\". Line number 1.");
1554 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type bits {"
David Sedlák9fb515f2019-07-11 10:33:58 +02001555 "bit one {position 4294967296;}}}}", LYS_IN_YANG));
1556 logbuf_assert("Invalid value \"4294967296\" of \"position\". Line number 1.");
Radek Krejci8b764662018-11-14 14:15:13 +01001557 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type bits {"
1558 "bit one; bit one;}}}", LYS_IN_YANG));
1559 logbuf_assert("Duplicate identifier \"one\" of bit statement. Line number 1.");
1560 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type bits {"
1561 "bit '11';}}}", LYS_IN_YANG));
1562 logbuf_assert("Invalid identifier first character '1'. Line number 1.");
1563 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type bits {"
1564 "bit 'x1$1';}}}", LYS_IN_YANG));
1565 logbuf_assert("Invalid identifier character '$'. Line number 1.");
1566
Radek Krejci096235c2019-01-11 11:12:19 +01001567 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb; leaf l {type bits;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001568 logbuf_assert("Missing bit substatement for bits type. /bb:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001569
Radek Krejci096235c2019-01-11 11:12:19 +01001570 assert_null(lys_parse_mem(ctx, "module cc {yang-version 1.1;namespace urn:cc;prefix cc;typedef mytype {type bits {bit one;}}"
Radek Krejci8b764662018-11-14 14:15:13 +01001571 "leaf l {type mytype {bit two;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001572 logbuf_assert("Invalid bits - derived type adds new item \"two\". /cc:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001573
Radek Krejci096235c2019-01-11 11:12:19 +01001574 assert_null(lys_parse_mem(ctx, "module dd {yang-version 1.1;namespace urn:dd;prefix dd;typedef mytype {type bits {bit one;}}"
Radek Krejci8b764662018-11-14 14:15:13 +01001575 "leaf l {type mytype {bit one {position 1;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001576 logbuf_assert("Invalid bits - position of the item \"one\" has changed from 0 to 1 in the derived type. /dd:l");
1577 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;leaf l {type bits {bit x {position 4294967295;}bit y;}}}", LYS_IN_YANG));
1578 logbuf_assert("Invalid bits - it is not possible to auto-assign bit position for \"y\" since the highest value is already 4294967295. /ee:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001579
David Sedlák9fb515f2019-07-11 10:33:58 +02001580 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;leaf l {type bits {bit x {position 1;}bit y {position 1;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001581 logbuf_assert("Invalid bits - position 1 collide in items \"y\" and \"x\". /ff:l");
Radek Krejci8b764662018-11-14 14:15:13 +01001582
Radek Krejci096235c2019-01-11 11:12:19 +01001583 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;typedef mytype {type bits;}"
Radek Krejci04bc1e92018-11-14 14:28:13 +01001584 "leaf l {type mytype {bit one;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001585 logbuf_assert("Missing bit substatement for bits type mytype. /gg:l");
Radek Krejci04bc1e92018-11-14 14:28:13 +01001586
Radek Krejci096235c2019-01-11 11:12:19 +01001587 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh; typedef mytype {type bits {bit one;}}"
Radek Krejci027d5802018-11-14 16:57:28 +01001588 "leaf l {type mytype {bit one;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001589 logbuf_assert("Bits type can be subtyped only in YANG 1.1 modules. /hh:l");
Radek Krejci027d5802018-11-14 16:57:28 +01001590
Radek Krejci8b764662018-11-14 14:15:13 +01001591 *state = NULL;
1592 ly_ctx_destroy(ctx, NULL);
1593}
1594
Radek Krejci6cba4292018-11-15 17:33:29 +01001595static void
1596test_type_dec64(void **state)
1597{
1598 *state = test_type_dec64;
1599
1600 struct ly_ctx *ctx;
1601 struct lys_module *mod;
1602 struct lysc_type *type;
1603
1604 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1605
1606 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;leaf l {type decimal64 {"
1607 "fraction-digits 2;range min..max;}}}", LYS_IN_YANG));
Radek Krejci6cba4292018-11-15 17:33:29 +01001608 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1609 assert_non_null(type);
1610 assert_int_equal(LY_TYPE_DEC64, type->basetype);
1611 assert_int_equal(2, ((struct lysc_type_dec*)type)->fraction_digits);
1612 assert_non_null(((struct lysc_type_dec*)type)->range);
1613 assert_non_null(((struct lysc_type_dec*)type)->range->parts);
1614 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_dec*)type)->range->parts));
1615 assert_int_equal(INT64_C(-9223372036854775807) - INT64_C(1), ((struct lysc_type_dec*)type)->range->parts[0].min_64);
1616 assert_int_equal(INT64_C(9223372036854775807), ((struct lysc_type_dec*)type)->range->parts[0].max_64);
1617
1618 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;typedef mytype {type decimal64 {"
1619 "fraction-digits 2;range '3.14 | 5.1 | 10';}}leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci6cba4292018-11-15 17:33:29 +01001620 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1621 assert_non_null(type);
1622 assert_int_equal(LY_TYPE_DEC64, type->basetype);
1623 assert_int_equal(2, ((struct lysc_type_dec*)type)->fraction_digits);
1624 assert_non_null(((struct lysc_type_dec*)type)->range);
1625 assert_non_null(((struct lysc_type_dec*)type)->range->parts);
1626 assert_int_equal(3, LY_ARRAY_SIZE(((struct lysc_type_dec*)type)->range->parts));
1627 assert_int_equal(314, ((struct lysc_type_dec*)type)->range->parts[0].min_64);
1628 assert_int_equal(314, ((struct lysc_type_dec*)type)->range->parts[0].max_64);
1629 assert_int_equal(510, ((struct lysc_type_dec*)type)->range->parts[1].min_64);
1630 assert_int_equal(510, ((struct lysc_type_dec*)type)->range->parts[1].max_64);
1631 assert_int_equal(1000, ((struct lysc_type_dec*)type)->range->parts[2].min_64);
1632 assert_int_equal(1000, ((struct lysc_type_dec*)type)->range->parts[2].max_64);
1633
Radek Krejci943177f2019-06-14 16:32:43 +02001634 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c;typedef mytype {type decimal64 {"
1635 "fraction-digits 2;range '1 .. 65535';}}leaf l {type mytype;}}", LYS_IN_YANG));
1636 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1637 assert_int_equal(LY_TYPE_DEC64, type->basetype);
1638 assert_int_equal(2, ((struct lysc_type_dec*)type)->fraction_digits);
1639 assert_non_null(((struct lysc_type_dec*)type)->range);
1640 assert_non_null(((struct lysc_type_dec*)type)->range->parts);
1641 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_dec*)type)->range->parts));
1642 assert_int_equal(100, ((struct lysc_type_dec*)type)->range->parts[0].min_64);
1643 assert_int_equal(6553500, ((struct lysc_type_dec*)type)->range->parts[0].max_64);
1644
Radek Krejci6cba4292018-11-15 17:33:29 +01001645 /* invalid cases */
1646 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type decimal64 {fraction-digits 0;}}}", LYS_IN_YANG));
1647 logbuf_assert("Invalid value \"0\" of \"fraction-digits\". Line number 1.");
1648 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type decimal64 {fraction-digits -1;}}}", LYS_IN_YANG));
1649 logbuf_assert("Invalid value \"-1\" of \"fraction-digits\". Line number 1.");
1650 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type decimal64 {fraction-digits 19;}}}", LYS_IN_YANG));
1651 logbuf_assert("Value \"19\" is out of \"fraction-digits\" bounds. Line number 1.");
1652
Radek Krejci096235c2019-01-11 11:12:19 +01001653 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type decimal64;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001654 logbuf_assert("Missing fraction-digits substatement for decimal64 type. /aa:l");
Radek Krejci6cba4292018-11-15 17:33:29 +01001655
Radek Krejci096235c2019-01-11 11:12:19 +01001656 assert_null(lys_parse_mem(ctx, "module ab {namespace urn:ab;prefix ab; typedef mytype {type decimal64;}leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001657 logbuf_assert("Missing fraction-digits substatement for decimal64 type mytype. /ab:l");
Radek Krejci643c8242018-11-15 17:51:11 +01001658
Radek Krejci096235c2019-01-11 11:12:19 +01001659 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb; leaf l {type decimal64 {fraction-digits 2;"
Radek Krejci6cba4292018-11-15 17:33:29 +01001660 "range '3.142';}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001661 logbuf_assert("Range boundary \"3.142\" of decimal64 type exceeds defined number (2) of fraction digits. /bb:l");
Radek Krejci6cba4292018-11-15 17:33:29 +01001662
Radek Krejci096235c2019-01-11 11:12:19 +01001663 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc; leaf l {type decimal64 {fraction-digits 2;"
Radek Krejci6cba4292018-11-15 17:33:29 +01001664 "range '4 | 3.14';}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001665 logbuf_assert("Invalid range restriction - values are not in ascending order (3.14). /cc:l");
Radek Krejci6cba4292018-11-15 17:33:29 +01001666
Radek Krejci096235c2019-01-11 11:12:19 +01001667 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd; typedef mytype {type decimal64 {fraction-digits 2;}}"
Radek Krejci643c8242018-11-15 17:51:11 +01001668 "leaf l {type mytype {fraction-digits 3;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001669 logbuf_assert("Invalid fraction-digits substatement for type not directly derived from decimal64 built-in type. /dd:l");
Radek Krejci643c8242018-11-15 17:51:11 +01001670
Radek Krejci096235c2019-01-11 11:12:19 +01001671 assert_null(lys_parse_mem(ctx, "module de {namespace urn:de;prefix de; typedef mytype {type decimal64 {fraction-digits 2;}}"
Radek Krejci643c8242018-11-15 17:51:11 +01001672 "typedef mytype2 {type mytype {fraction-digits 3;}}leaf l {type mytype2;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001673 logbuf_assert("Invalid fraction-digits substatement for type \"mytype2\" not directly derived from decimal64 built-in type. /de:l");
Radek Krejci643c8242018-11-15 17:51:11 +01001674
Radek Krejci943177f2019-06-14 16:32:43 +02001675 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:c;prefix c;typedef mytype {type decimal64 {"
1676 "fraction-digits 18;range '-10 .. 0';}}leaf l {type mytype;}}", LYS_IN_YANG));
1677 logbuf_assert("Invalid range restriction - invalid value \"-10000000000000000000\". /ee:l");
1678 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:c;prefix c;typedef mytype {type decimal64 {"
1679 "fraction-digits 18;range '0 .. 10';}}leaf l {type mytype;}}", LYS_IN_YANG));
1680 logbuf_assert("Invalid range restriction - invalid value \"10000000000000000000\". /ee:l");
1681
Radek Krejci6cba4292018-11-15 17:33:29 +01001682 *state = NULL;
1683 ly_ctx_destroy(ctx, NULL);
1684}
1685
Radek Krejci16c0f822018-11-16 10:46:10 +01001686static void
1687test_type_instanceid(void **state)
1688{
1689 *state = test_type_instanceid;
1690
1691 struct ly_ctx *ctx;
1692 struct lys_module *mod;
1693 struct lysc_type *type;
1694
1695 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1696
1697 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;typedef mytype {type instance-identifier {require-instance false;}}"
1698 "leaf l1 {type instance-identifier {require-instance true;}}"
1699 "leaf l2 {type mytype;} leaf l3 {type instance-identifier;}}", LYS_IN_YANG));
Radek Krejci16c0f822018-11-16 10:46:10 +01001700 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1701 assert_non_null(type);
1702 assert_int_equal(LY_TYPE_INST, type->basetype);
1703 assert_int_equal(1, ((struct lysc_type_instanceid*)type)->require_instance);
1704
1705 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
1706 assert_non_null(type);
1707 assert_int_equal(LY_TYPE_INST, type->basetype);
1708 assert_int_equal(0, ((struct lysc_type_instanceid*)type)->require_instance);
1709
1710 type = ((struct lysc_node_leaf*)mod->compiled->data->next->next)->type;
1711 assert_non_null(type);
1712 assert_int_equal(LY_TYPE_INST, type->basetype);
1713 assert_int_equal(1, ((struct lysc_type_instanceid*)type)->require_instance);
1714
1715 /* invalid cases */
1716 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type instance-identifier {require-instance yes;}}}", LYS_IN_YANG));
1717 logbuf_assert("Invalid value \"yes\" of \"require-instance\". Line number 1.");
1718
Radek Krejci096235c2019-01-11 11:12:19 +01001719 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type instance-identifier {fraction-digits 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001720 logbuf_assert("Invalid type restrictions for instance-identifier type. /aa:l");
Radek Krejci16c0f822018-11-16 10:46:10 +01001721
1722 *state = NULL;
1723 ly_ctx_destroy(ctx, NULL);
1724}
1725
Radek Krejci555cb5b2018-11-16 14:54:33 +01001726static void
1727test_type_identityref(void **state)
1728{
1729 *state = test_type_identityref;
1730
1731 struct ly_ctx *ctx;
1732 struct lys_module *mod;
1733 struct lysc_type *type;
1734
1735 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1736
1737 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1;namespace urn:a;prefix a;identity i; identity j; identity k {base i;}"
1738 "typedef mytype {type identityref {base i;}}"
Radek Krejcib83ea3e2018-11-23 14:29:13 +01001739 "leaf l1 {type mytype;} leaf l2 {type identityref {base a:k; base j;}}}", LYS_IN_YANG));
Radek Krejci555cb5b2018-11-16 14:54:33 +01001740 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1741 assert_non_null(type);
1742 assert_int_equal(LY_TYPE_IDENT, type->basetype);
1743 assert_non_null(((struct lysc_type_identityref*)type)->bases);
1744 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_type_identityref*)type)->bases));
1745 assert_string_equal("i", ((struct lysc_type_identityref*)type)->bases[0]->name);
1746
1747 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
1748 assert_non_null(type);
1749 assert_int_equal(LY_TYPE_IDENT, type->basetype);
1750 assert_non_null(((struct lysc_type_identityref*)type)->bases);
1751 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_identityref*)type)->bases));
1752 assert_string_equal("k", ((struct lysc_type_identityref*)type)->bases[0]->name);
1753 assert_string_equal("j", ((struct lysc_type_identityref*)type)->bases[1]->name);
1754
Radek Krejcib83ea3e2018-11-23 14:29:13 +01001755 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1;namespace urn:b;prefix b;import a {prefix a;}"
1756 "leaf l {type identityref {base a:k; base a:j;}}}", LYS_IN_YANG));
Radek Krejcib83ea3e2018-11-23 14:29:13 +01001757 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1758 assert_non_null(type);
1759 assert_int_equal(LY_TYPE_IDENT, type->basetype);
1760 assert_non_null(((struct lysc_type_identityref*)type)->bases);
1761 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_identityref*)type)->bases));
1762 assert_string_equal("k", ((struct lysc_type_identityref*)type)->bases[0]->name);
1763 assert_string_equal("j", ((struct lysc_type_identityref*)type)->bases[1]->name);
1764
Radek Krejci555cb5b2018-11-16 14:54:33 +01001765 /* invalid cases */
Radek Krejci096235c2019-01-11 11:12:19 +01001766 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; leaf l {type identityref;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001767 logbuf_assert("Missing base substatement for identityref type. /aa:l");
Radek Krejci555cb5b2018-11-16 14:54:33 +01001768
Radek Krejci096235c2019-01-11 11:12:19 +01001769 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb; typedef mytype {type identityref;}"
Radek Krejci555cb5b2018-11-16 14:54:33 +01001770 "leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001771 logbuf_assert("Missing base substatement for identityref type mytype. /bb:l");
Radek Krejci555cb5b2018-11-16 14:54:33 +01001772
Radek Krejci096235c2019-01-11 11:12:19 +01001773 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc; identity i; typedef mytype {type identityref {base i;}}"
Radek Krejci555cb5b2018-11-16 14:54:33 +01001774 "leaf l {type mytype {base i;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001775 logbuf_assert("Invalid base substatement for the type not directly derived from identityref built-in type. /cc:l");
Radek Krejci555cb5b2018-11-16 14:54:33 +01001776
Radek Krejci096235c2019-01-11 11:12:19 +01001777 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd; identity i; typedef mytype {type identityref {base i;}}"
Radek Krejci555cb5b2018-11-16 14:54:33 +01001778 "typedef mytype2 {type mytype {base i;}}leaf l {type mytype2;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001779 logbuf_assert("Invalid base substatement for the type \"mytype2\" not directly derived from identityref built-in type. /dd:l");
Radek Krejci555cb5b2018-11-16 14:54:33 +01001780
Radek Krejci096235c2019-01-11 11:12:19 +01001781 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee; identity i; identity j;"
Radek Krejci555cb5b2018-11-16 14:54:33 +01001782 "leaf l {type identityref {base i;base j;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001783 logbuf_assert("Multiple bases in identityref type are allowed only in YANG 1.1 modules. /ee:l");
Radek Krejci555cb5b2018-11-16 14:54:33 +01001784
Radek Krejci096235c2019-01-11 11:12:19 +01001785 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff; identity i;leaf l {type identityref {base j;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001786 logbuf_assert("Unable to find base (j) of identityref. /ff:l");
Radek Krejci322614f2018-11-16 15:05:44 +01001787
Radek Krejci096235c2019-01-11 11:12:19 +01001788 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;leaf l {type identityref {base x:j;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02001789 logbuf_assert("Invalid prefix used for base (x:j) of identityref. /gg:l");
Radek Krejci322614f2018-11-16 15:05:44 +01001790
Radek Krejci555cb5b2018-11-16 14:54:33 +01001791 *state = NULL;
1792 ly_ctx_destroy(ctx, NULL);
1793}
1794
Radek Krejcia3045382018-11-22 14:30:31 +01001795static void
1796test_type_leafref(void **state)
1797{
1798 *state = test_type_leafref;
1799
1800 struct ly_ctx *ctx;
1801 struct lys_module *mod;
1802 struct lysc_type *type;
1803 const char *path, *name, *prefix;
1804 size_t prefix_len, name_len;
1805 int parent_times, has_predicate;
1806
1807 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
1808
1809 /* lys_path_token() */
1810 path = "invalid_path";
1811 parent_times = 0;
1812 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1813 path = "..";
1814 parent_times = 0;
1815 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1816 path = "..[";
1817 parent_times = 0;
1818 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1819 path = "../";
1820 parent_times = 0;
1821 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1822 path = "/";
1823 parent_times = 0;
1824 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1825
1826 path = "../../pref:id/xxx[predicate]/invalid!!!";
1827 parent_times = 0;
1828 assert_int_equal(LY_SUCCESS, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1829 assert_string_equal("/xxx[predicate]/invalid!!!", path);
1830 assert_int_equal(4, prefix_len);
1831 assert_int_equal(0, strncmp("pref", prefix, prefix_len));
1832 assert_int_equal(2, name_len);
1833 assert_int_equal(0, strncmp("id", name, name_len));
1834 assert_int_equal(2, parent_times);
1835 assert_int_equal(0, has_predicate);
1836 assert_int_equal(LY_SUCCESS, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1837 assert_string_equal("[predicate]/invalid!!!", path);
1838 assert_int_equal(0, prefix_len);
1839 assert_null(prefix);
1840 assert_int_equal(3, name_len);
1841 assert_int_equal(0, strncmp("xxx", name, name_len));
1842 assert_int_equal(1, has_predicate);
1843 path += 11;
1844 assert_int_equal(LY_EINVAL, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1845 assert_string_equal("!!!", path);
1846 assert_int_equal(0, prefix_len);
1847 assert_null(prefix);
1848 assert_int_equal(7, name_len);
1849 assert_int_equal(0, strncmp("invalid", name, name_len));
1850
1851 path = "/absolute/prefix:path";
1852 parent_times = 0;
1853 assert_int_equal(LY_SUCCESS, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1854 assert_string_equal("/prefix:path", path);
1855 assert_int_equal(0, prefix_len);
1856 assert_null(prefix);
1857 assert_int_equal(8, name_len);
1858 assert_int_equal(0, strncmp("absolute", name, name_len));
1859 assert_int_equal(-1, parent_times);
1860 assert_int_equal(0, has_predicate);
1861 assert_int_equal(LY_SUCCESS, lys_path_token(&path, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate));
1862 assert_int_equal(0, *path);
1863 assert_int_equal(6, prefix_len);
1864 assert_int_equal(0, strncmp("prefix", prefix, prefix_len));
1865 assert_int_equal(4, name_len);
1866 assert_int_equal(0, strncmp("path", name, name_len));
1867 assert_int_equal(0, has_predicate);
1868
1869 /* complete leafref paths */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001870 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1;namespace urn:a;prefix a;"
Radek Krejcia3045382018-11-22 14:30:31 +01001871 "leaf ref1 {type leafref {path /a:target1;}} leaf ref2 {type leafref {path /a/target2; require-instance false;}}"
1872 "leaf target1 {type string;}container a {leaf target2 {type uint8;}}}", LYS_IN_YANG));
Radek Krejcia3045382018-11-22 14:30:31 +01001873 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1874 assert_non_null(type);
1875 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1876 assert_string_equal("/a:target1", ((struct lysc_type_leafref*)type)->path);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001877 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001878 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1879 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref*)type)->realtype->basetype);
Radek Krejcia3045382018-11-22 14:30:31 +01001880 assert_int_equal(1, ((struct lysc_type_leafref*)type)->require_instance);
1881 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
1882 assert_non_null(type);
1883 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1884 assert_string_equal("/a/target2", ((struct lysc_type_leafref*)type)->path);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001885 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1886 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1887 assert_int_equal(LY_TYPE_UINT8, ((struct lysc_type_leafref*)type)->realtype->basetype);
Radek Krejcia3045382018-11-22 14:30:31 +01001888 assert_int_equal(0, ((struct lysc_type_leafref*)type)->require_instance);
1889
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001890 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b; typedef mytype {type leafref {path /b:target;}}"
Radek Krejci4ce68932018-11-28 12:53:36 +01001891 "typedef mytype2 {type mytype;} typedef mytype3 {type leafref {path /target;}} leaf ref {type mytype2;}"
Radek Krejci6be5ff12018-11-26 13:18:15 +01001892 "leaf target {type leafref {path ../realtarget;}} leaf realtarget {type string;}}", LYS_IN_YANG));
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001893 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1894 assert_non_null(type);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001895 assert_int_equal(1, type->refcount);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001896 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1897 assert_string_equal("/b:target", ((struct lysc_type_leafref* )type)->path);
1898 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001899 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1900 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref*)type)->realtype->basetype);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001901 assert_int_equal(1, ((struct lysc_type_leafref* )type)->require_instance);
1902
1903 /* prefixes are reversed to check using correct context of the path! */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001904 assert_non_null(mod = lys_parse_mem(ctx, "module c {yang-version 1.1;namespace urn:c;prefix b; import b {prefix c;}"
Radek Krejci2f4a0292018-11-22 15:41:53 +01001905 "typedef mytype3 {type c:mytype {require-instance false;}}"
1906 "leaf ref1 {type b:mytype3;}leaf ref2 {type c:mytype2;}}", LYS_IN_YANG));
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001907 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1908 assert_non_null(type);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001909 assert_int_equal(1, type->refcount);
Radek Krejci2f4a0292018-11-22 15:41:53 +01001910 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1911 assert_string_equal("/b:target", ((struct lysc_type_leafref* )type)->path);
1912 assert_ptr_not_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001913 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1914 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref*)type)->realtype->basetype);
Radek Krejci2f4a0292018-11-22 15:41:53 +01001915 assert_int_equal(0, ((struct lysc_type_leafref* )type)->require_instance);
1916 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
1917 assert_non_null(type);
Radek Krejci412ddfa2018-11-23 11:44:11 +01001918 assert_int_equal(1, type->refcount);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001919 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1920 assert_string_equal("/b:target", ((struct lysc_type_leafref* )type)->path);
1921 assert_ptr_not_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1922 assert_int_equal(1, ((struct lysc_type_leafref* )type)->require_instance);
1923
Radek Krejci4ce68932018-11-28 12:53:36 +01001924 /* non-prefixed nodes in path are supposed to be from the module where the leafref type is instantiated */
1925 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d; import b {prefix b;}"
1926 "leaf ref {type b:mytype3;}leaf target {type int8;}}", LYS_IN_YANG));
Radek Krejci4ce68932018-11-28 12:53:36 +01001927 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1928 assert_non_null(type);
1929 assert_int_equal(1, type->refcount);
1930 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1931 assert_string_equal("/target", ((struct lysc_type_leafref* )type)->path);
1932 assert_ptr_not_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1933 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1934 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_leafref*)type)->realtype->basetype);
1935 assert_int_equal(1, ((struct lysc_type_leafref* )type)->require_instance);
1936
Radek Krejci58d171e2018-11-23 13:50:55 +01001937 /* conditional leafrefs */
Radek Krejci4ce68932018-11-28 12:53:36 +01001938 assert_non_null(mod = lys_parse_mem(ctx, "module e {yang-version 1.1;namespace urn:e;prefix e;feature f1; feature f2;"
Radek Krejci58d171e2018-11-23 13:50:55 +01001939 "leaf ref1 {if-feature 'f1 and f2';type leafref {path /target;}}"
1940 "leaf target {if-feature f1; type boolean;}}", LYS_IN_YANG));
Radek Krejci58d171e2018-11-23 13:50:55 +01001941 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1942 assert_non_null(type);
1943 assert_int_equal(1, type->refcount);
1944 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1945 assert_string_equal("/target", ((struct lysc_type_leafref* )type)->path);
1946 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1947 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1948 assert_int_equal(LY_TYPE_BOOL, ((struct lysc_type_leafref*)type)->realtype->basetype);
1949
Radek Krejci7adf4ff2018-12-05 08:55:00 +01001950 assert_non_null(mod = lys_parse_mem(ctx, "module f {namespace urn:f;prefix f;"
1951 "list interface{key name;leaf name{type string;}list address {key ip;leaf ip {type string;}}}"
1952 "container default-address{leaf ifname{type leafref{ path \"../../interface/name\";}}"
Radek Krejcibade82a2018-12-05 10:13:48 +01001953 "leaf address {type leafref{ path \"../../interface[ name = current()/../ifname ]/address/ip\";}}}}",
Radek Krejci7adf4ff2018-12-05 08:55:00 +01001954 LYS_IN_YANG));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001955 type = ((struct lysc_node_leaf*)(*lysc_node_children_p(mod->compiled->data->prev, 0))->prev)->type;
Radek Krejci7adf4ff2018-12-05 08:55:00 +01001956 assert_non_null(type);
1957 assert_int_equal(1, type->refcount);
1958 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
Radek Krejcibade82a2018-12-05 10:13:48 +01001959 assert_string_equal("../../interface[ name = current()/../ifname ]/address/ip", ((struct lysc_type_leafref* )type)->path);
Radek Krejci7adf4ff2018-12-05 08:55:00 +01001960 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1961 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1962 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref*)type)->realtype->basetype);
Radek Krejcia3045382018-11-22 14:30:31 +01001963
Radek Krejci20e8a182018-12-07 11:43:21 +01001964 assert_non_null(mod = lys_parse_mem(ctx, "module g {namespace urn:g;prefix g;"
1965 "leaf source {type leafref {path \"/endpoint-parent[id=current()/../field]/endpoint/name\";}}"
1966 "leaf field {type int32;}list endpoint-parent {key id;leaf id {type int32;}"
1967 "list endpoint {key name;leaf name {type string;}}}}", LYS_IN_YANG));
Radek Krejci20e8a182018-12-07 11:43:21 +01001968 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1969 assert_non_null(type);
1970 assert_int_equal(1, type->refcount);
1971 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1972 assert_string_equal("/endpoint-parent[id=current()/../field]/endpoint/name", ((struct lysc_type_leafref* )type)->path);
1973 assert_ptr_equal(mod, ((struct lysc_type_leafref*)type)->path_context);
1974 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1975 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref*)type)->realtype->basetype);
1976
Radek Krejci3d929562019-02-21 11:25:55 +01001977 /* leafref to imported (not yet implemented) module */
1978 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module h {namespace urn:h;prefix h; leaf h {type uint16;}}");
1979 assert_non_null(mod = lys_parse_mem(ctx, "module i {namespace urn:i;prefix i;import h {prefix h;}"
1980 "leaf i {type leafref {path /h:h;}}}", LYS_IN_YANG));
1981 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1982 assert_non_null(type);
1983 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1984 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1985 assert_int_equal(LY_TYPE_UINT16, ((struct lysc_type_leafref*)type)->realtype->basetype);
1986 assert_non_null(mod = ly_ctx_get_module_implemented(ctx, "h"));
1987 assert_int_equal(1, mod->implemented);
1988 assert_non_null(mod->compiled->data);
1989 assert_string_equal("h", mod->compiled->data->name);
1990
Radek Krejci92cc8512019-04-25 09:57:06 +02001991 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module j {namespace urn:j;prefix j; leaf j {type string;}}");
1992 assert_non_null(mod = lys_parse_mem(ctx, "module k {namespace urn:k;prefix k;import j {prefix j;}"
1993 "leaf i {type leafref {path \"/ilist[name = current()/../j:j]/value\";}}"
1994 "list ilist {key name; leaf name {type string;} leaf value {type uint16;}}}", LYS_IN_YANG));
1995 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
1996 assert_non_null(type);
1997 assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
1998 assert_non_null(((struct lysc_type_leafref*)type)->realtype);
1999 assert_int_equal(LY_TYPE_UINT16, ((struct lysc_type_leafref*)type)->realtype->basetype);
2000 assert_non_null(mod = ly_ctx_get_module_implemented(ctx, "j"));
2001 assert_int_equal(1, mod->implemented);
2002 assert_non_null(mod->compiled->data);
2003 assert_string_equal("j", mod->compiled->data->name);
2004
Radek Krejcia3045382018-11-22 14:30:31 +01002005 /* invalid paths */
Radek Krejci096235c2019-01-11 11:12:19 +01002006 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002007 "leaf ref1 {type leafref {path ../a/invalid;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002008 logbuf_assert("Invalid leafref path - unable to find \"../a/invalid\". /aa:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002009 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002010 "leaf ref1 {type leafref {path ../../toohigh;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002011 logbuf_assert("Invalid leafref path \"../../toohigh\" - too many \"..\" in the path. /bb:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002012 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002013 "leaf ref1 {type leafref {path /a:invalid;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002014 logbuf_assert("Invalid leafref path - unable to find module connected with the prefix of the node \"/a:invalid\". /cc:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002015 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;leaf target1 {type string;}container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002016 "leaf ref1 {type leafref {path '/a[target2 = current()/../target1]/target2';}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002017 logbuf_assert("Invalid leafref path - node \"/a\" is expected to be a list, but it is container. /dd:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002018 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002019 "leaf ref1 {type leafref {path /a!invalid;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002020 logbuf_assert("Invalid leafref path at character 3 (/a!invalid). /ee:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002021 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;container a {leaf target2 {type uint8;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002022 "leaf ref1 {type leafref {path /a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002023 logbuf_assert("Invalid leafref path \"/a\" - target node is container instead of leaf or leaf-list. /ff:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002024 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;container a {leaf target2 {type uint8; status deprecated;}}"
Radek Krejcia3045382018-11-22 14:30:31 +01002025 "leaf ref1 {type leafref {path /a/target2;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002026 logbuf_assert("A current definition \"ref1\" is not allowed to reference deprecated definition \"target2\". /gg:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002027 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh;"
Radek Krejci2f4a0292018-11-22 15:41:53 +01002028 "leaf ref1 {type leafref;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002029 logbuf_assert("Missing path substatement for leafref type. /hh:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002030 assert_null(lys_parse_mem(ctx, "module ii {namespace urn:ii;prefix ii;typedef mytype {type leafref;}"
Radek Krejci2f4a0292018-11-22 15:41:53 +01002031 "leaf ref1 {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002032 logbuf_assert("Missing path substatement for leafref type mytype. /ii:ref1");
Radek Krejci096235c2019-01-11 11:12:19 +01002033 assert_null(lys_parse_mem(ctx, "module jj {namespace urn:jj;prefix jj;feature f;"
Radek Krejci58d171e2018-11-23 13:50:55 +01002034 "leaf ref {type leafref {path /target;}}leaf target {if-feature f;type string;}}", LYS_IN_YANG));
Radek Krejci58d171e2018-11-23 13:50:55 +01002035 logbuf_assert("Invalid leafref path \"/target\" - set of features applicable to the leafref target is not a subset of features "
Radek Krejci327de162019-06-14 12:52:07 +02002036 "applicable to the leafref itself. /jj:ref");
Radek Krejci096235c2019-01-11 11:12:19 +01002037 assert_null(lys_parse_mem(ctx, "module kk {namespace urn:kk;prefix kk;"
Radek Krejcib57cf1e2018-11-23 14:07:05 +01002038 "leaf ref {type leafref {path /target;}}leaf target {type string;config false;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002039 logbuf_assert("Invalid leafref path \"/target\" - target is supposed to represent configuration data (as the leafref does), but it does not. /kk:ref");
Radek Krejci58d171e2018-11-23 13:50:55 +01002040
Radek Krejci096235c2019-01-11 11:12:19 +01002041 assert_null(lys_parse_mem(ctx, "module ll {namespace urn:ll;prefix ll;"
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002042 "leaf ref {type leafref {path /target; require-instance true;}}leaf target {type string;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002043 logbuf_assert("Leafref type can be restricted by require-instance statement only in YANG 1.1 modules. /ll:ref");
Radek Krejci096235c2019-01-11 11:12:19 +01002044 assert_null(lys_parse_mem(ctx, "module mm {namespace urn:mm;prefix mm;typedef mytype {type leafref {path /target;require-instance false;}}"
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002045 "leaf ref {type mytype;}leaf target {type string;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002046 logbuf_assert("Leafref type \"mytype\" can be restricted by require-instance statement only in YANG 1.1 modules. /mm:ref");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002047
Radek Krejci096235c2019-01-11 11:12:19 +01002048 assert_null(lys_parse_mem(ctx, "module nn {namespace urn:nn;prefix nn;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002049 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2050 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2051 "leaf address {type leafref{ path \"/interface[name is current()/../ifname]/ip\";}}}",
2052 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002053 logbuf_assert("Invalid leafref path predicate \"[name i\" - missing \"=\" after node-identifier. /nn:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002054
Radek Krejci096235c2019-01-11 11:12:19 +01002055 assert_null(lys_parse_mem(ctx, "module oo {namespace urn:oo;prefix oo;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002056 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2057 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2058 "leaf address {type leafref{ path \"/interface[name=current()/../ifname/ip\";}}}",
2059 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002060 logbuf_assert("Invalid leafref path predicate \"[name=current()/../ifname/ip\" - missing predicate termination. /oo:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002061
Radek Krejci096235c2019-01-11 11:12:19 +01002062 assert_null(lys_parse_mem(ctx, "module pp {namespace urn:pp;prefix pp;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002063 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2064 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2065 "leaf address {type leafref{ path \"/interface[x:name=current()/../ifname]/ip\";}}}",
2066 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002067 logbuf_assert("Invalid leafref path predicate \"[x:name=current()/../ifname]\" - prefix \"x\" not defined in module \"pp\". /pp:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002068
Radek Krejci096235c2019-01-11 11:12:19 +01002069 assert_null(lys_parse_mem(ctx, "module qq {namespace urn:qq;prefix qq;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002070 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2071 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2072 "leaf address {type leafref{ path \"/interface[id=current()/../ifname]/ip\";}}}",
2073 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002074 logbuf_assert("Invalid leafref path predicate \"[id=current()/../ifname]\" - predicate's key node \"id\" not found. /qq:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002075
Radek Krejci096235c2019-01-11 11:12:19 +01002076 assert_null(lys_parse_mem(ctx, "module rr {namespace urn:rr;prefix rr;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002077 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2078 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2079 "leaf address {type leafref{ path \"/interface[name=current() / .. / ifname][name=current()/../test]/ip\";}}}",
2080 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002081 logbuf_assert("Invalid leafref path predicate \"[name=current()/../test]\" - multiple equality tests for the key \"name\". /rr:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002082
Radek Krejci096235c2019-01-11 11:12:19 +01002083 assert_null(lys_parse_mem(ctx, "module ss {namespace urn:ss;prefix ss;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002084 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2085 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2086 "leaf address {type leafref{ path \"/interface[name = ../ifname]/ip\";}}}",
2087 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002088 logbuf_assert("Invalid leafref path predicate \"[name = ../ifname]\" - missing current-function-invocation. /ss:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002089
Radek Krejci096235c2019-01-11 11:12:19 +01002090 assert_null(lys_parse_mem(ctx, "module tt {namespace urn:tt;prefix tt;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002091 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2092 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2093 "leaf address {type leafref{ path \"/interface[name = current()../ifname]/ip\";}}}",
2094 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002095 logbuf_assert("Invalid leafref path predicate \"[name = current()../ifname]\" - missing \"/\" after current-function-invocation. /tt:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002096
Radek Krejci096235c2019-01-11 11:12:19 +01002097 assert_null(lys_parse_mem(ctx, "module uu {namespace urn:uu;prefix uu;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002098 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2099 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2100 "leaf address {type leafref{ path \"/interface[name = current()/..ifname]/ip\";}}}",
2101 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002102 logbuf_assert("Invalid leafref path predicate \"[name = current()/..ifname]\" - missing \"/\" in \"../\" rel-path-keyexpr pattern. /uu:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002103
Radek Krejci096235c2019-01-11 11:12:19 +01002104 assert_null(lys_parse_mem(ctx, "module vv {namespace urn:vv;prefix vv;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002105 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2106 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2107 "leaf address {type leafref{ path \"/interface[name = current()/ifname]/ip\";}}}",
2108 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002109 logbuf_assert("Invalid leafref path predicate \"[name = current()/ifname]\" - at least one \"..\" is expected in rel-path-keyexpr. /vv:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002110
Radek Krejci096235c2019-01-11 11:12:19 +01002111 assert_null(lys_parse_mem(ctx, "module ww {namespace urn:ww;prefix ww;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002112 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2113 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2114 "leaf address {type leafref{ path \"/interface[name = current()/../]/ip\";}}}",
2115 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002116 logbuf_assert("Invalid leafref path predicate \"[name = current()/../]\" - at least one node-identifier is expected in rel-path-keyexpr. /ww:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002117
Radek Krejci096235c2019-01-11 11:12:19 +01002118 assert_null(lys_parse_mem(ctx, "module xx {namespace urn:xx;prefix xx;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002119 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2120 "leaf ifname{type leafref{ path \"../interface/name\";}}leaf test{type string;}"
2121 "leaf address {type leafref{ path \"/interface[name = current()/../$node]/ip\";}}}",
2122 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002123 logbuf_assert("Invalid node identifier in leafref path predicate - character 22 (of [name = current()/../$node]). /xx:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002124
Radek Krejci096235c2019-01-11 11:12:19 +01002125 assert_null(lys_parse_mem(ctx, "module yy {namespace urn:yy;prefix yy;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002126 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2127 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2128 "leaf address {type leafref{ path \"/interface[name=current()/../x:ifname]/ip\";}}}",
2129 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002130 logbuf_assert("Invalid leafref path predicate \"[name=current()/../x:ifname]\" - unable to find module of the node \"ifname\" in rel-path-keyexpr. /yy:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002131
Radek Krejci096235c2019-01-11 11:12:19 +01002132 assert_null(lys_parse_mem(ctx, "module zz {namespace urn:zz;prefix zz;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002133 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2134 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2135 "leaf address {type leafref{ path \"/interface[name=current()/../xxx]/ip\";}}}",
2136 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002137 logbuf_assert("Invalid leafref path predicate \"[name=current()/../xxx]\" - unable to find node \"current()/../xxx\" in the rel-path-keyexpr. /zz:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002138
Radek Krejci096235c2019-01-11 11:12:19 +01002139 assert_null(lys_parse_mem(ctx, "module zza {namespace urn:zza;prefix zza;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002140 "list interface{key name;leaf name{type string;}leaf ip {type string;}}"
2141 "leaf ifname{type leafref{ path \"../interface/name\";}}container c;"
2142 "leaf address {type leafref{ path \"/interface[name=current()/../c]/ip\";}}}",
2143 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002144 logbuf_assert("Invalid leafref path predicate \"[name=current()/../c]\" - rel-path-keyexpr \"current()/../c\" refers container instead of leaf. /zza:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002145
Radek Krejci096235c2019-01-11 11:12:19 +01002146 assert_null(lys_parse_mem(ctx, "module zzb {namespace urn:zzb;prefix zzb;"
Radek Krejcibade82a2018-12-05 10:13:48 +01002147 "list interface{key name;leaf name{type string;}leaf ip {type string;}container c;}"
2148 "leaf ifname{type leafref{ path \"../interface/name\";}}"
2149 "leaf address {type leafref{ path \"/interface[c=current()/../ifname]/ip\";}}}",
2150 LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002151 logbuf_assert("Invalid leafref path predicate \"[c=current()/../ifname]\" - predicate's key node \"c\" not found. /zzb:address");
Radek Krejcibade82a2018-12-05 10:13:48 +01002152
Radek Krejci412ddfa2018-11-23 11:44:11 +01002153 /* circular chain */
Radek Krejci096235c2019-01-11 11:12:19 +01002154 assert_null(lys_parse_mem(ctx, "module aaa {namespace urn:aaa;prefix aaa;"
Radek Krejci412ddfa2018-11-23 11:44:11 +01002155 "leaf ref1 {type leafref {path /ref2;}}"
2156 "leaf ref2 {type leafref {path /ref3;}}"
Radek Krejci0c3f1ad2018-11-23 14:19:38 +01002157 "leaf ref3 {type leafref {path /ref4;}}"
2158 "leaf ref4 {type leafref {path /ref1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002159 logbuf_assert("Invalid leafref path \"/ref1\" - circular chain of leafrefs detected. /aaa:ref4");
Radek Krejci412ddfa2018-11-23 11:44:11 +01002160
Radek Krejcia3045382018-11-22 14:30:31 +01002161 *state = NULL;
2162 ly_ctx_destroy(ctx, NULL);
2163}
2164
Radek Krejci43699232018-11-23 14:59:46 +01002165static void
2166test_type_empty(void **state)
2167{
2168 *state = test_type_empty;
2169
2170 struct ly_ctx *ctx;
Radek Krejci43699232018-11-23 14:59:46 +01002171
2172 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2173
2174 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +01002175 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;"
Radek Krejci43699232018-11-23 14:59:46 +01002176 "leaf l {type empty; default x;}}", LYS_IN_YANG));
Radek Krejcia1911222019-07-22 17:24:50 +02002177 logbuf_assert("Invalid leaf's default value \"x\" which does not fit the type (Invalid empty value \"x\".). /aa:l");
Radek Krejci43699232018-11-23 14:59:46 +01002178
Radek Krejci096235c2019-01-11 11:12:19 +01002179 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;typedef mytype {type empty; default x;}"
Radek Krejci43699232018-11-23 14:59:46 +01002180 "leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002181 logbuf_assert("Invalid type \"mytype\" - \"empty\" type must not have a default value (x). /bb:l");
Radek Krejci43699232018-11-23 14:59:46 +01002182
2183 *state = NULL;
2184 ly_ctx_destroy(ctx, NULL);
2185}
2186
Radek Krejcicdfecd92018-11-26 11:27:32 +01002187
2188static void
2189test_type_union(void **state)
2190{
2191 *state = test_type_union;
2192
2193 struct ly_ctx *ctx;
2194 struct lys_module *mod;
2195 struct lysc_type *type;
2196
2197 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2198
2199 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1;namespace urn:a;prefix a; typedef mybasetype {type string;}"
2200 "typedef mytype {type union {type int8; type mybasetype;}}"
2201 "leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002202 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2203 assert_non_null(type);
2204 assert_int_equal(2, type->refcount);
2205 assert_int_equal(LY_TYPE_UNION, type->basetype);
2206 assert_non_null(((struct lysc_type_union*)type)->types);
2207 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_union*)type)->types));
2208 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_union*)type)->types[0]->basetype);
2209 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_union*)type)->types[1]->basetype);
2210
2211 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1;namespace urn:b;prefix b; typedef mybasetype {type string;}"
2212 "typedef mytype {type union {type int8; type mybasetype;}}"
2213 "leaf l {type union {type decimal64 {fraction-digits 2;} type mytype;}}}", LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002214 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2215 assert_non_null(type);
2216 assert_int_equal(1, type->refcount);
2217 assert_int_equal(LY_TYPE_UNION, type->basetype);
2218 assert_non_null(((struct lysc_type_union*)type)->types);
2219 assert_int_equal(3, LY_ARRAY_SIZE(((struct lysc_type_union*)type)->types));
2220 assert_int_equal(LY_TYPE_DEC64, ((struct lysc_type_union*)type)->types[0]->basetype);
2221 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_union*)type)->types[1]->basetype);
2222 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_union*)type)->types[2]->basetype);
2223
2224 assert_non_null(mod = lys_parse_mem(ctx, "module c {yang-version 1.1;namespace urn:c;prefix c; typedef mybasetype {type string;}"
2225 "typedef mytype {type union {type leafref {path ../target;} type mybasetype;}}"
Radek Krejci6be5ff12018-11-26 13:18:15 +01002226 "leaf l {type union {type decimal64 {fraction-digits 2;} type mytype;}}"
2227 "leaf target {type leafref {path ../realtarget;}} leaf realtarget {type int8;}}",
Radek Krejcicdfecd92018-11-26 11:27:32 +01002228 LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002229 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2230 assert_non_null(type);
2231 assert_int_equal(1, type->refcount);
2232 assert_int_equal(LY_TYPE_UNION, type->basetype);
2233 assert_non_null(((struct lysc_type_union*)type)->types);
2234 assert_int_equal(3, LY_ARRAY_SIZE(((struct lysc_type_union*)type)->types));
2235 assert_int_equal(LY_TYPE_DEC64, ((struct lysc_type_union*)type)->types[0]->basetype);
2236 assert_int_equal(LY_TYPE_LEAFREF, ((struct lysc_type_union*)type)->types[1]->basetype);
2237 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_union*)type)->types[2]->basetype);
2238 assert_non_null(((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[1])->realtype);
2239 assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[1])->realtype->basetype);
2240
Radek Krejci6be5ff12018-11-26 13:18:15 +01002241 /* invalid unions */
Radek Krejci096235c2019-01-11 11:12:19 +01002242 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;typedef mytype {type union;}"
Radek Krejci6be5ff12018-11-26 13:18:15 +01002243 "leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002244 logbuf_assert("Missing type substatement for union type mytype. /aa:l");
Radek Krejci6be5ff12018-11-26 13:18:15 +01002245
Radek Krejci096235c2019-01-11 11:12:19 +01002246 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;leaf l {type union;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002247 logbuf_assert("Missing type substatement for union type. /bb:l");
Radek Krejci6be5ff12018-11-26 13:18:15 +01002248
Radek Krejci096235c2019-01-11 11:12:19 +01002249 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;typedef mytype {type union{type int8; type string;}}"
Radek Krejci6be5ff12018-11-26 13:18:15 +01002250 "leaf l {type mytype {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002251 logbuf_assert("Invalid type substatement for the type not directly derived from union built-in type. /cc:l");
Radek Krejci6be5ff12018-11-26 13:18:15 +01002252
Radek Krejci096235c2019-01-11 11:12:19 +01002253 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;typedef mytype {type union{type int8; type string;}}"
Radek Krejci6be5ff12018-11-26 13:18:15 +01002254 "typedef mytype2 {type mytype {type string;}}leaf l {type mytype2;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002255 logbuf_assert("Invalid type substatement for the type \"mytype2\" not directly derived from union built-in type. /dd:l");
Radek Krejci6be5ff12018-11-26 13:18:15 +01002256
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002257 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;typedef mytype {type union{type mytype; type string;}}"
2258 "leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002259 logbuf_assert("Invalid \"mytype\" type reference - circular chain of types detected. /ee:l");
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002260 assert_null(lys_parse_mem(ctx, "module ef {namespace urn:ef;prefix ef;typedef mytype {type mytype2;}"
2261 "typedef mytype2 {type mytype;} leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002262 logbuf_assert("Invalid \"mytype\" type reference - circular chain of types detected. /ef:l");
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002263
Radek Krejcicdfecd92018-11-26 11:27:32 +01002264 *state = NULL;
2265 ly_ctx_destroy(ctx, NULL);
2266}
2267
2268static void
2269test_type_dflt(void **state)
2270{
2271 *state = test_type_union;
2272
2273 struct ly_ctx *ctx;
2274 struct lys_module *mod;
2275 struct lysc_type *type;
Radek Krejcia1911222019-07-22 17:24:50 +02002276 struct lysc_node_leaf *leaf;
2277 int dynamic;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002278
2279 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2280
2281 /* default is not inherited from union's types */
2282 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a; typedef mybasetype {type string;default hello;units xxx;}"
2283 "leaf l {type union {type decimal64 {fraction-digits 2;} type mybasetype;}}}", LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002284 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2285 assert_non_null(type);
2286 assert_int_equal(1, type->refcount);
2287 assert_int_equal(LY_TYPE_UNION, type->basetype);
2288 assert_non_null(((struct lysc_type_union*)type)->types);
2289 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_type_union*)type)->types));
2290 assert_int_equal(LY_TYPE_DEC64, ((struct lysc_type_union*)type)->types[0]->basetype);
2291 assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_union*)type)->types[1]->basetype);
2292 assert_null(((struct lysc_node_leaf*)mod->compiled->data)->dflt);
2293 assert_null(((struct lysc_node_leaf*)mod->compiled->data)->units);
2294
2295 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b; typedef mybasetype {type string;default hello;units xxx;}"
2296 "leaf l {type mybasetype;}}", LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002297 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2298 assert_non_null(type);
Radek Krejcia1911222019-07-22 17:24:50 +02002299 assert_int_equal(3, type->refcount); /* 2x type reference, 1x default value's reference (typedf's default does not reference own type)*/
Radek Krejcicdfecd92018-11-26 11:27:32 +01002300 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejci812a5bf2019-09-09 09:18:05 +02002301 assert_non_null(leaf = (struct lysc_node_leaf*)mod->compiled->data);
Radek Krejcia1911222019-07-22 17:24:50 +02002302 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2303 assert_int_equal(0, dynamic);
2304 assert_string_equal("xxx", leaf->units);
Radek Krejcicdfecd92018-11-26 11:27:32 +01002305
2306 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c; typedef mybasetype {type string;default hello;units xxx;}"
2307 "leaf l {type mybasetype; default goodbye;units yyy;}}", LYS_IN_YANG));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002308 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2309 assert_non_null(type);
Radek Krejcia1911222019-07-22 17:24:50 +02002310 assert_int_equal(3, type->refcount); /* 2x type reference, 1x default value's reference */
Radek Krejcicdfecd92018-11-26 11:27:32 +01002311 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejcia1911222019-07-22 17:24:50 +02002312 leaf = (struct lysc_node_leaf*)mod->compiled->data;
2313 assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2314 assert_int_equal(0, dynamic);
2315 assert_string_equal("yyy", leaf->units);
Radek Krejcicdfecd92018-11-26 11:27:32 +01002316
Radek Krejci6be5ff12018-11-26 13:18:15 +01002317 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d; typedef mybasetype {type string;default hello;units xxx;}"
2318 "typedef mytype {type mybasetype;}leaf l1 {type mytype; default goodbye;units yyy;}"
2319 "leaf l2 {type mytype;}}", LYS_IN_YANG));
Radek Krejci6be5ff12018-11-26 13:18:15 +01002320 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2321 assert_non_null(type);
Radek Krejcia1911222019-07-22 17:24:50 +02002322 assert_int_equal(6, type->refcount); /* 4x type reference, 2x default value's reference (1 shared compiled type of typedefs which default does not reference own type) */
Radek Krejci6be5ff12018-11-26 13:18:15 +01002323 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejcia1911222019-07-22 17:24:50 +02002324 leaf = (struct lysc_node_leaf*)mod->compiled->data;
2325 assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2326 assert_int_equal(0, dynamic);
2327 assert_string_equal("yyy", leaf->units);
Radek Krejci6be5ff12018-11-26 13:18:15 +01002328 type = ((struct lysc_node_leaf*)mod->compiled->data->next)->type;
2329 assert_non_null(type);
Radek Krejcia1911222019-07-22 17:24:50 +02002330 assert_int_equal(6, type->refcount); /* 4x type reference, 2x default value's reference (1 shared compiled type of typedefs which default does not reference own type) */
Radek Krejci6be5ff12018-11-26 13:18:15 +01002331 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejcia1911222019-07-22 17:24:50 +02002332 leaf = (struct lysc_node_leaf*)mod->compiled->data->next;
2333 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2334 assert_int_equal(0, dynamic);
2335 assert_string_equal("xxx", leaf->units);
Radek Krejci6be5ff12018-11-26 13:18:15 +01002336
2337 assert_non_null(mod = lys_parse_mem(ctx, "module e {namespace urn:e;prefix e; typedef mybasetype {type string;}"
2338 "typedef mytype {type mybasetype; default hello;units xxx;}leaf l {type mytype;}}", LYS_IN_YANG));
Radek Krejci6be5ff12018-11-26 13:18:15 +01002339 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2340 assert_non_null(type);
Radek Krejcia1911222019-07-22 17:24:50 +02002341 assert_int_equal(4, type->refcount); /* 3x type reference, 1x default value's reference (typedef's default does not reference own type) */
Radek Krejci6be5ff12018-11-26 13:18:15 +01002342 assert_int_equal(LY_TYPE_STRING, type->basetype);
Radek Krejcia1911222019-07-22 17:24:50 +02002343 leaf = (struct lysc_node_leaf*)mod->compiled->data;
2344 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2345 assert_int_equal(0, dynamic);
2346 assert_string_equal("xxx", leaf->units);
Radek Krejci6be5ff12018-11-26 13:18:15 +01002347
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01002348 /* mandatory leaf does not takes default value from type */
2349 assert_non_null(mod = lys_parse_mem(ctx, "module f {namespace urn:f;prefix f;typedef mytype {type string; default hello;units xxx;}"
2350 "leaf l {type mytype; mandatory true;}}", LYS_IN_YANG));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01002351 type = ((struct lysc_node_leaf*)mod->compiled->data)->type;
2352 assert_non_null(type);
2353 assert_int_equal(LY_TYPE_STRING, type->basetype);
2354 assert_null(((struct lysc_node_leaf*)mod->compiled->data)->dflt);
2355 assert_string_equal("xxx", ((struct lysc_node_leaf*)mod->compiled->data)->units);
2356
Radek Krejcicdfecd92018-11-26 11:27:32 +01002357 *state = NULL;
2358 ly_ctx_destroy(ctx, NULL);
2359}
2360
Radek Krejci665421c2018-12-05 08:03:39 +01002361static void
2362test_status(void **state)
2363{
2364 *state = test_status;
2365
2366 struct ly_ctx *ctx;
Radek Krejci665421c2018-12-05 08:03:39 +01002367
2368 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2369
Radek Krejci096235c2019-01-11 11:12:19 +01002370 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;"
Radek Krejci665421c2018-12-05 08:03:39 +01002371 "container c {status deprecated; leaf l {status current; type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002372 logbuf_assert("A \"current\" status is in conflict with the parent's \"deprecated\" status. /aa:c/l");
Radek Krejci665421c2018-12-05 08:03:39 +01002373
Radek Krejci096235c2019-01-11 11:12:19 +01002374 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;"
Radek Krejci665421c2018-12-05 08:03:39 +01002375 "container c {status obsolete; leaf l {status current; type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002376 logbuf_assert("A \"current\" status is in conflict with the parent's \"obsolete\" status. /bb:c/l");
Radek Krejci665421c2018-12-05 08:03:39 +01002377
Radek Krejci096235c2019-01-11 11:12:19 +01002378 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;"
Radek Krejci665421c2018-12-05 08:03:39 +01002379 "container c {status obsolete; leaf l {status deprecated; type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002380 logbuf_assert("A \"deprecated\" status is in conflict with the parent's \"obsolete\" status. /cc:c/l");
Radek Krejci665421c2018-12-05 08:03:39 +01002381
2382 *state = NULL;
2383 ly_ctx_destroy(ctx, NULL);
2384}
2385
Radek Krejcie86bf772018-12-14 11:39:53 +01002386static void
Radek Krejcif2de0ed2019-05-02 14:13:18 +02002387test_grouping(void **state)
2388{
2389 *state = test_grouping;
2390
2391 struct ly_ctx *ctx;
2392
2393 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2394
2395 /* result ok, but a warning about not used locally scoped grouping printed */
2396 assert_non_null(lys_parse_mem(ctx, "module a {namespace urn:a;prefix a; grouping grp1 {leaf a1 {type string;}}"
2397 "container a {leaf x {type string;} grouping grp2 {leaf a2 {type string;}}}}", LYS_IN_YANG));
2398 logbuf_assert("Locally scoped grouping \"grp2\" not used.");
2399 logbuf_clean();
2400
2401 /* result ok - when statement or leafref target must be checked only at the place where the grouping is really instantiated */
2402 assert_non_null(lys_parse_mem(ctx, "module b {namespace urn:b;prefix b; grouping grp {"
2403 "leaf ref {type leafref {path \"../name\";}}"
2404 "leaf cond {type string; when \"../name = 'specialone'\";}}}", LYS_IN_YANG));
2405 logbuf_assert("");
2406
2407
2408 /* invalid - error in a non-instantiated grouping */
2409 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;"
2410 "grouping grp {leaf x {type leafref;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002411 logbuf_assert("Missing path substatement for leafref type. /aa:{grouping='grp'}/x");
Radek Krejcif2de0ed2019-05-02 14:13:18 +02002412 logbuf_clean();
2413 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;"
2414 "container a {grouping grp {leaf x {type leafref;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002415 logbuf_assert("Missing path substatement for leafref type. /aa:a/{grouping='grp'}/x");
Radek Krejcif2de0ed2019-05-02 14:13:18 +02002416
2417
2418 *state = NULL;
2419 ly_ctx_destroy(ctx, NULL);
2420}
2421
2422static void
Radek Krejcie86bf772018-12-14 11:39:53 +01002423test_uses(void **state)
2424{
2425 *state = test_uses;
2426
2427 struct ly_ctx *ctx;
2428 struct lys_module *mod;
Radek Krejci3641f562019-02-13 15:38:40 +01002429 const struct lysc_node *parent, *child;
Radek Krejci32b6ecd2019-04-12 10:41:24 +02002430 const struct lysc_node_container *cont;
Radek Krejcie86bf772018-12-14 11:39:53 +01002431
2432 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2433
Radek Krejci0af46292019-01-11 16:02:31 +01002434 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module grp {namespace urn:grp;prefix g; typedef mytype {type string;} feature f;"
2435 "grouping grp {leaf x {type mytype;} leaf y {type string; if-feature f;}}}");
Radek Krejcie86bf772018-12-14 11:39:53 +01002436 assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;import grp {prefix g;}"
2437 "grouping grp_a_top {leaf a1 {type int8;}}"
2438 "container a {uses grp_a; uses grp_a_top; uses g:grp; grouping grp_a {leaf a2 {type uint8;}}}}", LYS_IN_YANG));
Radek Krejcie86bf772018-12-14 11:39:53 +01002439 assert_non_null((parent = mod->compiled->data));
2440 assert_int_equal(LYS_CONTAINER, parent->nodetype);
2441 assert_non_null((child = ((struct lysc_node_container*)parent)->child));
2442 assert_string_equal("a2", child->name);
Radek Krejci76b3e962018-12-14 17:01:25 +01002443 assert_ptr_equal(mod, child->module);
Radek Krejcie86bf772018-12-14 11:39:53 +01002444 assert_non_null((child = child->next));
2445 assert_string_equal("a1", child->name);
Radek Krejci76b3e962018-12-14 17:01:25 +01002446 assert_ptr_equal(mod, child->module);
Radek Krejcie86bf772018-12-14 11:39:53 +01002447 assert_non_null((child = child->next));
2448 assert_string_equal("x", child->name);
Radek Krejci76b3e962018-12-14 17:01:25 +01002449 assert_ptr_equal(mod, child->module);
Radek Krejci0af46292019-01-11 16:02:31 +01002450 assert_non_null((child = child->next));
2451 assert_string_equal("y", child->name);
2452 assert_non_null(child->iffeatures);
2453 assert_int_equal(1, LY_ARRAY_SIZE(child->iffeatures));
2454 assert_int_equal(1, LY_ARRAY_SIZE(child->iffeatures[0].features));
2455 assert_string_equal("f", child->iffeatures[0].features[0]->name);
2456 assert_int_equal(LY_EINVAL, lys_feature_enable(mod->compiled->imports[0].module, "f"));
2457 logbuf_assert("Module \"grp\" is not implemented so all its features are permanently disabled without a chance to change it.");
2458 assert_int_equal(0, lysc_iffeature_value(&child->iffeatures[0]));
2459
2460 /* make the imported module implemented and enable the feature */
2461 assert_non_null(mod = ly_ctx_get_module(ctx, "grp", NULL));
2462 assert_int_equal(LY_SUCCESS, ly_ctx_module_implement(ctx, mod));
2463 assert_int_equal(LY_SUCCESS, lys_feature_enable(mod, "f"));
2464 assert_string_equal("f", child->iffeatures[0].features[0]->name);
2465 assert_int_equal(1, lysc_iffeature_value(&child->iffeatures[0]));
Radek Krejcie86bf772018-12-14 11:39:53 +01002466
Radek Krejci00b874b2019-02-12 10:54:50 +01002467 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "submodule bsub {belongs-to b {prefix b;} grouping grp {leaf b {when 1; type string;}}}");
2468 assert_non_null(mod = lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;include bsub;uses grp {when 2;}}", LYS_IN_YANG));
Radek Krejcib1b59152019-01-07 13:21:56 +01002469 assert_non_null(mod->compiled->data);
2470 assert_int_equal(LYS_LEAF, mod->compiled->data->nodetype);
2471 assert_string_equal("b", mod->compiled->data->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002472 assert_int_equal(2, LY_ARRAY_SIZE(mod->compiled->data->when));
Radek Krejcib1b59152019-01-07 13:21:56 +01002473
Radek Krejci7f6a3812019-01-07 13:48:57 +01002474 logbuf_clean();
2475 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:ii;prefix ii;"
2476 "grouping grp {leaf l {type string;}leaf k {type string; status obsolete;}}"
2477 "uses grp {status deprecated;}}", LYS_IN_YANG));
Radek Krejci7f6a3812019-01-07 13:48:57 +01002478 assert_int_equal(LYS_LEAF, mod->compiled->data->nodetype);
2479 assert_string_equal("l", mod->compiled->data->name);
2480 assert_true(LYS_STATUS_DEPRC & mod->compiled->data->flags);
2481 assert_int_equal(LYS_LEAF, mod->compiled->data->next->nodetype);
2482 assert_string_equal("k", mod->compiled->data->next->name);
2483 assert_true(LYS_STATUS_OBSLT & mod->compiled->data->next->flags);
2484 logbuf_assert(""); /* no warning about inheriting deprecated flag from uses */
2485
Radek Krejci3641f562019-02-13 15:38:40 +01002486 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d; grouping grp {container g;}"
2487 "container top {uses grp {augment g {leaf x {type int8;}}}}}", LYS_IN_YANG));
2488 assert_non_null(mod->compiled->data);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002489 assert_non_null(child = lysc_node_children(mod->compiled->data, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01002490 assert_string_equal("g", child->name);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002491 assert_non_null(child = lysc_node_children(child, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01002492 assert_string_equal("x", child->name);
2493
Radek Krejci32b6ecd2019-04-12 10:41:24 +02002494 assert_non_null(mod = lys_parse_mem(ctx, "module e {yang-version 1.1;namespace urn:e;prefix e; grouping grp {action g { description \"super g\";}}"
2495 "container top {action e; uses grp {refine g {description \"ultra g\";}}}}", LYS_IN_YANG));
2496 assert_non_null(mod->compiled->data);
2497 cont = (const struct lysc_node_container*)mod->compiled->data;
2498 assert_non_null(cont->actions);
2499 assert_int_equal(2, LY_ARRAY_SIZE(cont->actions));
2500 assert_string_equal("e", cont->actions[1].name);
2501 assert_string_equal("g", cont->actions[0].name);
2502 assert_string_equal("ultra g", cont->actions[0].dsc);
2503
2504 assert_non_null(mod = lys_parse_mem(ctx, "module f {yang-version 1.1;namespace urn:f;prefix f; grouping grp {notification g { description \"super g\";}}"
2505 "container top {notification f; uses grp {refine g {description \"ultra g\";}}}}", LYS_IN_YANG));
2506 assert_non_null(mod->compiled->data);
2507 cont = (const struct lysc_node_container*)mod->compiled->data;
2508 assert_non_null(cont->notifs);
2509 assert_int_equal(2, LY_ARRAY_SIZE(cont->notifs));
2510 assert_string_equal("f", cont->notifs[1].name);
2511 assert_string_equal("g", cont->notifs[0].name);
2512 assert_string_equal("ultra g", cont->notifs[0].dsc);
2513
Radek Krejci684faf22019-05-27 14:31:16 +02002514 /* empty grouping */
2515 assert_non_null(mod = lys_parse_mem(ctx, "module g {namespace urn:g;prefix g; grouping grp; uses grp;}", LYS_IN_YANG));
2516 assert_null(mod->compiled->data);
2517
Radek Krejcie86bf772018-12-14 11:39:53 +01002518 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +01002519 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;uses missinggrp;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002520 logbuf_assert("Grouping \"missinggrp\" referenced by a uses statement not found. /aa:{uses='missinggrp'}");
Radek Krejcie86bf772018-12-14 11:39:53 +01002521
Radek Krejci096235c2019-01-11 11:12:19 +01002522 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;uses grp;"
Radek Krejcie86bf772018-12-14 11:39:53 +01002523 "grouping grp {leaf a{type string;}uses grp1;}"
2524 "grouping grp1 {leaf b {type string;}uses grp2;}"
2525 "grouping grp2 {leaf c {type string;}uses grp;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002526 logbuf_assert("Grouping \"grp\" references itself through a uses statement. /bb:{uses='grp'}/{uses='grp1'}/{uses='grp2'}/{uses='grp'}");
Radek Krejcie86bf772018-12-14 11:39:53 +01002527
Radek Krejci096235c2019-01-11 11:12:19 +01002528 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;uses a:missingprefix;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002529 logbuf_assert("Invalid prefix used for grouping reference. /cc:{uses='a:missingprefix'}");
Radek Krejci76b3e962018-12-14 17:01:25 +01002530
Radek Krejci096235c2019-01-11 11:12:19 +01002531 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;grouping grp{leaf a{type string;}}"
Radek Krejci76b3e962018-12-14 17:01:25 +01002532 "leaf a {type string;}uses grp;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002533 logbuf_assert("Duplicate identifier \"a\" of data definition/RPC/action/Notification statement. /dd:{uses='grp'}/dd:a");
Radek Krejci76b3e962018-12-14 17:01:25 +01002534
Radek Krejci096235c2019-01-11 11:12:19 +01002535 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;grouping grp {leaf l {type string; status deprecated;}}"
Radek Krejci7f6a3812019-01-07 13:48:57 +01002536 "uses grp {status obsolete;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002537 logbuf_assert("A \"deprecated\" status is in conflict with the parent's \"obsolete\" status. /ee:{uses='grp'}/ee:l");
Radek Krejci7f6a3812019-01-07 13:48:57 +01002538
Radek Krejci95710c92019-02-11 15:49:55 +01002539 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;grouping grp {leaf l {type string;}}"
2540 "leaf l {type int8;}uses grp;}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002541 logbuf_assert("Duplicate identifier \"l\" of data definition/RPC/action/Notification statement. /ff:{uses='grp'}/ff:l");
Radek Krejci95710c92019-02-11 15:49:55 +01002542 assert_null(lys_parse_mem(ctx, "module fg {namespace urn:fg;prefix fg;grouping grp {leaf m {type string;}}"
2543 "uses grp;leaf m {type int8;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002544 logbuf_assert("Duplicate identifier \"m\" of data definition/RPC/action/Notification statement. /fg:m");
Radek Krejci95710c92019-02-11 15:49:55 +01002545
Radek Krejci3641f562019-02-13 15:38:40 +01002546
2547 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg; grouping grp {container g;}"
2548 "leaf g {type string;}"
2549 "container top {uses grp {augment /g {leaf x {type int8;}}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002550 logbuf_assert("Invalid descendant-schema-nodeid value \"/g\" - absolute-schema-nodeid used. /gg:top/{uses='grp'}/{augment='/g'}");
Radek Krejci3641f562019-02-13 15:38:40 +01002551
Radek Krejci32b6ecd2019-04-12 10:41:24 +02002552 assert_non_null(mod = lys_parse_mem(ctx, "module hh {yang-version 1.1;namespace urn:hh;prefix hh;"
2553 "grouping grp {notification g { description \"super g\";}}"
2554 "container top {notification h; uses grp {refine h {description \"ultra h\";}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002555 logbuf_assert("Invalid descendant-schema-nodeid value \"h\" - target node not found. /hh:top/{uses='grp'}/{refine='h'}");
Radek Krejci32b6ecd2019-04-12 10:41:24 +02002556
2557 assert_non_null(mod = lys_parse_mem(ctx, "module ii {yang-version 1.1;namespace urn:ii;prefix ii;"
2558 "grouping grp {action g { description \"super g\";}}"
2559 "container top {action i; uses grp {refine i {description \"ultra i\";}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002560 logbuf_assert("Invalid descendant-schema-nodeid value \"i\" - target node not found. /ii:top/{uses='grp'}/{refine='i'}");
Radek Krejci3641f562019-02-13 15:38:40 +01002561
Radek Krejcie86bf772018-12-14 11:39:53 +01002562 *state = NULL;
2563 ly_ctx_destroy(ctx, NULL);
2564}
2565
Radek Krejci01342af2019-01-03 15:18:08 +01002566static void
2567test_refine(void **state)
2568{
2569 *state = test_refine;
2570
2571 struct ly_ctx *ctx;
2572 struct lys_module *mod;
2573 struct lysc_node *parent, *child;
Radek Krejcia1911222019-07-22 17:24:50 +02002574 struct lysc_node_leaf *leaf;
2575 struct lysc_node_leaflist *llist;
2576 int dynamic;
Radek Krejci01342af2019-01-03 15:18:08 +01002577
2578 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2579
Radek Krejci096235c2019-01-11 11:12:19 +01002580 assert_non_null(lys_parse_mem(ctx, "module grp {yang-version 1.1;namespace urn:grp;prefix g; feature f;typedef mytype {type string; default cheers!;}"
2581 "grouping grp {container c {leaf l {type mytype; default goodbye;}"
2582 "leaf-list ll {type mytype; default goodbye; max-elements 6;}"
2583 "choice ch {default a; leaf a {type int8;}leaf b{type uint8;}}"
2584 "leaf x {type mytype; mandatory true; must 1;}"
2585 "anydata a {mandatory false; if-feature f; description original; reference original;}"
2586 "container c {config false; leaf l {type string;}}}}}", LYS_IN_YANG));
Radek Krejci01342af2019-01-03 15:18:08 +01002587
Radek Krejcif0089082019-01-07 16:42:01 +01002588 assert_non_null(mod = lys_parse_mem(ctx, "module a {yang-version 1.1;namespace urn:a;prefix a;import grp {prefix g;}feature fa;"
Radek Krejci01342af2019-01-03 15:18:08 +01002589 "uses g:grp {refine c/l {default hello; config false;}"
Radek Krejci6b22ab72019-01-07 15:39:20 +01002590 "refine c/ll {default hello;default world; min-elements 2; max-elements 5;}"
Radek Krejcif0089082019-01-07 16:42:01 +01002591 "refine c/ch {default b;config true; if-feature fa;}"
Radek Krejcif3404542019-01-08 13:28:42 +01002592 "refine c/x {mandatory false; must ../ll;description refined; reference refined;}"
2593 "refine c/a {mandatory true; must 1; if-feature fa;description refined; reference refined;}"
Radek Krejci9a54f1f2019-01-07 13:47:55 +01002594 "refine c/c {config true;presence indispensable;}}}", LYS_IN_YANG));
Radek Krejci01342af2019-01-03 15:18:08 +01002595 assert_non_null((parent = mod->compiled->data));
2596 assert_int_equal(LYS_CONTAINER, parent->nodetype);
2597 assert_string_equal("c", parent->name);
Radek Krejcia1911222019-07-22 17:24:50 +02002598 assert_non_null((leaf = (struct lysc_node_leaf*)((struct lysc_node_container*)parent)->child));
2599 assert_int_equal(LYS_LEAF, leaf->nodetype);
2600 assert_string_equal("l", leaf->name);
2601 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2602 assert_int_equal(0, dynamic);
2603 assert_int_equal(LYS_CONFIG_R, leaf->flags & LYS_CONFIG_MASK);
2604 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
2605 assert_int_equal(LYS_LEAFLIST, llist->nodetype);
2606 assert_string_equal("ll", llist->name);
2607 assert_int_equal(2, LY_ARRAY_SIZE(llist->dflts));
2608 assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
2609 assert_int_equal(0, dynamic);
2610 assert_string_equal("world", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LYD_XML, NULL, NULL, &dynamic));
2611 assert_int_equal(0, dynamic);
2612 assert_int_equal(2, llist->min);
2613 assert_int_equal(5, llist->max);
2614 assert_non_null(child = llist->next);
Radek Krejci01342af2019-01-03 15:18:08 +01002615 assert_int_equal(LYS_CHOICE, child->nodetype);
2616 assert_string_equal("ch", child->name);
2617 assert_string_equal("b", ((struct lysc_node_choice*)child)->dflt->name);
2618 assert_true(LYS_SET_DFLT & ((struct lysc_node_choice*)child)->dflt->flags);
2619 assert_false(LYS_SET_DFLT & ((struct lysc_node_choice*)child)->cases[0].flags);
Radek Krejcif0089082019-01-07 16:42:01 +01002620 assert_non_null(child->iffeatures);
2621 assert_int_equal(1, LY_ARRAY_SIZE(child->iffeatures));
Radek Krejcia1911222019-07-22 17:24:50 +02002622 assert_non_null(leaf = (struct lysc_node_leaf*)child->next);
2623 assert_int_equal(LYS_LEAF, leaf->nodetype);
2624 assert_string_equal("x", leaf->name);
2625 assert_false(LYS_MAND_TRUE & leaf->flags);
2626 assert_string_equal("cheers!", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2627 assert_int_equal(0, dynamic);
2628 assert_non_null(leaf->musts);
2629 assert_int_equal(2, LY_ARRAY_SIZE(leaf->musts));
2630 assert_string_equal("refined", leaf->dsc);
2631 assert_string_equal("refined", leaf->ref);
2632 assert_non_null(child = leaf->next);
Radek Krejci7f6a3812019-01-07 13:48:57 +01002633 assert_int_equal(LYS_ANYDATA, child->nodetype);
2634 assert_string_equal("a", child->name);
2635 assert_true(LYS_MAND_TRUE & child->flags);
Radek Krejci9a564c92019-01-07 14:53:57 +01002636 assert_non_null(((struct lysc_node_anydata*)child)->musts);
2637 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_node_anydata*)child)->musts));
Radek Krejcif0089082019-01-07 16:42:01 +01002638 assert_non_null(child->iffeatures);
2639 assert_int_equal(2, LY_ARRAY_SIZE(child->iffeatures));
Radek Krejcif3404542019-01-08 13:28:42 +01002640 assert_string_equal("refined", child->dsc);
2641 assert_string_equal("refined", child->ref);
Radek Krejci7f6a3812019-01-07 13:48:57 +01002642 assert_non_null(child = child->next);
Radek Krejcib1b59152019-01-07 13:21:56 +01002643 assert_int_equal(LYS_CONTAINER, child->nodetype);
2644 assert_string_equal("c", child->name);
Radek Krejci7f6a3812019-01-07 13:48:57 +01002645 assert_true(LYS_PRESENCE & child->flags);
Radek Krejcib1b59152019-01-07 13:21:56 +01002646 assert_true(LYS_CONFIG_W & child->flags);
2647 assert_true(LYS_CONFIG_W & ((struct lysc_node_container*)child)->child->flags);
Radek Krejci01342af2019-01-03 15:18:08 +01002648
2649 assert_non_null(mod = lys_parse_mem(ctx, "module b {yang-version 1.1;namespace urn:b;prefix b;import grp {prefix g;}"
Radek Krejcib1b59152019-01-07 13:21:56 +01002650 "uses g:grp {status deprecated; refine c/x {default hello; mandatory false;}}}", LYS_IN_YANG));
Radek Krejcia1911222019-07-22 17:24:50 +02002651 assert_non_null((leaf = (struct lysc_node_leaf*)((struct lysc_node_container*)mod->compiled->data)->child->prev->prev->prev));
2652 assert_int_equal(LYS_LEAF, leaf->nodetype);
2653 assert_string_equal("x", leaf->name);
2654 assert_false(LYS_MAND_TRUE & leaf->flags);
2655 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2656 assert_int_equal(0, dynamic);
Radek Krejci01342af2019-01-03 15:18:08 +01002657
2658 /* invalid */
Radek Krejci096235c2019-01-11 11:12:19 +01002659 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002660 "uses g:grp {refine c {default hello;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002661 logbuf_assert("Invalid refine of default - container cannot hold default value(s). /aa:{uses='g:grp'}/{refine='c'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002662
Radek Krejci096235c2019-01-11 11:12:19 +01002663 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002664 "uses g:grp {refine c/l {default hello; default world;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002665 logbuf_assert("Invalid refine of default - leaf cannot hold 2 default values. /bb:{uses='g:grp'}/{refine='c/l'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002666
Radek Krejci096235c2019-01-11 11:12:19 +01002667 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002668 "uses g:grp {refine c/ll {default hello; default world;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002669 logbuf_assert("Invalid refine of default in leaf-list - the default statement is allowed only in YANG 1.1 modules. /cc:{uses='g:grp'}/{refine='c/ll'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002670
Radek Krejci096235c2019-01-11 11:12:19 +01002671 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002672 "uses g:grp {refine c/ll {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002673 logbuf_assert("Invalid refine of mandatory - leaf-list cannot hold mandatory statement. /dd:{uses='g:grp'}/{refine='c/ll'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002674
Radek Krejci096235c2019-01-11 11:12:19 +01002675 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002676 "uses g:grp {refine c/l {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002677 logbuf_assert("Invalid refine of mandatory - leaf already has \"default\" statement. /ee:{uses='g:grp'}/{refine='c/l'}");
Radek Krejci096235c2019-01-11 11:12:19 +01002678 assert_null(lys_parse_mem(ctx, "module ef {namespace urn:ef;prefix ef;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002679 "uses g:grp {refine c/ch {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002680 logbuf_assert("Invalid refine of mandatory - choice already has \"default\" statement. /ef:{uses='g:grp'}/{refine='c/ch'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002681
Radek Krejci096235c2019-01-11 11:12:19 +01002682 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002683 "uses g:grp {refine c/ch/a/a {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002684 logbuf_assert("Invalid refine of mandatory under the default case. /ff:{uses='g:grp'}/{refine='c/ch/a/a'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002685
Radek Krejci096235c2019-01-11 11:12:19 +01002686 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg;import grp {prefix g;}"
Radek Krejci01342af2019-01-03 15:18:08 +01002687 "uses g:grp {refine c/x {default hello;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002688 logbuf_assert("Invalid refine of default - the node is mandatory. /gg:{uses='g:grp'}/{refine='c/x'}");
Radek Krejci01342af2019-01-03 15:18:08 +01002689
Radek Krejci096235c2019-01-11 11:12:19 +01002690 assert_null(lys_parse_mem(ctx, "module hh {namespace urn:hh;prefix hh;import grp {prefix g;}"
Radek Krejcib1b59152019-01-07 13:21:56 +01002691 "uses g:grp {refine c/c/l {config true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002692 logbuf_assert("Invalid refine of config - configuration node cannot be child of any state data node. /hh:{uses='g:grp'}/{refine='c/c/l'}");
Radek Krejcib1b59152019-01-07 13:21:56 +01002693
Radek Krejci096235c2019-01-11 11:12:19 +01002694 assert_null(lys_parse_mem(ctx, "module ii {namespace urn:ii;prefix ii;grouping grp {leaf l {type string; status deprecated;}}"
Radek Krejcib1b59152019-01-07 13:21:56 +01002695 "uses grp {status obsolete;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002696 logbuf_assert("A \"deprecated\" status is in conflict with the parent's \"obsolete\" status. /ii:{uses='grp'}/ii:l");
Radek Krejcib1b59152019-01-07 13:21:56 +01002697
Radek Krejci096235c2019-01-11 11:12:19 +01002698 assert_null(lys_parse_mem(ctx, "module jj {namespace urn:jj;prefix jj;import grp {prefix g;}"
Radek Krejci9a54f1f2019-01-07 13:47:55 +01002699 "uses g:grp {refine c/x {presence nonsence;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002700 logbuf_assert("Invalid refine of presence statement - leaf cannot hold the presence statement. /jj:{uses='g:grp'}/{refine='c/x'}");
Radek Krejci9a54f1f2019-01-07 13:47:55 +01002701
Radek Krejci096235c2019-01-11 11:12:19 +01002702 assert_null(lys_parse_mem(ctx, "module kk {namespace urn:kk;prefix kk;import grp {prefix g;}"
Radek Krejci9a564c92019-01-07 14:53:57 +01002703 "uses g:grp {refine c/ch {must 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002704 logbuf_assert("Invalid refine of must statement - choice cannot hold any must statement. /kk:{uses='g:grp'}/{refine='c/ch'}");
Radek Krejci9a564c92019-01-07 14:53:57 +01002705
Radek Krejci096235c2019-01-11 11:12:19 +01002706 assert_null(lys_parse_mem(ctx, "module ll {namespace urn:ll;prefix ll;import grp {prefix g;}"
Radek Krejci6b22ab72019-01-07 15:39:20 +01002707 "uses g:grp {refine c/x {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002708 logbuf_assert("Invalid refine of min-elements statement - leaf cannot hold this statement. /ll:{uses='g:grp'}/{refine='c/x'}");
Radek Krejci6b22ab72019-01-07 15:39:20 +01002709
Radek Krejci096235c2019-01-11 11:12:19 +01002710 assert_null(lys_parse_mem(ctx, "module mm {namespace urn:mm;prefix mm;import grp {prefix g;}"
Radek Krejcif2271f12019-01-07 16:42:23 +01002711 "uses g:grp {refine c/ll {min-elements 10;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002712 logbuf_assert("Invalid refine of min-elements statement - \"min-elements\" is bigger than \"max-elements\". /mm:{uses='g:grp'}/{refine='c/ll'}");
Radek Krejcif2271f12019-01-07 16:42:23 +01002713
Radek Krejci01342af2019-01-03 15:18:08 +01002714 *state = NULL;
2715 ly_ctx_destroy(ctx, NULL);
2716}
Radek Krejcie86bf772018-12-14 11:39:53 +01002717
Radek Krejci95710c92019-02-11 15:49:55 +01002718static void
2719test_augment(void **state)
2720{
2721 *state = test_augment;
2722
2723 struct ly_ctx *ctx;
2724 struct lys_module *mod;
2725 const struct lysc_node *node;
2726 const struct lysc_node_choice *ch;
2727 const struct lysc_node_case *c;
Radek Krejcif538ce52019-03-05 10:46:14 +01002728 const struct lysc_action *rpc;
Radek Krejci95710c92019-02-11 15:49:55 +01002729
2730 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2731
2732 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module a {namespace urn:a;prefix a; typedef atype {type string;}"
2733 "container top {leaf a {type string;}}}");
2734 assert_non_null(lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;import a {prefix a;}"
2735 "leaf b {type a:atype;}}", LYS_IN_YANG));
2736 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module c {namespace urn:c;prefix c; import a {prefix a;}"
2737 "augment /a:top/ { container c {leaf c {type a:atype;}}}}");
2738 assert_non_null(lys_parse_mem(ctx, "module d {namespace urn:d;prefix d;import a {prefix a;} import c {prefix c;}"
2739 "augment /a:top/c:c/ { leaf d {type a:atype;} leaf c {type string;}}}", LYS_IN_YANG));
2740 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "a")));
2741 assert_non_null(ly_ctx_get_module_implemented(ctx, "b"));
2742 assert_non_null(ly_ctx_get_module_implemented(ctx, "c"));
2743 assert_non_null(ly_ctx_get_module_implemented(ctx, "d"));
2744 assert_non_null(node = mod->compiled->data);
2745 assert_string_equal(node->name, "top");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002746 assert_non_null(node = lysc_node_children(node, 0));
Radek Krejci95710c92019-02-11 15:49:55 +01002747 assert_string_equal(node->name, "a");
2748 assert_non_null(node = node->next);
2749 assert_string_equal(node->name, "c");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002750 assert_non_null(node = lysc_node_children(node, 0));
Radek Krejci95710c92019-02-11 15:49:55 +01002751 assert_string_equal(node->name, "c");
2752 assert_non_null(node = node->next);
2753 assert_string_equal(node->name, "d");
2754 assert_non_null(node = node->next);
2755 assert_string_equal(node->name, "c");
2756
2757 assert_non_null((mod = lys_parse_mem(ctx, "module e {namespace urn:e;prefix e;choice ch {leaf a {type string;}}"
Radek Krejci00b874b2019-02-12 10:54:50 +01002758 "augment /ch/c {when 1; leaf lc2 {type uint16;}}"
2759 "augment /ch { when 1; leaf b {type int8;} case c {leaf lc1 {type uint8;}}}}", LYS_IN_YANG)));
Radek Krejci95710c92019-02-11 15:49:55 +01002760 assert_non_null((ch = (const struct lysc_node_choice*)mod->compiled->data));
2761 assert_null(mod->compiled->data->next);
2762 assert_string_equal("ch", ch->name);
2763 assert_non_null(c = ch->cases);
2764 assert_string_equal("a", c->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002765 assert_null(c->when);
Radek Krejci95710c92019-02-11 15:49:55 +01002766 assert_string_equal("a", c->child->name);
2767 assert_non_null(c = (const struct lysc_node_case*)c->next);
2768 assert_string_equal("b", c->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002769 assert_non_null(c->when);
Radek Krejci95710c92019-02-11 15:49:55 +01002770 assert_string_equal("b", c->child->name);
2771 assert_non_null(c = (const struct lysc_node_case*)c->next);
2772 assert_string_equal("c", c->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002773 assert_non_null(c->when);
Radek Krejci95710c92019-02-11 15:49:55 +01002774 assert_string_equal("lc1", ((const struct lysc_node_case*)c)->child->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002775 assert_null(((const struct lysc_node_case*)c)->child->when);
Radek Krejci95710c92019-02-11 15:49:55 +01002776 assert_string_equal("lc2", ((const struct lysc_node_case*)c)->child->next->name);
Radek Krejci00b874b2019-02-12 10:54:50 +01002777 assert_non_null(((const struct lysc_node_case*)c)->child->next->when);
Radek Krejci95710c92019-02-11 15:49:55 +01002778 assert_ptr_equal(ch->cases->child->prev, ((const struct lysc_node_case*)c)->child->next);
2779 assert_null(c->next);
2780
2781 assert_non_null((mod = lys_parse_mem(ctx, "module f {namespace urn:f;prefix f;grouping g {leaf a {type string;}}"
2782 "container c;"
2783 "augment /c {uses g;}}", LYS_IN_YANG)));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002784 assert_non_null(node = lysc_node_children(mod->compiled->data, 0));
Radek Krejci95710c92019-02-11 15:49:55 +01002785 assert_string_equal(node->name, "a");
2786
Radek Krejci339f5292019-02-11 16:42:34 +01002787 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "submodule gsub {belongs-to g {prefix g;}"
2788 "augment /c {container sub;}}");
2789 assert_non_null(mod = lys_parse_mem(ctx, "module g {namespace urn:g;prefix g;include gsub; container c;"
2790 "augment /c/sub {leaf main {type string;}}}", LYS_IN_YANG));
2791 assert_non_null(mod->compiled->data);
2792 assert_string_equal("c", mod->compiled->data->name);
2793 assert_non_null(node = ((struct lysc_node_container*)mod->compiled->data)->child);
2794 assert_string_equal("sub", node->name);
2795 assert_non_null(node = ((struct lysc_node_container*)node)->child);
2796 assert_string_equal("main", node->name);
2797
Radek Krejcif538ce52019-03-05 10:46:14 +01002798 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module himp {namespace urn:hi;prefix hi;container top; rpc func;}");
Radek Krejci733988a2019-02-15 15:12:44 +01002799 assert_non_null(mod = lys_parse_mem(ctx, "module h {namespace urn:h;prefix h;import himp {prefix hi;}container top;"
2800 "augment /hi:top {container p {presence XXX; leaf x {mandatory true;type string;}}}"
2801 "augment /hi:top {list ll {key x;leaf x {type string;}leaf y {mandatory true; type string;}}}"
2802 "augment /hi:top {leaf l {type string; mandatory true; config false;}}"
2803 "augment /top {leaf l {type string; mandatory true;}}}", LYS_IN_YANG));
2804 assert_non_null(node = mod->compiled->data);
2805 assert_non_null(node = ((struct lysc_node_container*)node)->child);
2806 assert_string_equal("l", node->name);
2807 assert_true(node->flags & LYS_MAND_TRUE);
2808 assert_non_null(mod = ly_ctx_get_module_implemented(ctx, "himp"));
Radek Krejcife909632019-02-12 15:34:42 +01002809 assert_non_null(node = mod->compiled->data);
2810 assert_non_null(node = ((struct lysc_node_container*)node)->child);
2811 assert_string_equal("p", node->name);
Radek Krejci733988a2019-02-15 15:12:44 +01002812 assert_non_null(node = node->next);
2813 assert_string_equal("ll", node->name);
2814 assert_non_null(node = node->next);
2815 assert_string_equal("l", node->name);
2816 assert_true(node->flags & LYS_CONFIG_R);
Radek Krejcife909632019-02-12 15:34:42 +01002817
Radek Krejcif538ce52019-03-05 10:46:14 +01002818 assert_non_null(lys_parse_mem(ctx, "module i {namespace urn:i;prefix i;import himp {prefix hi;}"
2819 "augment /hi:func/input {leaf x {type string;}}"
2820 "augment /hi:func/output {leaf y {type string;}}}", LYS_IN_YANG));
2821 assert_non_null(mod = ly_ctx_get_module_implemented(ctx, "himp"));
2822 assert_non_null(rpc = mod->compiled->rpcs);
2823 assert_int_equal(1, LY_ARRAY_SIZE(rpc));
2824 assert_non_null(rpc->input.data);
2825 assert_string_equal("x", rpc->input.data->name);
2826 assert_null(rpc->input.data->next);
2827 assert_non_null(rpc->output.data);
2828 assert_string_equal("y", rpc->output.data->name);
2829 assert_null(rpc->output.data->next);
2830
Radek Krejci95710c92019-02-11 15:49:55 +01002831 assert_null(lys_parse_mem(ctx, "module aa {namespace urn:aa;prefix aa; container c {leaf a {type string;}}"
2832 "augment /x {leaf a {type int8;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002833 logbuf_assert("Invalid absolute-schema-nodeid value \"/x\" - target node not found. /aa:{augment='/x'}");
Radek Krejci95710c92019-02-11 15:49:55 +01002834
2835 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb; container c {leaf a {type string;}}"
2836 "augment /c {leaf a {type int8;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002837 logbuf_assert("Duplicate identifier \"a\" of data definition/RPC/action/Notification statement. /bb:{augment='/c'}/a");
Radek Krejci95710c92019-02-11 15:49:55 +01002838
2839
Radek Krejci339f5292019-02-11 16:42:34 +01002840 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc; container c {leaf a {type string;}}"
2841 "augment /c/a {leaf a {type int8;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002842 logbuf_assert("Augment's absolute-schema-nodeid \"/c/a\" refers to a leaf node which is not an allowed augment's target. /cc:{augment='/c/a'}");
Radek Krejci339f5292019-02-11 16:42:34 +01002843
2844 assert_null(lys_parse_mem(ctx, "module dd {namespace urn:dd;prefix dd; container c {leaf a {type string;}}"
2845 "augment /c {case b {leaf d {type int8;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002846 logbuf_assert("Invalid augment of container node which is not allowed to contain case node \"b\". /dd:{augment='/c'}");
Radek Krejci339f5292019-02-11 16:42:34 +01002847
Radek Krejci733988a2019-02-15 15:12:44 +01002848 assert_null(lys_parse_mem(ctx, "module ee {namespace urn:ee;prefix ee; import himp {prefix hi;}"
2849 "augment /hi:top {container c {leaf d {mandatory true; type int8;}}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002850 logbuf_assert("Invalid augment adding mandatory node \"c\" without making it conditional via when statement. /ee:{augment='/hi:top'}");
Radek Krejcife909632019-02-12 15:34:42 +01002851
Radek Krejci3641f562019-02-13 15:38:40 +01002852 assert_null(lys_parse_mem(ctx, "module ff {namespace urn:ff;prefix ff; container top;"
2853 "augment ../top {leaf x {type int8;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002854 logbuf_assert("Invalid absolute-schema-nodeid value \"../top\" - missing starting \"/\". /ff:{augment='../top'}");
Radek Krejci95710c92019-02-11 15:49:55 +01002855
Radek Krejcif538ce52019-03-05 10:46:14 +01002856 assert_null(lys_parse_mem(ctx, "module gg {namespace urn:gg;prefix gg; rpc func;"
2857 "augment /func {leaf x {type int8;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02002858 logbuf_assert("Augment's absolute-schema-nodeid \"/func\" refers to a RPC/action node which is not an allowed augment's target. /gg:{augment='/func'}");
Radek Krejcif538ce52019-03-05 10:46:14 +01002859
Radek Krejci95710c92019-02-11 15:49:55 +01002860 *state = NULL;
2861 ly_ctx_destroy(ctx, NULL);
2862}
2863
Radek Krejciccd20f12019-02-15 14:12:27 +01002864static void
2865test_deviation(void **state)
2866{
2867 *state = test_deviation;
2868
2869 struct ly_ctx *ctx;
2870 struct lys_module *mod;
2871 const struct lysc_node *node;
Radek Krejci7af64242019-02-18 13:07:53 +01002872 const struct lysc_node_list *list;
Radek Krejcia1911222019-07-22 17:24:50 +02002873 const struct lysc_node_leaflist *llist;
2874 const struct lysc_node_leaf *leaf;
Radek Krejci474f9b82019-07-24 11:36:37 +02002875 const char *str;
Radek Krejcia1911222019-07-22 17:24:50 +02002876 int dynamic;
Radek Krejciccd20f12019-02-15 14:12:27 +01002877
2878 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
2879
2880 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module a {namespace urn:a;prefix a;"
Radek Krejci88ef64b2019-02-18 16:02:06 +01002881 "container top {leaf a {type string;} leaf b {type string;} leaf c {type string;}}"
2882 "choice ch {default c; case b {leaf b{type string;}} case a {leaf a{type string;} leaf x {type string;}}"
Radek Krejcif538ce52019-03-05 10:46:14 +01002883 " case c {leaf c{type string;}}}"
2884 "rpc func1 { input { leaf x {type int8;}} output {leaf y {type int8;}}}"
2885 "rpc func2;}");
Radek Krejciccd20f12019-02-15 14:12:27 +01002886 assert_non_null(lys_parse_mem(ctx, "module b {namespace urn:b;prefix b;import a {prefix a;}"
Radek Krejci88ef64b2019-02-18 16:02:06 +01002887 "deviation /a:top/a:b {deviate not-supported;}"
2888 "deviation /a:ch/a:a/a:x {deviate not-supported;}"
2889 "deviation /a:ch/a:c/a:c {deviate not-supported;}"
2890 "deviation /a:ch/a:b {deviate not-supported;}"
Radek Krejcif538ce52019-03-05 10:46:14 +01002891 "deviation /a:ch/a:a/a:a {deviate not-supported;}"
2892 "deviation /a:func1/a:input {deviate not-supported;}"
2893 "deviation /a:func1/a:output {deviate not-supported;}"
2894 "deviation /a:func2 {deviate not-supported;}}", LYS_IN_YANG));
Radek Krejciccd20f12019-02-15 14:12:27 +01002895 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "a")));
2896 assert_non_null(node = mod->compiled->data);
2897 assert_string_equal(node->name, "top");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002898 assert_non_null(node = lysc_node_children(node, 0));
Radek Krejciccd20f12019-02-15 14:12:27 +01002899 assert_string_equal(node->name, "a");
2900 assert_non_null(node = node->next);
2901 assert_string_equal(node->name, "c");
Radek Krejci88ef64b2019-02-18 16:02:06 +01002902 assert_null(node = node->next);
2903 assert_non_null(node = mod->compiled->data->next);
2904 assert_string_equal("ch", node->name);
2905 assert_null(((struct lysc_node_choice*)node)->dflt);
2906 assert_null(((struct lysc_node_choice*)node)->cases);
Radek Krejcif538ce52019-03-05 10:46:14 +01002907 assert_int_equal(1, LY_ARRAY_SIZE(mod->compiled->rpcs));
2908 assert_null(mod->compiled->rpcs[0].input.data);
2909 assert_null(mod->compiled->rpcs[0].output.data);
Radek Krejciccd20f12019-02-15 14:12:27 +01002910
2911 assert_non_null(mod = lys_parse_mem(ctx, "module c {namespace urn:c;prefix c; typedef mytype {type string; units kilometers;}"
2912 "leaf c1 {type mytype;} leaf c2 {type mytype; units meters;} leaf c3 {type mytype; units meters;}"
2913 "deviation /c1 {deviate add {units meters;}}"
2914 "deviation /c2 {deviate delete {units meters;}}"
2915 "deviation /c3 {deviate replace {units centimeters;}}}", LYS_IN_YANG));
2916 assert_non_null(node = mod->compiled->data);
2917 assert_string_equal("c1", node->name);
2918 assert_string_equal("meters", ((struct lysc_node_leaf*)node)->units);
2919 assert_non_null(node = node->next);
2920 assert_string_equal("c2", node->name);
2921 assert_null(((struct lysc_node_leaf*)node)->units);
2922 assert_non_null(node = node->next);
2923 assert_string_equal("c3", node->name);
2924 assert_string_equal("centimeters", ((struct lysc_node_leaf*)node)->units);
2925
2926 assert_non_null(mod = lys_parse_mem(ctx, "module d {namespace urn:d;prefix d; leaf c1 {type string; must 1;}"
Radek Krejcib4532d12019-02-15 16:13:29 +01002927 "container c2 {presence yes; must 1; must 2;} leaf c3 {type string; must 1; must 3;}"
Radek Krejciccd20f12019-02-15 14:12:27 +01002928 "deviation /c1 {deviate add {must 3;}}"
2929 "deviation /c2 {deviate delete {must 2;}}"
2930 "deviation /c3 {deviate delete {must 3; must 1;}}}", LYS_IN_YANG));
2931 assert_non_null(node = mod->compiled->data);
2932 assert_string_equal("c1", node->name);
2933 assert_int_equal(2, LY_ARRAY_SIZE(((struct lysc_node_leaf*)node)->musts));
2934 assert_string_equal("3", ((struct lysc_node_leaf*)node)->musts[1].cond->expr);
2935 assert_non_null(node = node->next);
2936 assert_string_equal("c2", node->name);
Radek Krejcib4532d12019-02-15 16:13:29 +01002937 assert_int_equal(1, LY_ARRAY_SIZE(((struct lysc_node_container*)node)->musts));
2938 assert_string_equal("1", ((struct lysc_node_container*)node)->musts[0].cond->expr);
Radek Krejciccd20f12019-02-15 14:12:27 +01002939 assert_non_null(node = node->next);
2940 assert_string_equal("c3", node->name);
2941 assert_null(((struct lysc_node_leaf*)node)->musts);
2942
Radek Krejcib4532d12019-02-15 16:13:29 +01002943 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module e {yang-version 1.1; namespace urn:e;prefix e; typedef mytype {type string; default nothing;}"
Radek Krejci468a94f2019-02-15 14:52:36 +01002944 "choice a {default a;leaf a {type string;} leaf b {type string;} leaf c {type string; mandatory true;}}"
Radek Krejciccd20f12019-02-15 14:12:27 +01002945 "choice b {default a;leaf a {type string;} leaf b {type string;}}"
2946 "leaf c {default hello; type string;}"
Radek Krejcib4532d12019-02-15 16:13:29 +01002947 "leaf-list d {default hello; default world; type string;}"
2948 "leaf c2 {type mytype;} leaf-list d2 {type mytype;}}");
Radek Krejciccd20f12019-02-15 14:12:27 +01002949 assert_non_null(lys_parse_mem(ctx, "module f {yang-version 1.1; namespace urn:f;prefix f;import e {prefix x;}"
2950 "deviation /x:a {deviate delete {default a;}}"
2951 "deviation /x:b {deviate delete {default x:a;}}"
2952 "deviation /x:c {deviate delete {default hello;}}"
2953 "deviation /x:d {deviate delete {default world;}}}", LYS_IN_YANG));
2954 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "e")));
2955 assert_non_null(node = mod->compiled->data);
2956 assert_null(((struct lysc_node_choice*)node)->dflt);
2957 assert_non_null(node = node->next);
2958 assert_null(((struct lysc_node_choice*)node)->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02002959 assert_non_null(leaf = (struct lysc_node_leaf*)node->next);
2960 assert_null(leaf->dflt);
2961 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
2962 assert_int_equal(1, LY_ARRAY_SIZE(llist->dflts));
2963 assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
2964 assert_int_equal(0, dynamic);
2965 assert_non_null(leaf = (struct lysc_node_leaf*)llist->next);
2966 assert_string_equal("nothing", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2967 assert_int_equal(0, dynamic);
2968 assert_int_equal(5, leaf->dflt->realtype->refcount); /* 3x type reference, 2x default value reference (typedef's default does not reference own type) */
2969 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
2970 assert_int_equal(1, LY_ARRAY_SIZE(llist->dflts));
2971 assert_string_equal("nothing", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
2972 assert_int_equal(0, dynamic);
Radek Krejciccd20f12019-02-15 14:12:27 +01002973
2974 assert_non_null(lys_parse_mem(ctx, "module g {yang-version 1.1; namespace urn:g;prefix g;import e {prefix x;}"
2975 "deviation /x:b {deviate add {default x:b;}}"
2976 "deviation /x:c {deviate add {default bye;}}"
Radek Krejcib4532d12019-02-15 16:13:29 +01002977 "deviation /x:d {deviate add {default all; default people;}}"
Radek Krejci462cf252019-07-24 09:49:08 +02002978 "deviation /x:c2 {deviate add {default hi; must 1;}}"
Radek Krejcib4532d12019-02-15 16:13:29 +01002979 "deviation /x:d2 {deviate add {default hi; default all;}}}", LYS_IN_YANG));
Radek Krejciccd20f12019-02-15 14:12:27 +01002980 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "e")));
2981 assert_non_null(node = mod->compiled->data);
2982 assert_null(((struct lysc_node_choice*)node)->dflt);
2983 assert_non_null(node = node->next);
2984 assert_non_null(((struct lysc_node_choice*)node)->dflt);
2985 assert_string_equal("b", ((struct lysc_node_choice*)node)->dflt->name);
Radek Krejcia1911222019-07-22 17:24:50 +02002986 assert_non_null(leaf = (struct lysc_node_leaf*)node->next);
2987 assert_non_null(leaf->dflt);
2988 assert_string_equal("bye", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
2989 assert_int_equal(0, dynamic);
2990 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
2991 assert_int_equal(3, LY_ARRAY_SIZE(llist->dflts));
2992 assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
2993 assert_int_equal(0, dynamic);
2994 assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LYD_XML, NULL, NULL, &dynamic));
2995 assert_int_equal(0, dynamic);
2996 assert_string_equal("people", llist->dflts[2]->realtype->plugin->print(llist->dflts[2], LYD_XML, NULL, NULL, &dynamic));
2997 assert_int_equal(0, dynamic);
2998 assert_non_null(leaf = (struct lysc_node_leaf*)llist->next);
2999 assert_non_null(leaf->dflt);
3000 assert_string_equal("hi", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
3001 assert_int_equal(0, dynamic);
3002 assert_int_equal(6, leaf->dflt->realtype->refcount); /* 3x type reference, 3x default value reference
3003 - previous type's default values were replaced by node's default values where d2 now has 2 default values */
Radek Krejci462cf252019-07-24 09:49:08 +02003004 assert_int_equal(1, LY_ARRAY_SIZE(leaf->musts));
3005 assert_ptr_equal(leaf->musts[0].module, ly_ctx_get_module_implemented(ctx, "g"));
Radek Krejcia1911222019-07-22 17:24:50 +02003006 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
3007 assert_int_equal(2, LY_ARRAY_SIZE(llist->dflts));
3008 assert_string_equal("hi", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
3009 assert_int_equal(0, dynamic);
3010 assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LYD_XML, NULL, NULL, &dynamic));
3011 assert_int_equal(0, dynamic);
Radek Krejciccd20f12019-02-15 14:12:27 +01003012
3013 assert_non_null(lys_parse_mem(ctx, "module h {yang-version 1.1; namespace urn:h;prefix h;import e {prefix x;}"
3014 "deviation /x:b {deviate replace {default x:a;}}"
3015 "deviation /x:c {deviate replace {default hello;}}}", LYS_IN_YANG));
3016 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "e")));
3017 assert_non_null(node = mod->compiled->data);
3018 assert_null(((struct lysc_node_choice*)node)->dflt);
3019 assert_non_null(node = node->next);
3020 assert_non_null(((struct lysc_node_choice*)node)->dflt);
3021 assert_string_equal("a", ((struct lysc_node_choice*)node)->dflt->name);
Radek Krejcia1911222019-07-22 17:24:50 +02003022 assert_non_null(leaf = (struct lysc_node_leaf*)node->next);
3023 assert_non_null(leaf->dflt);
3024 assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
3025 assert_int_equal(0, dynamic);
Radek Krejciccd20f12019-02-15 14:12:27 +01003026
Radek Krejci7af64242019-02-18 13:07:53 +01003027 ly_ctx_set_module_imp_clb(ctx, test_imp_clb, "module i {namespace urn:i;prefix i;"
3028 "list l1 {key a; leaf a {type string;} leaf b {type string;} leaf c {type string;}}"
3029 "list l2 {key a; unique \"b c\"; unique \"d\"; leaf a {type string;} leaf b {type string;}"
3030 " leaf c {type string;} leaf d {type string;}}}");
3031 assert_non_null(lys_parse_mem(ctx, "module j {namespace urn:j;prefix j;import i {prefix i;}"
3032 "augment /i:l1 {leaf j_c {type string;}}"
3033 "deviation /i:l1 {deviate add {unique \"i:b j_c\"; }}"
3034 "deviation /i:l1 {deviate add {unique \"i:c\";}}"
3035 "deviation /i:l2 {deviate delete {unique \"d\"; unique \"b c\";}}}", LYS_IN_YANG));
3036 assert_non_null((mod = ly_ctx_get_module_implemented(ctx, "i")));
3037 assert_non_null(list = (struct lysc_node_list*)mod->compiled->data);
3038 assert_string_equal("l1", list->name);
3039 assert_int_equal(2, LY_ARRAY_SIZE(list->uniques));
3040 assert_int_equal(2, LY_ARRAY_SIZE(list->uniques[0]));
3041 assert_string_equal("b", list->uniques[0][0]->name);
3042 assert_string_equal("j_c", list->uniques[0][1]->name);
3043 assert_int_equal(1, LY_ARRAY_SIZE(list->uniques[1]));
3044 assert_string_equal("c", list->uniques[1][0]->name);
3045 assert_non_null(list = (struct lysc_node_list*)list->next);
3046 assert_string_equal("l2", list->name);
3047 assert_null(list->uniques);
3048
Radek Krejci93dcc392019-02-19 10:43:38 +01003049 assert_non_null(mod = lys_parse_mem(ctx, "module k {namespace urn:k;prefix k; leaf a {type string;}"
3050 "container top {leaf x {type string;} leaf y {type string; config false;}}"
3051 "deviation /a {deviate add {config false; }}"
3052 "deviation /top {deviate add {config false;}}}", LYS_IN_YANG));
3053 assert_non_null(node = mod->compiled->data);
3054 assert_string_equal("a", node->name);
3055 assert_true(node->flags & LYS_CONFIG_R);
3056 assert_non_null(node = node->next);
3057 assert_string_equal("top", node->name);
3058 assert_true(node->flags & LYS_CONFIG_R);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003059 assert_non_null(node = lysc_node_children(node, 0));
Radek Krejci93dcc392019-02-19 10:43:38 +01003060 assert_string_equal("x", node->name);
3061 assert_true(node->flags & LYS_CONFIG_R);
3062 assert_non_null(node = node->next);
3063 assert_string_equal("y", node->name);
3064 assert_true(node->flags & LYS_CONFIG_R);
3065
3066 assert_non_null(mod = lys_parse_mem(ctx, "module l {namespace urn:l;prefix l; leaf a {config false; type string;}"
3067 "container top {config false; leaf x {type string;}}"
3068 "deviation /a {deviate replace {config true;}}"
3069 "deviation /top {deviate replace {config true;}}}", LYS_IN_YANG));
3070 assert_non_null(node = mod->compiled->data);
3071 assert_string_equal("a", node->name);
3072 assert_true(node->flags & LYS_CONFIG_W);
3073 assert_non_null(node = node->next);
3074 assert_string_equal("top", node->name);
3075 assert_true(node->flags & LYS_CONFIG_W);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003076 assert_non_null(node = lysc_node_children(node, 0));
Radek Krejci93dcc392019-02-19 10:43:38 +01003077 assert_string_equal("x", node->name);
3078 assert_true(node->flags & LYS_CONFIG_W);
3079
Radek Krejcif1421c22019-02-19 13:05:20 +01003080 assert_non_null(mod = lys_parse_mem(ctx, "module m {namespace urn:m;prefix m;"
3081 "container a {leaf a {type string;}}"
3082 "container b {leaf b {mandatory true; type string;}}"
3083 "deviation /a/a {deviate add {mandatory true;}}"
3084 "deviation /b/b {deviate replace {mandatory false;}}}", LYS_IN_YANG));
3085 assert_non_null(node = mod->compiled->data);
3086 assert_string_equal("a", node->name);
3087 assert_true((node->flags & LYS_MAND_MASK) == LYS_MAND_TRUE);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003088 assert_true((lysc_node_children(node, 0)->flags & LYS_MAND_MASK) == LYS_MAND_TRUE);
Radek Krejcif1421c22019-02-19 13:05:20 +01003089 assert_non_null(node = node->next);
3090 assert_string_equal("b", node->name);
3091 assert_false(node->flags & LYS_MAND_MASK); /* just unset on container */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003092 assert_true((lysc_node_children(node, 0)->flags & LYS_MAND_MASK) == LYS_MAND_FALSE);
Radek Krejcif1421c22019-02-19 13:05:20 +01003093
Radek Krejci551b12c2019-02-19 16:11:21 +01003094 assert_non_null(mod = lys_parse_mem(ctx, "module n {yang-version 1.1; namespace urn:n;prefix n;"
3095 "leaf a {default test; type string;}"
3096 "leaf b {mandatory true; type string;}"
3097 "deviation /a {deviate add {mandatory true;} deviate delete {default test;}}"
3098 "deviation /b {deviate add {default test;} deviate replace {mandatory false;}}}", LYS_IN_YANG));
3099 assert_non_null(node = mod->compiled->data);
3100 assert_string_equal("a", node->name);
3101 assert_null(((struct lysc_node_leaf*)node)->dflt);
3102 assert_true((node->flags & LYS_MAND_MASK) == LYS_MAND_TRUE);
3103 assert_non_null(node = node->next);
3104 assert_string_equal("b", node->name);
3105 assert_non_null(((struct lysc_node_leaf*)node)->dflt);
3106 assert_true((node->flags & LYS_MAND_MASK) == LYS_MAND_FALSE);
3107
3108 assert_non_null(mod = lys_parse_mem(ctx, "module o {namespace urn:o;prefix o;"
3109 "leaf-list a {type string;}"
3110 "list b {config false;}"
3111 "leaf-list c {min-elements 1; max-elements 10; type string;}"
3112 "list d {min-elements 10; max-elements 100; config false;}"
3113 "deviation /a {deviate add {min-elements 1; max-elements 10;}}"
3114 "deviation /b {deviate add {min-elements 10; max-elements 100;}}"
3115 "deviation /c {deviate replace {min-elements 10; max-elements 100;}}"
3116 "deviation /d {deviate replace {min-elements 1; max-elements 10;}}}", LYS_IN_YANG));
3117 assert_non_null(node = mod->compiled->data);
3118 assert_string_equal("a", node->name);
3119 assert_int_equal(1, ((struct lysc_node_leaflist*)node)->min);
3120 assert_int_equal(10, ((struct lysc_node_leaflist*)node)->max);
3121 assert_non_null(node = node->next);
3122 assert_string_equal("b", node->name);
3123 assert_int_equal(10, ((struct lysc_node_list*)node)->min);
3124 assert_int_equal(100, ((struct lysc_node_list*)node)->max);
3125 assert_non_null(node = node->next);
3126 assert_string_equal("c", node->name);
3127 assert_int_equal(10, ((struct lysc_node_leaflist*)node)->min);
3128 assert_int_equal(100, ((struct lysc_node_leaflist*)node)->max);
3129 assert_non_null(node = node->next);
3130 assert_string_equal("d", node->name);
3131 assert_int_equal(1, ((struct lysc_node_list*)node)->min);
3132 assert_int_equal(10, ((struct lysc_node_list*)node)->max);
3133
Radek Krejci33f72892019-02-21 10:36:58 +01003134 assert_non_null(mod = lys_parse_mem(ctx, "module p {yang-version 1.1; namespace urn:p;prefix p; typedef mytype {type int8; default 1;}"
3135 "leaf a {type string; default 10;} leaf-list b {type string;}"
3136 "deviation /a {deviate replace {type mytype;}}"
3137 "deviation /b {deviate replace {type mytype;}}}", LYS_IN_YANG));
Radek Krejcia1911222019-07-22 17:24:50 +02003138 assert_non_null(leaf = (struct lysc_node_leaf*)mod->compiled->data);
3139 assert_string_equal("a", leaf->name);
3140 assert_int_equal(LY_TYPE_INT8, leaf->type->basetype);
3141 assert_string_equal("10", leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, NULL, NULL, &dynamic));
3142 assert_int_equal(0, dynamic);
3143 assert_int_equal(10, leaf->dflt->uint8);
3144 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
3145 assert_string_equal("b", llist->name);
3146 assert_int_equal(LY_TYPE_INT8, llist->type->basetype);
3147 assert_int_equal(1, LY_ARRAY_SIZE(llist->dflts));
3148 assert_string_equal("1", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LYD_XML, NULL, NULL, &dynamic));
3149 assert_int_equal(0, dynamic);
3150 assert_int_equal(1, llist->dflts[0]->uint8);
Radek Krejci33f72892019-02-21 10:36:58 +01003151
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003152 assert_non_null(mod = lys_parse_mem(ctx, "module q {yang-version 1.1; namespace urn:q;prefix q; import e {prefix e;}"
Radek Krejci1c0c3442019-07-23 16:08:47 +02003153 "leaf q {type instance-identifier; default \"/e:d2\";}"
3154 "leaf-list ql {type instance-identifier; default \"/e:d\"; default \"/e:d2\";}}", LYS_IN_YANG));
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003155 assert_non_null(lys_parse_mem(ctx, "module qdev {yang-version 1.1; namespace urn:qdev;prefix qd; import q {prefix q;}"
Radek Krejci1c0c3442019-07-23 16:08:47 +02003156 "deviation /q:q { deviate replace {type string;}}"
3157 "deviation /q:ql { deviate replace {type string;}}}", LYS_IN_YANG));
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003158 assert_non_null(leaf = (struct lysc_node_leaf*)mod->compiled->data);
3159 assert_int_equal(LY_TYPE_STRING, leaf->dflt->realtype->basetype);
3160 assert_non_null(leaf->dflt->canonized);
3161 assert_string_equal("/e:d2", leaf->dflt->canonized);
Radek Krejci1c0c3442019-07-23 16:08:47 +02003162 assert_non_null(llist = (struct lysc_node_leaflist*)leaf->next);
3163 assert_int_equal(2, LY_ARRAY_SIZE(llist->dflts));
3164 assert_int_equal(2, LY_ARRAY_SIZE(llist->dflts_mods));
3165 assert_ptr_equal(llist->dflts_mods[0], mod);
3166 assert_int_equal(LY_TYPE_STRING, llist->dflts[0]->realtype->basetype);
3167 assert_string_equal("/e:d", llist->dflts[0]->canonized);
3168 assert_ptr_equal(llist->dflts_mods[1], mod);
3169 assert_int_equal(LY_TYPE_STRING, llist->dflts[0]->realtype->basetype);
3170 assert_string_equal("/e:d2", llist->dflts[1]->canonized);
3171
3172 assert_non_null(mod = lys_parse_mem(ctx, "module r {yang-version 1.1; namespace urn:r;prefix r;"
3173 "typedef mytype {type uint8; default 200;}"
3174 "leaf r {type mytype;} leaf-list lr {type mytype;}"
3175 "deviation /r:r {deviate replace {type string;}}"
3176 "deviation /r:lr {deviate replace {type string;}}}", LYS_IN_YANG));
3177 assert_non_null(leaf = (struct lysc_node_leaf*)mod->compiled->data);
3178 assert_string_equal("r", leaf->name);
3179 assert_null(leaf->dflt);
3180 assert_null(leaf->dflt_mod);
3181 assert_non_null(llist = (struct lysc_node_leaflist* )leaf->next);
3182 assert_string_equal("lr", llist->name);
3183 assert_null(llist->dflts);
3184 assert_null(llist->dflts_mods);
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003185
Radek Krejci474f9b82019-07-24 11:36:37 +02003186 assert_non_null(mod = lys_parse_mem(ctx, "module s {yang-version 1.1; namespace urn:s;prefix s;"
3187 "leaf s {type instance-identifier {require-instance true;} default /s:x;}"
3188 "leaf x {type string;} leaf y {type string;}"
3189 "deviation /s:s {deviate replace {default /s:y;}}}", LYS_IN_YANG));
3190 assert_non_null(leaf = (struct lysc_node_leaf*)mod->compiled->data);
3191 assert_string_equal("s", leaf->name);
3192 assert_non_null(leaf->dflt);
3193 assert_non_null(str = leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, lys_get_prefix, mod, &dynamic));
3194 assert_string_equal("/s:y", str);
3195 if (dynamic) { free((char*)str); }
3196
Radek Krejci88ef64b2019-02-18 16:02:06 +01003197 assert_null(lys_parse_mem(ctx, "module aa1 {namespace urn:aa1;prefix aa1;import a {prefix a;}"
Radek Krejciccd20f12019-02-15 14:12:27 +01003198 "deviation /a:top/a:z {deviate not-supported;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003199 logbuf_assert("Invalid absolute-schema-nodeid value \"/a:top/a:z\" - target node not found. /aa1:{deviation='/a:top/a:z'}");
Radek Krejci88ef64b2019-02-18 16:02:06 +01003200 assert_non_null(lys_parse_mem(ctx, "module aa2 {namespace urn:aa2;prefix aa2;import a {prefix a;}"
3201 "deviation /a:top/a:a {deviate not-supported;}"
3202 "deviation /a:top/a:a {deviate add {default error;}}}", LYS_IN_YANG));
3203 /* warning */
3204 logbuf_assert("Useless multiple (2) deviates on node \"/a:top/a:a\" since the node is not-supported.");
Radek Krejciccd20f12019-02-15 14:12:27 +01003205
3206 assert_null(lys_parse_mem(ctx, "module bb {namespace urn:bb;prefix bb;import a {prefix a;}"
3207 "deviation a:top/a:a {deviate not-supported;}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003208 logbuf_assert("Invalid absolute-schema-nodeid value \"a:top/a:a\" - missing starting \"/\". /bb:{deviation='a:top/a:a'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003209
3210 assert_null(lys_parse_mem(ctx, "module cc {namespace urn:cc;prefix cc; container c;"
3211 "deviation /c {deviate add {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003212 logbuf_assert("Invalid deviation of container node - it is not possible to add \"units\" property. /cc:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003213 assert_null(lys_parse_mem(ctx, "module cd {namespace urn:cd;prefix cd; leaf c {type string; units centimeters;}"
3214 "deviation /c {deviate add {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003215 logbuf_assert("Invalid deviation adding \"units\" property which already exists (with value \"centimeters\"). /cd:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003216
3217 assert_null(lys_parse_mem(ctx, "module dd1 {namespace urn:dd1;prefix dd1; container c;"
3218 "deviation /c {deviate delete {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003219 logbuf_assert("Invalid deviation of container node - it is not possible to delete \"units\" property. /dd1:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003220 assert_null(lys_parse_mem(ctx, "module dd2 {namespace urn:dd2;prefix dd2; leaf c {type string;}"
3221 "deviation /c {deviate delete {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003222 logbuf_assert("Invalid deviation deleting \"units\" property \"meters\" which is not present. /dd2:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003223 assert_null(lys_parse_mem(ctx, "module dd3 {namespace urn:dd3;prefix dd3; leaf c {type string; units centimeters;}"
3224 "deviation /c {deviate delete {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003225 logbuf_assert("Invalid deviation deleting \"units\" property \"meters\" which does not match the target's property value \"centimeters\"."
3226 " /dd3:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003227
3228 assert_null(lys_parse_mem(ctx, "module ee1 {namespace urn:ee1;prefix ee1; container c;"
3229 "deviation /c {deviate replace {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003230 logbuf_assert("Invalid deviation of container node - it is not possible to replace \"units\" property. /ee1:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003231 assert_null(lys_parse_mem(ctx, "module ee2 {namespace urn:ee2;prefix ee2; leaf c {type string;}"
3232 "deviation /c {deviate replace {units meters;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003233 logbuf_assert("Invalid deviation replacing \"units\" property \"meters\" which is not present. /ee2:{deviation='/c'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003234
3235 /* the default is already deleted in /e:a byt module f */
3236 assert_null(lys_parse_mem(ctx, "module ff1 {namespace urn:ff1;prefix ff1; import e {prefix e;}"
3237 "deviation /e:a {deviate delete {default x:a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003238 logbuf_assert("Invalid deviation deleting \"default\" property \"x:a\" which is not present. /ff1:{deviation='/e:a'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003239 assert_null(lys_parse_mem(ctx, "module ff2 {namespace urn:ff2;prefix ff2; import e {prefix e;}"
3240 "deviation /e:b {deviate delete {default x:a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003241 logbuf_assert("Invalid deviation deleting \"default\" property \"x:a\" of choice. "
3242 "The prefix does not match any imported module of the deviation module. /ff2:{deviation='/e:b'}");
Radek Krejci88ef64b2019-02-18 16:02:06 +01003243 assert_null(lys_parse_mem(ctx, "module ff3 {namespace urn:ff3;prefix ff3; import e {prefix e;}"
3244 "deviation /e:b {deviate delete {default e:b;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003245 logbuf_assert("Invalid deviation deleting \"default\" property \"e:b\" of choice does not match the default case name \"a\". /ff3:{deviation='/e:b'}");
Radek Krejci88ef64b2019-02-18 16:02:06 +01003246 assert_null(lys_parse_mem(ctx, "module ff4 {namespace urn:ff4;prefix ff4; import e {prefix e;}"
3247 "deviation /e:b {deviate delete {default ff4:a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003248 logbuf_assert("Invalid deviation deleting \"default\" property \"ff4:a\" of choice. The prefix does not match the default case's module. /ff4:{deviation='/e:b'}");
Radek Krejci88ef64b2019-02-18 16:02:06 +01003249 assert_null(lys_parse_mem(ctx, "module ff5 {namespace urn:ff5;prefix ff5; anyxml a;"
3250 "deviation /a {deviate delete {default x;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003251 logbuf_assert("Invalid deviation of anyxml node - it is not possible to delete \"default\" property. /ff5:{deviation='/a'}");
Radek Krejci1c0c3442019-07-23 16:08:47 +02003252 assert_null(lys_parse_mem(ctx, "module ff6 {namespace urn:ff6;prefix ff6; import e {prefix e;}"
3253 "deviation /e:c {deviate delete {default hi;}}}", LYS_IN_YANG));
3254 logbuf_assert("Invalid deviation deleting \"default\" property \"hi\" which does not match the target's property value \"hello\". /ff6:{deviation='/e:c'}");
3255 assert_null(lys_parse_mem(ctx, "module ff7 {namespace urn:ff7;prefix ff7; import e {prefix e;}"
3256 "deviation /e:d {deviate delete {default hi;}}}", LYS_IN_YANG));
3257 logbuf_assert("Invalid deviation deleting \"default\" property \"hi\" which does not match any of the target's property values. /ff7:{deviation='/e:d'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003258
3259 assert_null(lys_parse_mem(ctx, "module gg1 {namespace urn:gg1;prefix gg1; import e {prefix e;}"
3260 "deviation /e:b {deviate add {default e:a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003261 logbuf_assert("Invalid deviation adding \"default\" property which already exists (with value \"a\"). /gg1:{deviation='/e:b'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003262 assert_null(lys_parse_mem(ctx, "module gg2 {namespace urn:gg2;prefix gg2; import e {prefix e;}"
Radek Krejci468a94f2019-02-15 14:52:36 +01003263 "deviation /e:a {deviate add {default x:a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003264 logbuf_assert("Invalid deviation adding \"default\" property \"x:a\" of choice. "
3265 "The prefix does not match any imported module of the deviation module. /gg2:{deviation='/e:a'}");
Radek Krejci468a94f2019-02-15 14:52:36 +01003266 assert_null(lys_parse_mem(ctx, "module gg3 {namespace urn:gg3;prefix gg3; import e {prefix e;}"
3267 "deviation /e:a {deviate add {default a;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003268 logbuf_assert("Invalid deviation adding \"default\" property \"a\" of choice - the specified case does not exists. /gg3:{deviation='/e:a'}");
Radek Krejci468a94f2019-02-15 14:52:36 +01003269 assert_null(lys_parse_mem(ctx, "module gg4 {namespace urn:gg4;prefix gg4; import e {prefix e;}"
Radek Krejciccd20f12019-02-15 14:12:27 +01003270 "deviation /e:c {deviate add {default hi;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003271 logbuf_assert("Invalid deviation adding \"default\" property which already exists (with value \"hello\"). /gg4:{deviation='/e:c'}");
Radek Krejci468a94f2019-02-15 14:52:36 +01003272 assert_null(lys_parse_mem(ctx, "module gg4 {namespace urn:gg4;prefix gg4; import e {prefix e;}"
3273 "deviation /e:a {deviate add {default e:c;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003274 logbuf_assert("Invalid deviation adding \"default\" property \"e:c\" of choice - mandatory node \"c\" under the default case. /gg4:{deviation='/e:a'}");
Radek Krejci88ef64b2019-02-18 16:02:06 +01003275 assert_null(lys_parse_mem(ctx, "module gg5 {namespace urn:gg5;prefix gg5; leaf x {type string; mandatory true;}"
3276 "deviation /x {deviate add {default error;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003277 logbuf_assert("Invalid deviation combining default value and mandatory leaf. /gg5:{deviation='/x'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003278
3279 assert_null(lys_parse_mem(ctx, "module hh1 {yang-version 1.1; namespace urn:hh1;prefix hh1; import e {prefix e;}"
3280 "deviation /e:d {deviate replace {default hi;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003281 logbuf_assert("Invalid deviation of leaf-list node - it is not possible to replace \"default\" property. /hh1:{deviation='/e:d'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003282
Radek Krejci7af64242019-02-18 13:07:53 +01003283 assert_null(lys_parse_mem(ctx, "module ii1 {namespace urn:ii1;prefix ii1; import i {prefix i;}"
3284 "deviation /i:l1 {deviate delete {unique x;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003285 logbuf_assert("Invalid deviation deleting \"unique\" property \"x\" which does not match any of the target's property values. /ii1:{deviation='/i:l1'}");
Radek Krejci7af64242019-02-18 13:07:53 +01003286 assert_null(lys_parse_mem(ctx, "module ii2 {namespace urn:ii2;prefix ii2; import i {prefix i;} leaf x { type string;}"
3287 "deviation /i:l2 {deviate delete {unique d;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003288 logbuf_assert("Invalid deviation deleting \"unique\" property \"d\" which does not match any of the target's property values. /ii2:{deviation='/i:l2'}");
Radek Krejci7af64242019-02-18 13:07:53 +01003289 assert_null(lys_parse_mem(ctx, "module ii3 {namespace urn:ii3;prefix ii3; leaf x { type string;}"
3290 "deviation /x {deviate delete {unique d;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003291 logbuf_assert("Invalid deviation of leaf node - it is not possible to delete \"unique\" property. /ii3:{deviation='/x'}");
Radek Krejci7af64242019-02-18 13:07:53 +01003292 assert_null(lys_parse_mem(ctx, "module ii4 {namespace urn:ii4;prefix ii4; leaf x { type string;}"
3293 "deviation /x {deviate add {unique d;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003294 logbuf_assert("Invalid deviation of leaf node - it is not possible to add \"unique\" property. /ii4:{deviation='/x'}");
Radek Krejciccd20f12019-02-15 14:12:27 +01003295
Radek Krejci93dcc392019-02-19 10:43:38 +01003296 assert_null(lys_parse_mem(ctx, "module jj1 {namespace urn:jj1;prefix jj1; choice ch {case a {leaf a{type string;}}}"
3297 "deviation /ch/a {deviate add {config false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003298 logbuf_assert("Invalid deviation of case node - it is not possible to add \"config\" property. /jj1:{deviation='/ch/a'}");
Radek Krejci93dcc392019-02-19 10:43:38 +01003299 assert_null(lys_parse_mem(ctx, "module jj2 {namespace urn:jj2;prefix jj2; container top {config false; leaf x {type string;}}"
3300 "deviation /top/x {deviate add {config true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003301 logbuf_assert("Invalid deviation of config - configuration node cannot be child of any state data node. /jj2:{deviation='/top/x'}");
Radek Krejci93dcc392019-02-19 10:43:38 +01003302 assert_null(lys_parse_mem(ctx, "module jj3 {namespace urn:jj3;prefix jj3; container top {leaf x {type string;}}"
3303 "deviation /top/x {deviate replace {config false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003304 logbuf_assert("Invalid deviation replacing \"config\" property \"config false\" which is not present. /jj3:{deviation='/top/x'}");
Radek Krejci93dcc392019-02-19 10:43:38 +01003305 assert_null(lys_parse_mem(ctx, "module jj4 {namespace urn:jj4;prefix jj4; choice ch {case a {leaf a{type string;}}}"
3306 "deviation /ch/a {deviate replace {config false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003307 logbuf_assert("Invalid deviation of case node - it is not possible to replace \"config\" property. /jj4:{deviation='/ch/a'}");
Radek Krejci93dcc392019-02-19 10:43:38 +01003308 assert_null(lys_parse_mem(ctx, "module jj5 {namespace urn:jj5;prefix jj5; container top {leaf x {type string; config true;}}"
3309 "deviation /top {deviate add {config false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003310 logbuf_assert("Invalid deviation of config - configuration node cannot be child of any state data node. /jj5:{deviation='/top'}");
Radek Krejcif1421c22019-02-19 13:05:20 +01003311 assert_null(lys_parse_mem(ctx, "module jj6 {namespace urn:jj6;prefix jj6; leaf x {config false; type string;}"
3312 "deviation /x {deviate add {config true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003313 logbuf_assert("Invalid deviation adding \"config\" property which already exists (with value \"config false\"). /jj6:{deviation='/x'}");
Radek Krejcif1421c22019-02-19 13:05:20 +01003314
3315 assert_null(lys_parse_mem(ctx, "module kk1 {namespace urn:kk1;prefix kk1; container top {leaf a{type string;}}"
3316 "deviation /top {deviate add {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003317 logbuf_assert("Invalid deviation of mandatory - container cannot hold mandatory statement. /kk1:{deviation='/top'}");
Radek Krejcif1421c22019-02-19 13:05:20 +01003318 assert_null(lys_parse_mem(ctx, "module kk2 {namespace urn:kk2;prefix kk2; container top {leaf a{type string;}}"
3319 "deviation /top {deviate replace {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003320 logbuf_assert("Invalid deviation replacing \"mandatory\" property \"mandatory true\" which is not present. /kk2:{deviation='/top'}");
Radek Krejcif1421c22019-02-19 13:05:20 +01003321 assert_null(lys_parse_mem(ctx, "module kk3 {namespace urn:kk3;prefix kk3; container top {leaf x {type string;}}"
3322 "deviation /top/x {deviate replace {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003323 logbuf_assert("Invalid deviation replacing \"mandatory\" property \"mandatory true\" which is not present. /kk3:{deviation='/top/x'}");
Radek Krejcif1421c22019-02-19 13:05:20 +01003324 assert_null(lys_parse_mem(ctx, "module kk4 {namespace urn:kk4;prefix kk4; leaf x {mandatory true; type string;}"
3325 "deviation /x {deviate add {mandatory false;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003326 logbuf_assert("Invalid deviation adding \"mandatory\" property which already exists (with value \"mandatory true\"). /kk4:{deviation='/x'}");
Radek Krejci93dcc392019-02-19 10:43:38 +01003327
Radek Krejci551b12c2019-02-19 16:11:21 +01003328 assert_null(lys_parse_mem(ctx, "module ll1 {namespace urn:ll1;prefix ll1; leaf x {default test; type string;}"
3329 "deviation /x {deviate add {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003330 logbuf_assert("Invalid deviation combining default value and mandatory leaf. /ll1:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003331 assert_null(lys_parse_mem(ctx, "module ll2 {yang-version 1.1; namespace urn:ll2;prefix ll2; leaf-list x {default test; type string;}"
3332 "deviation /x {deviate add {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003333 logbuf_assert("Invalid deviation combining default value and mandatory leaf-list. /ll2:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003334 assert_null(lys_parse_mem(ctx, "module ll2 {namespace urn:ll2;prefix ll2; choice ch {default a; leaf a {type string;} leaf b {type string;}}"
3335 "deviation /ch {deviate add {mandatory true;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003336 logbuf_assert("Invalid deviation combining default case and mandatory choice. /ll2:{deviation='/ch'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003337
3338 assert_null(lys_parse_mem(ctx, "module mm1 {namespace urn:mm1;prefix mm1; leaf-list x {min-elements 10; type string;}"
3339 "deviation /x {deviate add {max-elements 5;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003340 logbuf_assert("Invalid combination of min-elements and max-elements after deviation: min value 10 is bigger than max value 5. /mm1:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003341 assert_null(lys_parse_mem(ctx, "module mm2 {namespace urn:mm2;prefix mm2; leaf-list x {max-elements 10; type string;}"
3342 "deviation /x {deviate add {min-elements 20;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003343 logbuf_assert("Invalid combination of min-elements and max-elements after deviation: min value 20 is bigger than max value 10. /mm2:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003344 assert_null(lys_parse_mem(ctx, "module mm3 {namespace urn:mm3;prefix mm3; list x {min-elements 5; max-elements 10; config false;}"
3345 "deviation /x {deviate replace {max-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003346 logbuf_assert("Invalid combination of min-elements and max-elements after deviation: min value 5 is bigger than max value 1. /mm3:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003347 assert_null(lys_parse_mem(ctx, "module mm4 {namespace urn:mm4;prefix mm4; list x {min-elements 5; max-elements 10; config false;}"
3348 "deviation /x {deviate replace {min-elements 20;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003349 logbuf_assert("Invalid combination of min-elements and max-elements after deviation: min value 20 is bigger than max value 10. /mm4:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003350 assert_null(lys_parse_mem(ctx, "module mm5 {namespace urn:mm5;prefix mm5; leaf-list x {type string; min-elements 5;}"
3351 "deviation /x {deviate add {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003352 logbuf_assert("Invalid deviation adding \"min-elements\" property which already exists (with value \"5\"). /mm5:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003353 assert_null(lys_parse_mem(ctx, "module mm6 {namespace urn:mm6;prefix mm6; list x {config false; min-elements 5;}"
3354 "deviation /x {deviate add {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003355 logbuf_assert("Invalid deviation adding \"min-elements\" property which already exists (with value \"5\"). /mm6:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003356 assert_null(lys_parse_mem(ctx, "module mm7 {namespace urn:mm7;prefix mm7; leaf-list x {type string; max-elements 5;}"
3357 "deviation /x {deviate add {max-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003358 logbuf_assert("Invalid deviation adding \"max-elements\" property which already exists (with value \"5\"). /mm7:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003359 assert_null(lys_parse_mem(ctx, "module mm8 {namespace urn:mm8;prefix mm8; list x {config false; max-elements 5;}"
3360 "deviation /x {deviate add {max-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003361 logbuf_assert("Invalid deviation adding \"max-elements\" property which already exists (with value \"5\"). /mm8:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003362 assert_null(lys_parse_mem(ctx, "module mm9 {namespace urn:mm9;prefix mm9; leaf-list x {type string;}"
3363 "deviation /x {deviate replace {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003364 logbuf_assert("Invalid deviation replacing with \"min-elements\" property \"1\" which is not present. /mm9:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003365 assert_null(lys_parse_mem(ctx, "module mm10 {namespace urn:mm10;prefix mm10; list x {config false;}"
3366 "deviation /x {deviate replace {min-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003367 logbuf_assert("Invalid deviation replacing with \"min-elements\" property \"1\" which is not present. /mm10:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003368 assert_null(lys_parse_mem(ctx, "module mm11 {namespace urn:mm11;prefix mm11; leaf-list x {type string;}"
3369 "deviation /x {deviate replace {max-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003370 logbuf_assert("Invalid deviation replacing with \"max-elements\" property \"1\" which is not present. /mm11:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003371 assert_null(lys_parse_mem(ctx, "module mm12 {namespace urn:mm12;prefix mm12; list x {config false; }"
3372 "deviation /x {deviate replace {max-elements 1;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003373 logbuf_assert("Invalid deviation replacing with \"max-elements\" property \"1\" which is not present. /mm12:{deviation='/x'}");
Radek Krejci551b12c2019-02-19 16:11:21 +01003374
Radek Krejci33f72892019-02-21 10:36:58 +01003375 assert_null(lys_parse_mem(ctx, "module nn1 {namespace urn:nn1;prefix nn1; anyxml x;"
3376 "deviation /x {deviate replace {type string;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003377 logbuf_assert("Invalid deviation of anyxml node - it is not possible to replace \"type\" property. /nn1:{deviation='/x'}");
Radek Krejci33f72892019-02-21 10:36:58 +01003378 assert_null(lys_parse_mem(ctx, "module nn2 {namespace urn:nn2;prefix nn2; leaf-list x {type string;}"
3379 "deviation /x {deviate replace {type empty;}}}", LYS_IN_YANG));
Radek Krejci327de162019-06-14 12:52:07 +02003380 logbuf_assert("Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules. /nn2:{deviation='/x'}");
Radek Krejci33f72892019-02-21 10:36:58 +01003381
Radek Krejci1c0c3442019-07-23 16:08:47 +02003382 assert_null(lys_parse_mem(ctx, "module oo1 {namespace urn:oo1;prefix oo1; leaf x {type uint16; default 300;}"
3383 "deviation /x {deviate replace {type uint8;}}}", LYS_IN_YANG));
3384 logbuf_assert("Invalid deviation replacing leaf's type - the leaf's default value \"300\" does not match the type "
3385 "(Value \"300\" is out of uint8's min/max bounds.). /oo1:{deviation='/x'}");
3386 assert_null(lys_parse_mem(ctx, "module oo2 {yang-version 1.1;namespace urn:oo2;prefix oo2; leaf-list x {type uint16; default 10; default 300;}"
3387 "deviation /x {deviate replace {type uint8;}}}", LYS_IN_YANG));
3388 logbuf_assert("Invalid deviation replacing leaf-list's type - the leaf-list's default value \"300\" does not match the type "
3389 "(Value \"300\" is out of uint8's min/max bounds.). /oo2:{deviation='/x'}");
3390 assert_null(lys_parse_mem(ctx, "module oo3 {namespace urn:oo3;prefix oo3; leaf x {type uint8;}"
3391 "deviation /x {deviate add {default 300;}}}", LYS_IN_YANG));
3392 logbuf_assert("Invalid deviation setting \"default\" property \"300\" which does not fit the type "
3393 "(Value \"300\" is out of uint8's min/max bounds.). /oo3:{deviation='/x'}");
3394
Radek Krejci474f9b82019-07-24 11:36:37 +02003395/* TODO recompiling reference object after deviation changes schema tree
3396 assert_non_null(lys_parse_mem(ctx, "module pp {namespace urn:pp;prefix pp; leaf l { type leafref {path /c/x;}}"
3397 "container c {leaf x {type string;} leaf y {type string;}}}", LYS_IN_YANG));
3398 assert_null(lys_parse_mem(ctx, "module pp1 {namespace urn:pp1;prefix pp1; import pp {prefix pp;}"
3399 "deviation /pp:c/pp:x {deviate not-supported;}}", LYS_IN_YANG));
3400 logbuf_assert("???. /pp:l}");
3401*/
3402
Radek Krejciccd20f12019-02-15 14:12:27 +01003403 *state = NULL;
3404 ly_ctx_destroy(ctx, NULL);
3405}
3406
Radek Krejcidd4e8d42018-10-16 14:55:43 +02003407int main(void)
3408{
3409 const struct CMUnitTest tests[] = {
Radek Krejci4f28eda2018-11-12 11:46:16 +01003410 cmocka_unit_test_setup_teardown(test_module, logger_setup, logger_teardown),
3411 cmocka_unit_test_setup_teardown(test_feature, logger_setup, logger_teardown),
3412 cmocka_unit_test_setup_teardown(test_identity, logger_setup, logger_teardown),
Radek Krejci0f07bed2018-11-13 14:01:40 +01003413 cmocka_unit_test_setup_teardown(test_type_length, logger_setup, logger_teardown),
3414 cmocka_unit_test_setup_teardown(test_type_range, logger_setup, logger_teardown),
Radek Krejcicda74152018-11-13 15:27:32 +01003415 cmocka_unit_test_setup_teardown(test_type_pattern, logger_setup, logger_teardown),
Radek Krejci8b764662018-11-14 14:15:13 +01003416 cmocka_unit_test_setup_teardown(test_type_enum, logger_setup, logger_teardown),
3417 cmocka_unit_test_setup_teardown(test_type_bits, logger_setup, logger_teardown),
Radek Krejci6cba4292018-11-15 17:33:29 +01003418 cmocka_unit_test_setup_teardown(test_type_dec64, logger_setup, logger_teardown),
Radek Krejci16c0f822018-11-16 10:46:10 +01003419 cmocka_unit_test_setup_teardown(test_type_instanceid, logger_setup, logger_teardown),
Radek Krejci555cb5b2018-11-16 14:54:33 +01003420 cmocka_unit_test_setup_teardown(test_type_identityref, logger_setup, logger_teardown),
Radek Krejcia3045382018-11-22 14:30:31 +01003421 cmocka_unit_test_setup_teardown(test_type_leafref, logger_setup, logger_teardown),
Radek Krejci43699232018-11-23 14:59:46 +01003422 cmocka_unit_test_setup_teardown(test_type_empty, logger_setup, logger_teardown),
Radek Krejcicdfecd92018-11-26 11:27:32 +01003423 cmocka_unit_test_setup_teardown(test_type_union, logger_setup, logger_teardown),
3424 cmocka_unit_test_setup_teardown(test_type_dflt, logger_setup, logger_teardown),
Radek Krejci665421c2018-12-05 08:03:39 +01003425 cmocka_unit_test_setup_teardown(test_status, logger_setup, logger_teardown),
Radek Krejci4f28eda2018-11-12 11:46:16 +01003426 cmocka_unit_test_setup_teardown(test_node_container, logger_setup, logger_teardown),
Radek Krejci0e5d8382018-11-28 16:37:53 +01003427 cmocka_unit_test_setup_teardown(test_node_leaflist, logger_setup, logger_teardown),
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003428 cmocka_unit_test_setup_teardown(test_node_list, logger_setup, logger_teardown),
Radek Krejci056d0a82018-12-06 16:57:25 +01003429 cmocka_unit_test_setup_teardown(test_node_choice, logger_setup, logger_teardown),
Radek Krejci9800fb82018-12-13 14:26:23 +01003430 cmocka_unit_test_setup_teardown(test_node_anydata, logger_setup, logger_teardown),
Radek Krejcif538ce52019-03-05 10:46:14 +01003431 cmocka_unit_test_setup_teardown(test_action, logger_setup, logger_teardown),
Radek Krejcifc11bd72019-04-11 16:00:05 +02003432 cmocka_unit_test_setup_teardown(test_notification, logger_setup, logger_teardown),
Radek Krejcif2de0ed2019-05-02 14:13:18 +02003433 cmocka_unit_test_setup_teardown(test_grouping, logger_setup, logger_teardown),
Radek Krejcie86bf772018-12-14 11:39:53 +01003434 cmocka_unit_test_setup_teardown(test_uses, logger_setup, logger_teardown),
Radek Krejci01342af2019-01-03 15:18:08 +01003435 cmocka_unit_test_setup_teardown(test_refine, logger_setup, logger_teardown),
Radek Krejci95710c92019-02-11 15:49:55 +01003436 cmocka_unit_test_setup_teardown(test_augment, logger_setup, logger_teardown),
Radek Krejciccd20f12019-02-15 14:12:27 +01003437 cmocka_unit_test_setup_teardown(test_deviation, logger_setup, logger_teardown),
Radek Krejcidd4e8d42018-10-16 14:55:43 +02003438 };
3439
3440 return cmocka_run_group_tests(tests, NULL, NULL);
3441}