blob: f98777a0c8bf0bf429d6f866445d68a6a211abb7 [file] [log] [blame]
Radek Krejci80dd33e2018-09-26 15:57:18 +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 Krejci80dd33e2018-09-26 15:57:18 +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 Krejci70593c12020-06-13 20:48:09 +020023#include "common.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020024#include "in_internal.h"
Radek Krejci70593c12020-06-13 20:48:09 +020025#include "parser_internal.h"
26#include "tree_schema.h"
27#include "tree_schema_internal.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020028
29/* originally static functions from tree_schema_free.c and parser_yang.c */
30void lysp_ext_instance_free(struct ly_ctx *ctx, struct lysp_ext_instance *ext);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020031void lysp_deviation_free(struct ly_ctx *ctx, struct lysp_deviation *dev);
32void lysp_grp_free(struct ly_ctx *ctx, struct lysp_grp *grp);
33void lysp_action_free(struct ly_ctx *ctx, struct lysp_action *action);
34void lysp_notif_free(struct ly_ctx *ctx, struct lysp_notif *notif);
35void lysp_augment_free(struct ly_ctx *ctx, struct lysp_augment *augment);
36void lysp_deviate_free(struct ly_ctx *ctx, struct lysp_deviate *d);
37void lysp_node_free(struct ly_ctx *ctx, struct lysp_node *node);
Radek Krejcif09e4e82019-06-14 15:08:11 +020038void lysp_when_free(struct ly_ctx *ctx, struct lysp_when *when);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020039
Michal Vasko63f3d842020-07-08 10:10:14 +020040LY_ERR buf_add_char(struct ly_ctx *ctx, struct ly_in *in, size_t len, char **buf, size_t *buf_len, size_t *buf_used);
41LY_ERR buf_store_char(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum yang_arg arg, char **word_p,
Radek Krejci1deb5be2020-08-26 16:43:36 +020042 size_t *word_len, char **word_b, size_t *buf_len, uint8_t need_buf, uint8_t *prefix);
Michal Vasko63f3d842020-07-08 10:10:14 +020043LY_ERR get_keyword(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum ly_stmt *kw, char **word_p, size_t *word_len);
44LY_ERR get_argument(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum yang_arg arg,
Radek Krejci2d7a47b2019-05-16 13:34:10 +020045 uint16_t *flags, char **word_p, char **word_b, size_t *word_len);
Radek Krejci1deb5be2020-08-26 16:43:36 +020046LY_ERR skip_comment(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint8_t comment);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020047
Michal Vasko63f3d842020-07-08 10:10:14 +020048LY_ERR parse_action(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_action **actions);
49LY_ERR parse_any(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum ly_stmt kw, struct lysp_node *parent, struct lysp_node **siblings);
50LY_ERR parse_augment(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_augment **augments);
51LY_ERR parse_case(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
52LY_ERR parse_container(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
53LY_ERR parse_deviate(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_deviate **deviates);
54LY_ERR parse_deviation(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_deviation **deviations);
55LY_ERR parse_grouping(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_grp **groupings);
56LY_ERR parse_choice(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
57LY_ERR parse_leaf(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
58LY_ERR parse_leaflist(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
59LY_ERR parse_list(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
60LY_ERR parse_maxelements(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts);
61LY_ERR parse_minelements(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts);
62LY_ERR parse_module(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_module *mod);
63LY_ERR parse_notif(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_notif **notifs);
64LY_ERR parse_submodule(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_submodule *submod);
65LY_ERR parse_uses(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
66LY_ERR parse_when(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_when **when_p);
67LY_ERR parse_type_enum_value_pos(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum ly_stmt val_kw, int64_t *value, uint16_t *flags, struct lysp_ext_instance **exts);
Radek Krejci80dd33e2018-09-26 15:57:18 +020068
69#define BUFSIZE 1024
70char logbuf[BUFSIZE] = {0};
Radek Krejci9ed7a192018-10-31 16:23:51 +010071int store = -1; /* negative for infinite logging, positive for limited logging */
Radek Krejci80dd33e2018-09-26 15:57:18 +020072
73/* set to 0 to printing error messages to stderr instead of checking them in code */
Radek Krejci70853c52018-10-15 14:46:16 +020074#define ENABLE_LOGGER_CHECKING 1
Radek Krejci80dd33e2018-09-26 15:57:18 +020075
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020076#if ENABLE_LOGGER_CHECKING
Radek Krejci80dd33e2018-09-26 15:57:18 +020077static void
78logger(LY_LOG_LEVEL level, const char *msg, const char *path)
79{
80 (void) level; /* unused */
Radek Krejci9ed7a192018-10-31 16:23:51 +010081 if (store) {
82 if (path && path[0]) {
83 snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
84 } else {
85 strncpy(logbuf, msg, BUFSIZE - 1);
86 }
87 if (store > 0) {
88 --store;
89 }
Radek Krejci80dd33e2018-09-26 15:57:18 +020090 }
91}
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020092#endif
Radek Krejci80dd33e2018-09-26 15:57:18 +020093
Michal Vasko5d24f6c2020-10-13 13:49:06 +020094static void
95logger_setup(void)
Radek Krejci80dd33e2018-09-26 15:57:18 +020096{
Radek Krejci80dd33e2018-09-26 15:57:18 +020097#if ENABLE_LOGGER_CHECKING
98 ly_set_log_clb(logger, 1);
99#endif
Radek Krejcib1a5dcc2018-11-26 14:50:05 +0100100}
101
Radek Krejci80dd33e2018-09-26 15:57:18 +0200102void
103logbuf_clean(void)
104{
105 logbuf[0] = '\0';
106}
107
108#if ENABLE_LOGGER_CHECKING
109# define logbuf_assert(str) assert_string_equal(logbuf, str)
110#else
111# define logbuf_assert(str)
112#endif
113
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200114static int
115setup_f(void **state)
116{
117 struct lys_yang_parser_ctx *pctx;
118 LY_ERR ret;
119
120 logger_setup();
121
122 pctx = calloc(1, sizeof *pctx);
123 pctx->format = LYS_IN_YANG;
124 pctx->pos_type = LY_VLOG_LINE;
125 pctx->line = 1;
126
127 pctx->parsed_mod = calloc(1, sizeof *pctx->parsed_mod);
128 pctx->parsed_mod->mod = calloc(1, sizeof *pctx->parsed_mod->mod);
129 pctx->parsed_mod->mod->parsed = pctx->parsed_mod;
130 ret = ly_ctx_new(NULL, 0, &pctx->parsed_mod->mod->ctx);
131 if (ret) {
132 return ret;
133 }
134
135 *state = pctx;
136 return 0;
137}
138
139static int
140teardown_f(void **state)
141{
142 struct lys_yang_parser_ctx *pctx = *state;
143 struct ly_ctx *ctx = pctx->parsed_mod->mod->ctx;
144
145 lys_module_free(pctx->parsed_mod->mod, NULL);
146 ly_ctx_destroy(ctx, NULL);
147 free(pctx);
148
149 return 0;
150}
151
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200152#define TEST_DUP_GENERIC(PREFIX, MEMBER, VALUE1, VALUE2, FUNC, RESULT, LINE, CLEANUP) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200153 in.current = PREFIX MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200154 assert_int_equal(LY_EVALID, FUNC(ctx, &in, RESULT)); \
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200155 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number "LINE"."); \
156 CLEANUP
157
Radek Krejci44ceedc2018-10-02 15:54:31 +0200158static void
159test_helpers(void **state)
160{
Michal Vasko63f3d842020-07-08 10:10:14 +0200161 struct ly_in in = {0};
Radek Krejci404251e2018-10-09 12:06:44 +0200162 char *buf, *p;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200163 size_t len, size;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200164 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200165 uint8_t prefix = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200166
167 /* storing into buffer */
Michal Vasko63f3d842020-07-08 10:10:14 +0200168 in.current = "abcd";
Radek Krejci44ceedc2018-10-02 15:54:31 +0200169 buf = NULL;
170 size = len = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200171 assert_int_equal(LY_SUCCESS, buf_add_char(NULL, &in, 2, &buf, &size, &len));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200172 assert_int_not_equal(0, size);
173 assert_int_equal(2, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200174 assert_string_equal("cd", in.current);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200175 assert_false(strncmp("ab", buf, 2));
176 free(buf);
Radek Krejci404251e2018-10-09 12:06:44 +0200177 buf = NULL;
178
179 /* invalid first characters */
180 len = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200181 in.current = "2invalid";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200182 assert_int_equal(LY_EVALID, buf_store_char(ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Michal Vasko63f3d842020-07-08 10:10:14 +0200183 in.current = ".invalid";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200184 assert_int_equal(LY_EVALID, buf_store_char(ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Michal Vasko63f3d842020-07-08 10:10:14 +0200185 in.current = "-invalid";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200186 assert_int_equal(LY_EVALID, buf_store_char(ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Radek Krejci404251e2018-10-09 12:06:44 +0200187 /* invalid following characters */
188 len = 3; /* number of characters read before the str content */
Michal Vasko63f3d842020-07-08 10:10:14 +0200189 in.current = "!";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200190 assert_int_equal(LY_EVALID, buf_store_char(ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Michal Vasko63f3d842020-07-08 10:10:14 +0200191 in.current = ":";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200192 assert_int_equal(LY_EVALID, buf_store_char(ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Radek Krejci404251e2018-10-09 12:06:44 +0200193 /* valid colon for prefixed identifiers */
194 len = size = 0;
195 p = NULL;
David Sedlák40bb13b2019-07-10 14:34:18 +0200196 prefix = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200197 in.current = "x:id";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200198 assert_int_equal(LY_SUCCESS, buf_store_char(ctx, &in, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 0, &prefix));
Radek Krejci404251e2018-10-09 12:06:44 +0200199 assert_int_equal(1, len);
200 assert_null(buf);
Michal Vasko63f3d842020-07-08 10:10:14 +0200201 assert_string_equal(":id", in.current);
Radek Krejci404251e2018-10-09 12:06:44 +0200202 assert_int_equal('x', p[len - 1]);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200203 assert_int_equal(LY_SUCCESS, buf_store_char(ctx, &in, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
Radek Krejci404251e2018-10-09 12:06:44 +0200204 assert_int_equal(2, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200205 assert_string_equal("id", in.current);
Radek Krejci404251e2018-10-09 12:06:44 +0200206 assert_int_equal(':', p[len - 1]);
207 free(buf);
David Sedlák40bb13b2019-07-10 14:34:18 +0200208 prefix = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200209
210 /* checking identifiers */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200211 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, ':', 0, NULL));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200212 logbuf_assert("Invalid identifier character ':' (0x003a). Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200213 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, '#', 1, NULL));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200214 logbuf_assert("Invalid identifier first character '#' (0x0023). Line number 1.");
Radek Krejci44ceedc2018-10-02 15:54:31 +0200215
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200216 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, 'a', 1, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200217 assert_int_equal(0, prefix);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200218 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, ':', 0, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200219 assert_int_equal(1, prefix);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200220 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, ':', 0, &prefix));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200221 assert_int_equal(1, prefix);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200222 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, 'b', 0, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200223 assert_int_equal(2, prefix);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200224 /* second colon is invalid */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200225 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)ctx, ':', 0, &prefix));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200226 logbuf_assert("Invalid identifier character ':' (0x003a). Line number 1.");
Radek Krejci44ceedc2018-10-02 15:54:31 +0200227}
Radek Krejci80dd33e2018-09-26 15:57:18 +0200228
229static void
230test_comments(void **state)
231{
Michal Vasko63f3d842020-07-08 10:10:14 +0200232 struct ly_in in = {0};
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200233 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejciefd22f62018-09-27 11:47:58 +0200234 char *word, *buf;
235 size_t len;
Radek Krejci80dd33e2018-09-26 15:57:18 +0200236
Michal Vasko63f3d842020-07-08 10:10:14 +0200237 in.current = " // this is a text of / one * line */ comment\nargument;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200238 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200239 assert_string_equal("argument;", word);
Radek Krejciefd22f62018-09-27 11:47:58 +0200240 assert_null(buf);
241 assert_int_equal(8, len);
Radek Krejci80dd33e2018-09-26 15:57:18 +0200242
Michal Vasko63f3d842020-07-08 10:10:14 +0200243 in.current = "/* this is a \n * text // of / block * comment */\"arg\" + \"ume\" \n + \n \"nt\";";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200244 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200245 assert_string_equal("argument", word);
246 assert_ptr_equal(buf, word);
247 assert_int_equal(8, len);
248 free(word);
Radek Krejci80dd33e2018-09-26 15:57:18 +0200249
Michal Vasko63f3d842020-07-08 10:10:14 +0200250 in.current = " this is one line comment on last line";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200251 assert_int_equal(LY_SUCCESS, skip_comment(ctx, &in, 1));
Michal Vasko63f3d842020-07-08 10:10:14 +0200252 assert_true(in.current[0] == '\0');
Radek Krejci80dd33e2018-09-26 15:57:18 +0200253
Michal Vasko63f3d842020-07-08 10:10:14 +0200254 in.current = " this is a not terminated comment x";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200255 assert_int_equal(LY_EVALID, skip_comment(ctx, &in, 2));
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200256 logbuf_assert("Unexpected end-of-input, non-terminated comment. Line number 5.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200257 assert_true(in.current[0] == '\0');
Radek Krejci80dd33e2018-09-26 15:57:18 +0200258}
259
Radek Krejciefd22f62018-09-27 11:47:58 +0200260static void
261test_arg(void **state)
262{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200263 struct lys_yang_parser_ctx *ctx = *state;
Michal Vasko63f3d842020-07-08 10:10:14 +0200264 struct ly_in in = {0};
Radek Krejciefd22f62018-09-27 11:47:58 +0200265 char *word, *buf;
266 size_t len;
267
268 /* missing argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200269 in.current = ";";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200270 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_MAYBE_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200271 assert_null(word);
272
Michal Vasko63f3d842020-07-08 10:10:14 +0200273 in.current = "{";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200274 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200275 logbuf_assert("Invalid character sequence \"{\", expected an argument. Line number 1.");
276
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200277 /* invalid escape sequence */
Michal Vasko63f3d842020-07-08 10:10:14 +0200278 in.current = "\"\\s\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200279 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200280 logbuf_assert("Double-quoted string unknown special character \'\\s\'. Line number 1.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200281 in.current = "\'\\s\'"; /* valid, since it is not an escape sequence in single quoted string */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200282 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200283 assert_int_equal(2, len);
284 assert_string_equal("\\s\'", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200285 assert_int_equal('\0', in.current[0]); /* input has been eaten */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200286
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200287 /* invalid character after the argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200288 in.current = "hello\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200289 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200290 logbuf_assert("Invalid character sequence \"\"\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200291 in.current = "hello}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200292 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200293 logbuf_assert("Invalid character sequence \"}\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
294
David Sedlák40bb13b2019-07-10 14:34:18 +0200295 /* invalid identifier-ref-arg-str */
Michal Vasko63f3d842020-07-08 10:10:14 +0200296 in.current = "pre:pre:value";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200297 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &len));
David Sedlák40bb13b2019-07-10 14:34:18 +0200298
Michal Vasko63f3d842020-07-08 10:10:14 +0200299 in.current = "\"\";"; /* empty identifier is not allowed */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200300 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_IDENTIF_ARG, NULL, &word, &buf, &len));
Radek Krejci4e199f52019-05-28 09:09:28 +0200301 logbuf_assert("Statement argument is required. Line number 1.");
302 logbuf_clean();
Michal Vasko63f3d842020-07-08 10:10:14 +0200303 in.current = "\"\";"; /* empty reference identifier is not allowed */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200304 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &len));
Radek Krejci4e199f52019-05-28 09:09:28 +0200305 logbuf_assert("Statement argument is required. Line number 1.");
306
Michal Vasko63f3d842020-07-08 10:10:14 +0200307 in.current = "hello/x\t"; /* slash is not an invalid character */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200308 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200309 assert_int_equal(7, len);
310 assert_string_equal("hello/x\t", word);
311
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200312 assert_null(buf);
Radek Krejciefd22f62018-09-27 11:47:58 +0200313
314 /* different quoting */
Michal Vasko63f3d842020-07-08 10:10:14 +0200315 in.current = "hello ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200316 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200317 assert_null(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200318 assert_int_equal(5, len);
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200319 assert_string_equal("hello ", word);
Radek Krejciefd22f62018-09-27 11:47:58 +0200320
Michal Vasko63f3d842020-07-08 10:10:14 +0200321 in.current = "hello/*comment*/\n";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200322 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200323 assert_null(buf);
324 assert_int_equal(5, len);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200325 assert_false(strncmp("hello", word, len));
326
327
Michal Vasko63f3d842020-07-08 10:10:14 +0200328 in.current = "\"hello\\n\\t\\\"\\\\\";";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200329 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
fredgand49fe112019-10-21 20:51:50 +0800330 assert_non_null(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200331 assert_int_equal(9, len);
fredgand49fe112019-10-21 20:51:50 +0800332 assert_string_equal("hello\n\t\"\\", word);
333 free(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200334
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200335 ctx->indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200336 in.current = "\"hello \t\n\t\t world!\"";
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200337 /* - space and tabs before newline are stripped out
338 * - space and tabs after newline (indentation) are stripped out
339 */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200340 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200341 assert_non_null(buf);
342 assert_ptr_equal(word, buf);
343 assert_int_equal(14, len);
344 assert_string_equal("hello\n world!", word);
345 free(buf);
Radek Krejciff13cd12019-10-25 15:34:24 +0200346 /* In contrast to previous, the backslash-escaped tabs are expanded after trimming, so they are preserved */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200347 ctx->indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200348 in.current = "\"hello \\t\n\t\\t world!\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200349 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200350 assert_non_null(buf);
351 assert_ptr_equal(word, buf);
352 assert_int_equal(16, len);
353 assert_string_equal("hello \t\n\t world!", word);
354 free(buf);
355 /* Do not handle whitespaces after backslash-escaped newline as indentation */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200356 ctx->indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200357 in.current = "\"hello\\n\t\t world!\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200358 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200359 assert_non_null(buf);
360 assert_ptr_equal(word, buf);
361 assert_int_equal(15, len);
362 assert_string_equal("hello\n\t\t world!", word);
363 free(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200364
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200365 ctx->indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200366 in.current = "\"hello\n \tworld!\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200367 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200368 assert_non_null(buf);
369 assert_ptr_equal(word, buf);
370 assert_int_equal(12, len);
371 assert_string_equal("hello\nworld!", word);
372 free(buf);
Radek Krejciefd22f62018-09-27 11:47:58 +0200373
Michal Vasko63f3d842020-07-08 10:10:14 +0200374 in.current = "\'hello\'";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200375 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200376 assert_null(buf);
377 assert_int_equal(5, len);
378 assert_false(strncmp("hello", word, 5));
379
Michal Vasko63f3d842020-07-08 10:10:14 +0200380 in.current = "\"hel\" +\t\n\"lo\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200381 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200382 assert_ptr_equal(word, buf);
383 assert_int_equal(5, len);
384 assert_string_equal("hello", word);
385 free(buf);
Michal Vasko63f3d842020-07-08 10:10:14 +0200386 in.current = "\"hel\" +\t\nlo"; /* unquoted the second part */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200387 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200388 logbuf_assert("Both string parts divided by '+' must be quoted. Line number 6.");
Radek Krejciefd22f62018-09-27 11:47:58 +0200389
Michal Vasko63f3d842020-07-08 10:10:14 +0200390 in.current = "\'he\'\t\n+ \"llo\"";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200391 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200392 assert_ptr_equal(word, buf);
393 assert_int_equal(5, len);
394 assert_string_equal("hello", word);
395 free(buf);
396
Michal Vasko63f3d842020-07-08 10:10:14 +0200397 in.current = " \t\n\"he\"+\'llo\'";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200398 assert_int_equal(LY_SUCCESS, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200399 assert_ptr_equal(word, buf);
400 assert_int_equal(5, len);
401 assert_string_equal("hello", word);
402 free(buf);
403
Radek Krejci44ceedc2018-10-02 15:54:31 +0200404 /* missing argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200405 in.current = ";";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200406 assert_int_equal(LY_EVALID, get_argument(ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200407 logbuf_assert("Invalid character sequence \";\", expected an argument. Line number 8.");
Radek Krejcidcc7b322018-10-11 14:24:02 +0200408}
409
410static void
411test_stmts(void **state)
412{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200413 struct lys_yang_parser_ctx *ctx = *state;
Michal Vasko63f3d842020-07-08 10:10:14 +0200414 struct ly_in in = {0};
415 const char *p;
Radek Krejcid6b76452019-09-03 17:03:03 +0200416 enum ly_stmt kw;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200417 char *word;
418 size_t len;
419
Michal Vasko63f3d842020-07-08 10:10:14 +0200420 in.current = "\n// comment\n\tinput\t{";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200421 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200422 assert_int_equal(LY_STMT_INPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200423 assert_int_equal(5, len);
424 assert_string_equal("input\t{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200425 assert_string_equal("\t{", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200426
Michal Vasko63f3d842020-07-08 10:10:14 +0200427 in.current = "\t /* comment */\t output\n\t{";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200428 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200429 assert_int_equal(LY_STMT_OUTPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200430 assert_int_equal(6, len);
431 assert_string_equal("output\n\t{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200432 assert_string_equal("\n\t{", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200433 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200434 assert_int_equal(LY_STMT_SYNTAX_LEFT_BRACE, kw);
Radek Krejciabdd8062019-06-11 16:44:19 +0200435 assert_int_equal(1, len);
436 assert_string_equal("{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200437 assert_string_equal("", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200438
Michal Vasko63f3d842020-07-08 10:10:14 +0200439 in.current = "/input { "; /* invalid slash */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200440 assert_int_equal(LY_EVALID, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200441 logbuf_assert("Invalid identifier first character '/'. Line number 4.");
442
Michal Vasko63f3d842020-07-08 10:10:14 +0200443 in.current = "not-a-statement-nor-extension { "; /* invalid identifier */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200444 assert_int_equal(LY_EVALID, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200445 logbuf_assert("Invalid character sequence \"not-a-statement-nor-extension\", expected a keyword. Line number 4.");
446
Michal Vasko63f3d842020-07-08 10:10:14 +0200447 in.current = "path;"; /* missing sep after the keyword */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200448 assert_int_equal(LY_EVALID, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200449 logbuf_assert("Invalid character sequence \"path;\", expected a keyword followed by a separator. Line number 4.");
450
Michal Vasko63f3d842020-07-08 10:10:14 +0200451 in.current = "action ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200452 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200453 assert_int_equal(LY_STMT_ACTION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200454 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200455 in.current = "anydata ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200456 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200457 assert_int_equal(LY_STMT_ANYDATA, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200458 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200459 in.current = "anyxml ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200460 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200461 assert_int_equal(LY_STMT_ANYXML, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200462 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200463 in.current = "argument ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200464 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200465 assert_int_equal(LY_STMT_ARGUMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200466 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200467 in.current = "augment ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200468 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200469 assert_int_equal(LY_STMT_AUGMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200470 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200471 in.current = "base ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200472 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200473 assert_int_equal(LY_STMT_BASE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200474 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200475 in.current = "belongs-to ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200476 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200477 assert_int_equal(LY_STMT_BELONGS_TO, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200478 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200479 in.current = "bit ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200480 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200481 assert_int_equal(LY_STMT_BIT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200482 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200483 in.current = "case ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200484 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200485 assert_int_equal(LY_STMT_CASE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200486 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200487 in.current = "choice ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200488 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200489 assert_int_equal(LY_STMT_CHOICE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200490 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200491 in.current = "config ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200492 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200493 assert_int_equal(LY_STMT_CONFIG, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200494 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200495 in.current = "contact ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200496 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200497 assert_int_equal(LY_STMT_CONTACT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200498 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200499 in.current = "container ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200500 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200501 assert_int_equal(LY_STMT_CONTAINER, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200502 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200503 in.current = "default ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200504 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200505 assert_int_equal(LY_STMT_DEFAULT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200506 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200507 in.current = "description ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200508 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200509 assert_int_equal(LY_STMT_DESCRIPTION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200510 assert_int_equal(11, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200511 in.current = "deviate ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200512 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200513 assert_int_equal(LY_STMT_DEVIATE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200514 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200515 in.current = "deviation ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200516 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200517 assert_int_equal(LY_STMT_DEVIATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200518 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200519 in.current = "enum ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200520 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200521 assert_int_equal(LY_STMT_ENUM, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200522 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200523 in.current = "error-app-tag ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200524 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200525 assert_int_equal(LY_STMT_ERROR_APP_TAG, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200526 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200527 in.current = "error-message ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200528 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200529 assert_int_equal(LY_STMT_ERROR_MESSAGE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200530 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200531 in.current = "extension ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200532 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200533 assert_int_equal(LY_STMT_EXTENSION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200534 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200535 in.current = "feature ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200536 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200537 assert_int_equal(LY_STMT_FEATURE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200538 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200539 in.current = "fraction-digits ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200540 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200541 assert_int_equal(LY_STMT_FRACTION_DIGITS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200542 assert_int_equal(15, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200543 in.current = "grouping ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200544 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200545 assert_int_equal(LY_STMT_GROUPING, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200546 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200547 in.current = "identity ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200548 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200549 assert_int_equal(LY_STMT_IDENTITY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200550 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200551 in.current = "if-feature ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200552 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200553 assert_int_equal(LY_STMT_IF_FEATURE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200554 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200555 in.current = "import ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200556 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200557 assert_int_equal(LY_STMT_IMPORT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200558 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200559 in.current = "include ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200560 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200561 assert_int_equal(LY_STMT_INCLUDE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200562 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200563 in.current = "input{";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200564 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200565 assert_int_equal(LY_STMT_INPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200566 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200567 in.current = "key ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200568 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200569 assert_int_equal(LY_STMT_KEY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200570 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200571 in.current = "leaf ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200572 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200573 assert_int_equal(LY_STMT_LEAF, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200574 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200575 in.current = "leaf-list ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200576 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200577 assert_int_equal(LY_STMT_LEAF_LIST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200578 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200579 in.current = "length ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200580 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200581 assert_int_equal(LY_STMT_LENGTH, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200582 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200583 in.current = "list ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200584 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200585 assert_int_equal(LY_STMT_LIST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200586 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200587 in.current = "mandatory ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200588 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200589 assert_int_equal(LY_STMT_MANDATORY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200590 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200591 in.current = "max-elements ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200592 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200593 assert_int_equal(LY_STMT_MAX_ELEMENTS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200594 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200595 in.current = "min-elements ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200596 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200597 assert_int_equal(LY_STMT_MIN_ELEMENTS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200598 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200599 in.current = "modifier ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200600 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200601 assert_int_equal(LY_STMT_MODIFIER, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200602 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200603 in.current = "module ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200604 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200605 assert_int_equal(LY_STMT_MODULE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200606 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200607 in.current = "must ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200608 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200609 assert_int_equal(LY_STMT_MUST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200610 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200611 in.current = "namespace ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200612 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200613 assert_int_equal(LY_STMT_NAMESPACE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200614 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200615 in.current = "notification ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200616 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200617 assert_int_equal(LY_STMT_NOTIFICATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200618 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200619 in.current = "ordered-by ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200620 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200621 assert_int_equal(LY_STMT_ORDERED_BY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200622 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200623 in.current = "organization ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200624 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200625 assert_int_equal(LY_STMT_ORGANIZATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200626 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200627 in.current = "output ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200628 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200629 assert_int_equal(LY_STMT_OUTPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200630 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200631 in.current = "path ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200632 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200633 assert_int_equal(LY_STMT_PATH, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200634 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200635 in.current = "pattern ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200636 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200637 assert_int_equal(LY_STMT_PATTERN, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200638 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200639 in.current = "position ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200640 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200641 assert_int_equal(LY_STMT_POSITION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200642 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200643 in.current = "prefix ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200644 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200645 assert_int_equal(LY_STMT_PREFIX, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200646 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200647 in.current = "presence ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200648 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200649 assert_int_equal(LY_STMT_PRESENCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200650 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200651 in.current = "range ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200652 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200653 assert_int_equal(LY_STMT_RANGE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200654 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200655 in.current = "reference ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200656 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200657 assert_int_equal(LY_STMT_REFERENCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200658 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200659 in.current = "refine ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200660 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200661 assert_int_equal(LY_STMT_REFINE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200662 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200663 in.current = "require-instance ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200664 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200665 assert_int_equal(LY_STMT_REQUIRE_INSTANCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200666 assert_int_equal(16, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200667 in.current = "revision ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200668 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200669 assert_int_equal(LY_STMT_REVISION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200670 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200671 in.current = "revision-date ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200672 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200673 assert_int_equal(LY_STMT_REVISION_DATE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200674 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200675 in.current = "rpc ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200676 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200677 assert_int_equal(LY_STMT_RPC, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200678 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200679 in.current = "status ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200680 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200681 assert_int_equal(LY_STMT_STATUS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200682 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200683 in.current = "submodule ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200684 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200685 assert_int_equal(LY_STMT_SUBMODULE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200686 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200687 in.current = "type ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200688 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200689 assert_int_equal(LY_STMT_TYPE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200690 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200691 in.current = "typedef ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200692 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200693 assert_int_equal(LY_STMT_TYPEDEF, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200694 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200695 in.current = "unique ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200696 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200697 assert_int_equal(LY_STMT_UNIQUE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200698 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200699 in.current = "units ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200700 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200701 assert_int_equal(LY_STMT_UNITS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200702 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200703 in.current = "uses ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200704 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200705 assert_int_equal(LY_STMT_USES, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200706 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200707 in.current = "value ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200708 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200709 assert_int_equal(LY_STMT_VALUE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200710 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200711 in.current = "when ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200712 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200713 assert_int_equal(LY_STMT_WHEN, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200714 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200715 in.current = "yang-version ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200716 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200717 assert_int_equal(LY_STMT_YANG_VERSION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200718 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200719 in.current = "yin-element ";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200720 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200721 assert_int_equal(LY_STMT_YIN_ELEMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200722 assert_int_equal(11, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200723 in.current = ";config false;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200724 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200725 assert_int_equal(LY_STMT_SYNTAX_SEMICOLON, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200726 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200727 assert_string_equal("config false;", in.current);
728 in.current = "{ config false;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200729 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200730 assert_int_equal(LY_STMT_SYNTAX_LEFT_BRACE, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200731 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200732 assert_string_equal(" config false;", in.current);
733 in.current = "}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200734 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200735 assert_int_equal(LY_STMT_SYNTAX_RIGHT_BRACE, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200736 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200737 assert_string_equal("", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200738
739 /* geenric extension */
Michal Vasko63f3d842020-07-08 10:10:14 +0200740 in.current = p = "nacm:default-deny-write;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200741 assert_int_equal(LY_SUCCESS, get_keyword(ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200742 assert_int_equal(LY_STMT_EXTENSION_INSTANCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200743 assert_int_equal(23, len);
744 assert_ptr_equal(p, word);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200745}
Radek Krejci44ceedc2018-10-02 15:54:31 +0200746
Radek Krejci05b13982018-11-28 16:22:07 +0100747static void
748test_minmax(void **state)
749{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200750 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci05b13982018-11-28 16:22:07 +0100751 uint16_t flags = 0;
752 uint32_t value = 0;
753 struct lysp_ext_instance *ext = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +0200754 struct ly_in in = {0};
Radek Krejci05b13982018-11-28 16:22:07 +0100755
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200756 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci05b13982018-11-28 16:22:07 +0100757
Michal Vasko63f3d842020-07-08 10:10:14 +0200758 in.current = " 1invalid; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200759 assert_int_equal(LY_EVALID, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100760 logbuf_assert("Invalid value \"1invalid\" of \"min-elements\". Line number 1.");
Radek Krejci05b13982018-11-28 16:22:07 +0100761
762 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200763 in.current = " -1; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200764 assert_int_equal(LY_EVALID, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100765 logbuf_assert("Invalid value \"-1\" of \"min-elements\". Line number 1.");
766
Radek Krejcidf6cad12018-11-28 17:10:55 +0100767 /* implementation limit */
768 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200769 in.current = " 4294967296; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200770 assert_int_equal(LY_EVALID, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100771 logbuf_assert("Value \"4294967296\" is out of \"min-elements\" bounds. Line number 1.");
772
Radek Krejci05b13982018-11-28 16:22:07 +0100773 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200774 in.current = " 1; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200775 assert_int_equal(LY_SUCCESS, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100776 assert_int_equal(LYS_SET_MIN, flags);
777 assert_int_equal(1, value);
778
779 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200780 in.current = " 1 {m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200781 assert_int_equal(LY_SUCCESS, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100782 assert_int_equal(LYS_SET_MIN, flags);
783 assert_int_equal(1, value);
784 assert_non_null(ext);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200785 FREE_ARRAY(ctx->parsed_mod->mod->ctx, ext, lysp_ext_instance_free);
Radek Krejci05b13982018-11-28 16:22:07 +0100786 ext = NULL;
787
788 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200789 in.current = " 1 {config true;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200790 assert_int_equal(LY_EVALID, parse_minelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100791 logbuf_assert("Invalid keyword \"config\" as a child of \"min-elements\". Line number 1.");
792
Michal Vasko63f3d842020-07-08 10:10:14 +0200793 in.current = " 1invalid; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200794 assert_int_equal(LY_EVALID, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100795 logbuf_assert("Invalid value \"1invalid\" of \"max-elements\". Line number 1.");
Radek Krejci05b13982018-11-28 16:22:07 +0100796
797 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200798 in.current = " -1; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200799 assert_int_equal(LY_EVALID, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100800 logbuf_assert("Invalid value \"-1\" of \"max-elements\". Line number 1.");
801
Radek Krejcidf6cad12018-11-28 17:10:55 +0100802 /* implementation limit */
803 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200804 in.current = " 4294967296; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200805 assert_int_equal(LY_EVALID, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100806 logbuf_assert("Value \"4294967296\" is out of \"max-elements\" bounds. Line number 1.");
807
Radek Krejci05b13982018-11-28 16:22:07 +0100808 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200809 in.current = " 1; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200810 assert_int_equal(LY_SUCCESS, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100811 assert_int_equal(LYS_SET_MAX, flags);
812 assert_int_equal(1, value);
813
814 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200815 in.current = " unbounded; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200816 assert_int_equal(LY_SUCCESS, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100817 assert_int_equal(LYS_SET_MAX, flags);
818 assert_int_equal(0, value);
819
820 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200821 in.current = " 1 {m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200822 assert_int_equal(LY_SUCCESS, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100823 assert_int_equal(LYS_SET_MAX, flags);
824 assert_int_equal(1, value);
825 assert_non_null(ext);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200826 FREE_ARRAY(ctx->parsed_mod->mod->ctx, ext, lysp_ext_instance_free);
Radek Krejci05b13982018-11-28 16:22:07 +0100827 ext = NULL;
828
829 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200830 in.current = " 1 {config true;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200831 assert_int_equal(LY_EVALID, parse_maxelements(ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100832 logbuf_assert("Invalid keyword \"config\" as a child of \"max-elements\". Line number 1.");
Radek Krejci05b13982018-11-28 16:22:07 +0100833}
834
Radek Krejci9fcacc12018-10-11 15:59:11 +0200835static struct lysp_module *
Michal Vaskob36053d2020-03-26 15:49:30 +0100836mod_renew(struct lys_yang_parser_ctx *ctx)
Radek Krejci9fcacc12018-10-11 15:59:11 +0200837{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200838 struct ly_ctx *ly_ctx = ctx->parsed_mod->mod->ctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100839
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200840 lys_module_free(ctx->parsed_mod->mod, NULL);
841 ctx->parsed_mod = calloc(1, sizeof *ctx->parsed_mod);
842 ctx->parsed_mod->mod = calloc(1, sizeof *ctx->parsed_mod->mod);
843 ctx->parsed_mod->mod->parsed = ctx->parsed_mod;
844 ctx->parsed_mod->mod->ctx = ly_ctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100845
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200846 return ctx->parsed_mod;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100847}
848
849static struct lysp_submodule *
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200850submod_renew(struct lys_yang_parser_ctx *ctx)
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100851{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200852 struct ly_ctx *ly_ctx = ctx->parsed_mod->mod->ctx;
853
854 lys_module_free(ctx->parsed_mod->mod, NULL);
855 ctx->parsed_mod = calloc(1, sizeof(struct lysp_submodule));
856 ctx->parsed_mod->mod = calloc(1, sizeof *ctx->parsed_mod->mod);
857 lydict_insert(ly_ctx, "name", 0, &ctx->parsed_mod->mod->name);
858 ctx->parsed_mod->mod->parsed = ctx->parsed_mod;
859 ctx->parsed_mod->mod->ctx = ly_ctx;
860
861 return (struct lysp_submodule *)ctx->parsed_mod;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200862}
863
Radek Krejcid33273d2018-10-25 14:55:52 +0200864static LY_ERR test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name),
865 const char *UNUSED(sub_rev), void *user_data, LYS_INFORMAT *format,
866 const char **module_data, void (**free_module_data)(void *model_data, void *user_data))
867{
868 *module_data = user_data;
869 *format = LYS_IN_YANG;
870 *free_module_data = NULL;
871 return LY_SUCCESS;
872}
873
Radek Krejci9fcacc12018-10-11 15:59:11 +0200874static void
875test_module(void **state)
876{
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200877 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci40544fa2019-01-11 09:38:37 +0100878 struct lysp_module *mod = NULL;
879 struct lysp_submodule *submod = NULL;
880 struct lys_module *m;
Michal Vasko63f3d842020-07-08 10:10:14 +0200881 struct ly_in in = {0};
Radek Krejci9fcacc12018-10-11 15:59:11 +0200882
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200883 mod = mod_renew(ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200884
885 /* missing mandatory substatements */
Michal Vasko63f3d842020-07-08 10:10:14 +0200886 in.current = " name {}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200887 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100888 assert_string_equal("name", mod->mod->name);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200889 logbuf_assert("Missing mandatory keyword \"namespace\" as a child of \"module\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200890 mod = mod_renew(ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200891
Michal Vasko63f3d842020-07-08 10:10:14 +0200892 in.current = " name {namespace urn:x;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200893 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100894 assert_string_equal("urn:x", mod->mod->ns);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200895 logbuf_assert("Missing mandatory keyword \"prefix\" as a child of \"module\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200896 mod = mod_renew(ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200897
Michal Vasko63f3d842020-07-08 10:10:14 +0200898 in.current = " name {namespace urn:x;prefix \"x\";}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200899 assert_int_equal(LY_SUCCESS, parse_module(ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100900 assert_string_equal("x", mod->mod->prefix);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200901 mod = mod_renew(ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200902
Radek Krejci027d5802018-11-14 16:57:28 +0100903#define SCHEMA_BEGINNING " name {yang-version 1.1;namespace urn:x;prefix \"x\";"
904#define SCHEMA_BEGINNING2 " name {namespace urn:x;prefix \"x\";"
Radek Krejcia042ea12018-10-13 07:52:15 +0200905#define TEST_NODE(NODETYPE, INPUT, NAME) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200906 in.current = SCHEMA_BEGINNING INPUT; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200907 assert_int_equal(LY_SUCCESS, parse_module(ctx, &in, mod)); \
Radek Krejcia042ea12018-10-13 07:52:15 +0200908 assert_non_null(mod->data); \
909 assert_int_equal(NODETYPE, mod->data->nodetype); \
910 assert_string_equal(NAME, mod->data->name); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200911 mod = mod_renew(ctx);
Radek Krejcia042ea12018-10-13 07:52:15 +0200912#define TEST_GENERIC(INPUT, TARGET, TEST) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200913 in.current = SCHEMA_BEGINNING INPUT; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200914 assert_int_equal(LY_SUCCESS, parse_module(ctx, &in, mod)); \
Radek Krejcia042ea12018-10-13 07:52:15 +0200915 assert_non_null(TARGET); \
916 TEST; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200917 mod = mod_renew(ctx);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100918#define TEST_DUP(MEMBER, VALUE1, VALUE2, LINE) \
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200919 TEST_DUP_GENERIC(SCHEMA_BEGINNING, MEMBER, VALUE1, VALUE2, \
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200920 parse_module, mod, LINE, mod = mod_renew(ctx))
Radek Krejcia042ea12018-10-13 07:52:15 +0200921
922 /* duplicated namespace, prefix */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100923 TEST_DUP("namespace", "y", "z", "1");
924 TEST_DUP("prefix", "y", "z", "1");
925 TEST_DUP("contact", "a", "b", "1");
926 TEST_DUP("description", "a", "b", "1");
927 TEST_DUP("organization", "a", "b", "1");
928 TEST_DUP("reference", "a", "b", "1");
Radek Krejcia042ea12018-10-13 07:52:15 +0200929
Radek Krejci70853c52018-10-15 14:46:16 +0200930 /* not allowed in module (submodule-specific) */
Michal Vasko63f3d842020-07-08 10:10:14 +0200931 in.current = SCHEMA_BEGINNING "belongs-to master {prefix m;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200932 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci70853c52018-10-15 14:46:16 +0200933 logbuf_assert("Invalid keyword \"belongs-to\" as a child of \"module\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200934 mod = mod_renew(ctx);
Radek Krejci70853c52018-10-15 14:46:16 +0200935
Radek Krejcia042ea12018-10-13 07:52:15 +0200936 /* anydata */
937 TEST_NODE(LYS_ANYDATA, "anydata test;}", "test");
938 /* anyxml */
939 TEST_NODE(LYS_ANYXML, "anyxml test;}", "test");
940 /* augment */
941 TEST_GENERIC("augment /somepath;}", mod->augments,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200942 assert_string_equal("/somepath", mod->augments[0].nodeid));
Radek Krejcia042ea12018-10-13 07:52:15 +0200943 /* choice */
944 TEST_NODE(LYS_CHOICE, "choice test;}", "test");
945 /* contact 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100946 TEST_GENERIC("contact \"firstname\" + \n\t\" surname\";}", mod->mod->contact,
947 assert_string_equal("firstname surname", mod->mod->contact));
Radek Krejcia042ea12018-10-13 07:52:15 +0200948 /* container */
949 TEST_NODE(LYS_CONTAINER, "container test;}", "test");
950 /* description 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100951 TEST_GENERIC("description \'some description\';}", mod->mod->dsc,
952 assert_string_equal("some description", mod->mod->dsc));
Radek Krejcia042ea12018-10-13 07:52:15 +0200953 /* deviation */
954 TEST_GENERIC("deviation /somepath {deviate not-supported;}}", mod->deviations,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200955 assert_string_equal("/somepath", mod->deviations[0].nodeid));
Radek Krejcia042ea12018-10-13 07:52:15 +0200956 /* extension */
957 TEST_GENERIC("extension test;}", mod->extensions,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200958 assert_string_equal("test", mod->extensions[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200959 /* feature */
960 TEST_GENERIC("feature test;}", mod->features,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200961 assert_string_equal("test", mod->features[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200962 /* grouping */
963 TEST_GENERIC("grouping grp;}", mod->groupings,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200964 assert_string_equal("grp", mod->groupings[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200965 /* identity */
966 TEST_GENERIC("identity test;}", mod->identities,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200967 assert_string_equal("test", mod->identities[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200968 /* import */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200969 ly_ctx_set_module_imp_clb(ctx->parsed_mod->mod->ctx, test_imp_clb, "module zzz { namespace urn:zzz; prefix z;}");
Radek Krejci086c7132018-10-26 15:29:04 +0200970 TEST_GENERIC("import zzz {prefix z;}}", mod->imports,
971 assert_string_equal("zzz", mod->imports[0].name));
Radek Krejci70853c52018-10-15 14:46:16 +0200972
Radek Krejcia042ea12018-10-13 07:52:15 +0200973 /* import - prefix collision */
Michal Vasko63f3d842020-07-08 10:10:14 +0200974 in.current = SCHEMA_BEGINNING "import zzz {prefix x;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200975 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci70853c52018-10-15 14:46:16 +0200976 logbuf_assert("Prefix \"x\" already used as module prefix. Line number 2.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200977 mod = mod_renew(ctx);
Michal Vasko63f3d842020-07-08 10:10:14 +0200978 in.current = SCHEMA_BEGINNING "import zzz {prefix y;}import zzz {prefix y;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200979 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci086c7132018-10-26 15:29:04 +0200980 logbuf_assert("Prefix \"y\" already used to import \"zzz\" module. Line number 2.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200981 mod = mod_renew(ctx);
Michal Vasko7c8439f2020-08-05 13:25:19 +0200982 in.current = "module name10 {yang-version 1.1;namespace urn:x;prefix \"x\";import zzz {prefix y;}import zzz {prefix z;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200983 assert_int_equal(lys_parse_mem(ctx->parsed_mod->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_SUCCESS);
Michal Vasko7c8439f2020-08-05 13:25:19 +0200984 logbuf_assert("Single revision of the module \"zzz\" imported twice.");
Radek Krejci70853c52018-10-15 14:46:16 +0200985
Radek Krejcia042ea12018-10-13 07:52:15 +0200986 /* include */
Radek Krejci9ed7a192018-10-31 16:23:51 +0100987 store = 1;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200988 ly_ctx_set_module_imp_clb(ctx->parsed_mod->mod->ctx, test_imp_clb, "module xxx { namespace urn:xxx; prefix x;}");
Michal Vasko63f3d842020-07-08 10:10:14 +0200989 in.current = "module" SCHEMA_BEGINNING "include xxx;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200990 assert_int_equal(lys_parse_mem(ctx->parsed_mod->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_EVALID);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100991 logbuf_assert("Input data contains module in situation when a submodule is expected.");
Radek Krejci9ed7a192018-10-31 16:23:51 +0100992 store = -1;
Radek Krejcid33273d2018-10-25 14:55:52 +0200993
Radek Krejci9ed7a192018-10-31 16:23:51 +0100994 store = 1;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200995 ly_ctx_set_module_imp_clb(ctx->parsed_mod->mod->ctx, test_imp_clb, "submodule xxx {belongs-to wrong-name {prefix w;}}");
Michal Vasko63f3d842020-07-08 10:10:14 +0200996 in.current = "module" SCHEMA_BEGINNING "include xxx;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200997 assert_int_equal(lys_parse_mem(ctx->parsed_mod->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_EVALID);
Michal Vaskoc3781c32020-10-06 14:04:08 +0200998 logbuf_assert("Submodule \"belongs-to\" value \"wrong-name\" does not match its module name \"name\". Line number 1.");
Radek Krejci9ed7a192018-10-31 16:23:51 +0100999 store = -1;
Radek Krejcid33273d2018-10-25 14:55:52 +02001000
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001001 ly_ctx_set_module_imp_clb(ctx->parsed_mod->mod->ctx, test_imp_clb, "submodule xxx {belongs-to name {prefix x;}}");
Radek Krejcid33273d2018-10-25 14:55:52 +02001002 TEST_GENERIC("include xxx;}", mod->includes,
Radek Krejci086c7132018-10-26 15:29:04 +02001003 assert_string_equal("xxx", mod->includes[0].name));
Radek Krejcid33273d2018-10-25 14:55:52 +02001004
Radek Krejcia042ea12018-10-13 07:52:15 +02001005 /* leaf */
1006 TEST_NODE(LYS_LEAF, "leaf test {type string;}}", "test");
1007 /* leaf-list */
1008 TEST_NODE(LYS_LEAFLIST, "leaf-list test {type string;}}", "test");
1009 /* list */
1010 TEST_NODE(LYS_LIST, "list test {key a;leaf a {type string;}}}", "test");
1011 /* notification */
1012 TEST_GENERIC("notification test;}", mod->notifs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001013 assert_string_equal("test", mod->notifs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001014 /* organization 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001015 TEST_GENERIC("organization \"CESNET a.l.e.\";}", mod->mod->org,
1016 assert_string_equal("CESNET a.l.e.", mod->mod->org));
Radek Krejcia042ea12018-10-13 07:52:15 +02001017 /* reference 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001018 TEST_GENERIC("reference RFC7950;}", mod->mod->ref,
1019 assert_string_equal("RFC7950", mod->mod->ref));
Radek Krejcia042ea12018-10-13 07:52:15 +02001020 /* revision */
1021 TEST_GENERIC("revision 2018-10-12;}", mod->revs,
Radek Krejcib7db73a2018-10-24 14:18:40 +02001022 assert_string_equal("2018-10-12", mod->revs[0].date));
Radek Krejcia042ea12018-10-13 07:52:15 +02001023 /* rpc */
1024 TEST_GENERIC("rpc test;}", mod->rpcs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001025 assert_string_equal("test", mod->rpcs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001026 /* typedef */
1027 TEST_GENERIC("typedef test{type string;}}", mod->typedefs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001028 assert_string_equal("test", mod->typedefs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001029 /* uses */
1030 TEST_NODE(LYS_USES, "uses test;}", "test");
1031 /* yang-version */
Michal Vasko63f3d842020-07-08 10:10:14 +02001032 in.current = SCHEMA_BEGINNING2 "\n\tyang-version 10;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001033 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejcia042ea12018-10-13 07:52:15 +02001034 logbuf_assert("Invalid value \"10\" of \"yang-version\". Line number 3.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001035 mod = mod_renew(ctx);
Radek Krejci96e48da2020-09-04 13:18:06 +02001036 in.current = SCHEMA_BEGINNING2 "yang-version 1;yang-version 1.1;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001037 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejcia042ea12018-10-13 07:52:15 +02001038 logbuf_assert("Duplicate keyword \"yang-version\". Line number 3.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001039 mod = mod_renew(ctx);
Radek Krejci96e48da2020-09-04 13:18:06 +02001040 in.current = SCHEMA_BEGINNING2 "yang-version 1;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001041 assert_int_equal(LY_SUCCESS, parse_module(ctx, &in, mod));
1042 assert_int_equal(1, mod->version);
1043 mod = mod_renew(ctx);
Michal Vasko63f3d842020-07-08 10:10:14 +02001044 in.current = SCHEMA_BEGINNING2 "yang-version \"1.1\";}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001045 assert_int_equal(LY_SUCCESS, parse_module(ctx, &in, mod));
1046 assert_int_equal(2, mod->version);
1047 mod = mod_renew(ctx);
Radek Krejci40544fa2019-01-11 09:38:37 +01001048
Michal Vaskob36053d2020-03-26 15:49:30 +01001049 struct lys_yang_parser_ctx *ctx_p = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001050 in.current = "module " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001051 m = calloc(1, sizeof *m);
1052 m->ctx = ctx->parsed_mod->mod->ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +02001053 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
David Sedlák1b623122019-08-05 15:27:49 +02001054 logbuf_assert("Trailing garbage \"module q {names...\" after module, expected end-of-input. Line number 1.");
Michal Vaskob36053d2020-03-26 15:49:30 +01001055 yang_parser_ctx_free(ctx_p);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001056 lys_module_free(m, NULL);
Radek Krejci40544fa2019-01-11 09:38:37 +01001057
Michal Vasko63f3d842020-07-08 10:10:14 +02001058 in.current = "prefix " SCHEMA_BEGINNING "}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001059 m = calloc(1, sizeof *m);
1060 m->ctx = ctx->parsed_mod->mod->ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +02001061 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
David Sedlák1b623122019-08-05 15:27:49 +02001062 logbuf_assert("Invalid keyword \"prefix\", expected \"module\" or \"submodule\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001063 yang_parser_ctx_free(ctx_p);
1064 lys_module_free(m, NULL);
Radek Krejci09306362018-10-15 15:26:01 +02001065
Michal Vasko63f3d842020-07-08 10:10:14 +02001066 in.current = "module " SCHEMA_BEGINNING "leaf enum {type enumeration {enum seven { position 7;}}}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001067 m = calloc(1, sizeof *m);
1068 m->ctx = ctx->parsed_mod->mod->ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +02001069 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
David Sedlák1b623122019-08-05 15:27:49 +02001070 logbuf_assert("Invalid keyword \"position\" as a child of \"enum\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001071 yang_parser_ctx_free(ctx_p);
1072 lys_module_free(m, NULL);
David Sedlák9fb515f2019-07-11 10:33:58 +02001073
Radek Krejci156ccaf2018-10-15 15:49:17 +02001074 /* extensions */
1075 TEST_GENERIC("prefix:test;}", mod->exts,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001076 assert_string_equal("prefix:test", mod->exts[0].name);
1077 assert_int_equal(LYEXT_SUBSTMT_SELF, mod->exts[0].insubstmt));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001078 mod = mod_renew(ctx);
Radek Krejci156ccaf2018-10-15 15:49:17 +02001079
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001080 /* invalid substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001081 in.current = SCHEMA_BEGINNING "must false;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001082 assert_int_equal(LY_EVALID, parse_module(ctx, &in, mod));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001083 logbuf_assert("Invalid keyword \"must\" as a child of \"module\". Line number 3.");
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001084
Radek Krejci09306362018-10-15 15:26:01 +02001085 /* submodule */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001086 submod = submod_renew(ctx);
Radek Krejci09306362018-10-15 15:26:01 +02001087
1088 /* missing mandatory substatements */
Michal Vasko63f3d842020-07-08 10:10:14 +02001089 in.current = " subname {}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001090 assert_int_equal(LY_EVALID, parse_submodule(ctx, &in, submod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001091 assert_string_equal("subname", submod->name);
Radek Krejci09306362018-10-15 15:26:01 +02001092 logbuf_assert("Missing mandatory keyword \"belongs-to\" as a child of \"submodule\". Line number 3.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001093 submod = submod_renew(ctx);
Radek Krejci09306362018-10-15 15:26:01 +02001094
Michal Vasko63f3d842020-07-08 10:10:14 +02001095 in.current = " subname {belongs-to name {prefix x;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001096 assert_int_equal(LY_SUCCESS, parse_submodule(ctx, &in, submod));
Michal Vaskoc3781c32020-10-06 14:04:08 +02001097 assert_string_equal("name", submod->mod->name);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001098 submod = submod_renew(ctx);
Radek Krejci09306362018-10-15 15:26:01 +02001099
1100#undef SCHEMA_BEGINNING
Radek Krejci313d9902018-11-08 09:42:58 +01001101#define SCHEMA_BEGINNING " subname {belongs-to name {prefix x;}"
Radek Krejci09306362018-10-15 15:26:01 +02001102
1103 /* duplicated namespace, prefix */
Michal Vasko63f3d842020-07-08 10:10:14 +02001104 in.current = " subname {belongs-to name {prefix x;}belongs-to module1;belongs-to module2;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001105 assert_int_equal(LY_EVALID, parse_submodule(ctx, &in, submod)); \
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001106 logbuf_assert("Duplicate keyword \"belongs-to\". Line number 3."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001107 submod = submod_renew(ctx);
Radek Krejci09306362018-10-15 15:26:01 +02001108
1109 /* not allowed in submodule (module-specific) */
Michal Vasko63f3d842020-07-08 10:10:14 +02001110 in.current = SCHEMA_BEGINNING "namespace \"urn:z\";}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001111 assert_int_equal(LY_EVALID, parse_submodule(ctx, &in, submod));
Radek Krejci09306362018-10-15 15:26:01 +02001112 logbuf_assert("Invalid keyword \"namespace\" as a child of \"submodule\". Line number 3.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001113 submod = submod_renew(ctx);
Michal Vasko63f3d842020-07-08 10:10:14 +02001114 in.current = SCHEMA_BEGINNING "prefix m;}}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001115 assert_int_equal(LY_EVALID, parse_submodule(ctx, &in, submod));
Radek Krejci09306362018-10-15 15:26:01 +02001116 logbuf_assert("Invalid keyword \"prefix\" as a child of \"submodule\". Line number 3.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001117 submod = submod_renew(ctx);
Radek Krejcia042ea12018-10-13 07:52:15 +02001118
Michal Vasko63f3d842020-07-08 10:10:14 +02001119 in.current = "submodule " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001120 assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, ctx->parsed_mod->mod->ctx, (struct lys_parser_ctx *)ctx, &in, &submod));
Michal Vaskob36053d2020-03-26 15:49:30 +01001121 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001122 logbuf_assert("Trailing garbage \"module q {names...\" after submodule, expected end-of-input. Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001123
Michal Vasko63f3d842020-07-08 10:10:14 +02001124 in.current = "prefix " SCHEMA_BEGINNING "}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001125 assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, ctx->parsed_mod->mod->ctx, (struct lys_parser_ctx *)ctx, &in, &submod));
Michal Vaskob36053d2020-03-26 15:49:30 +01001126 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001127 logbuf_assert("Invalid keyword \"prefix\", expected \"module\" or \"submodule\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001128 submod = submod_renew(ctx);
Radek Krejci40544fa2019-01-11 09:38:37 +01001129
Radek Krejcia042ea12018-10-13 07:52:15 +02001130#undef TEST_GENERIC
1131#undef TEST_NODE
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001132#undef TEST_DUP
Radek Krejcia042ea12018-10-13 07:52:15 +02001133#undef SCHEMA_BEGINNING
Radek Krejciefd22f62018-09-27 11:47:58 +02001134}
1135
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001136static void
1137test_deviation(void **state)
1138{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001139 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001140 struct lysp_deviation *d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001141 struct ly_in in = {0};
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001142
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001143 /* invalid cardinality */
1144#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
1145 TEST_DUP_GENERIC(" test {deviate not-supported;", MEMBER, VALUE1, VALUE2, parse_deviation, \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001146 &d, "1", FREE_ARRAY(ctx->parsed_mod->mod->ctx, d, lysp_deviation_free); d = NULL)
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001147
1148 TEST_DUP("description", "a", "b");
1149 TEST_DUP("reference", "a", "b");
1150
1151 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001152 in.current = " test {deviate not-supported;description text;reference \'another text\';prefix:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001153 assert_int_equal(LY_SUCCESS, parse_deviation(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001154 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001155 assert_string_equal(" ...", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001156 FREE_ARRAY(ctx->parsed_mod->mod->ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001157 d = NULL;
1158
1159 /* missing mandatory substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001160 in.current = " test {description text;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001161 assert_int_equal(LY_EVALID, parse_deviation(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001162 logbuf_assert("Missing mandatory keyword \"deviate\" as a child of \"deviation\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001163 FREE_ARRAY(ctx->parsed_mod->mod->ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001164 d = NULL;
1165
1166 /* invalid substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001167 in.current = " test {deviate not-supported; status obsolete;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001168 assert_int_equal(LY_EVALID, parse_deviation(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001169 logbuf_assert("Invalid keyword \"status\" as a child of \"deviation\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001170 FREE_ARRAY(ctx->parsed_mod->mod->ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001171 d = NULL;
1172
1173#undef TEST_DUP
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001174}
1175
1176static void
1177test_deviate(void **state)
1178{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001179 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001180 struct lysp_deviate *d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001181 struct ly_in in = {0};
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001182
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001183 /* invalid cardinality */
1184#define TEST_DUP(TYPE, MEMBER, VALUE1, VALUE2) \
1185 TEST_DUP_GENERIC(TYPE" {", MEMBER, VALUE1, VALUE2, parse_deviate, \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001186 &d, "1", lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL)
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001187
1188 TEST_DUP("add", "config", "true", "false");
1189 TEST_DUP("replace", "default", "int8", "uint8");
1190 TEST_DUP("add", "mandatory", "true", "false");
1191 TEST_DUP("add", "max-elements", "1", "2");
1192 TEST_DUP("add", "min-elements", "1", "2");
1193 TEST_DUP("replace", "type", "int8", "uint8");
1194 TEST_DUP("add", "units", "kilometers", "miles");
1195
1196 /* full contents */
Michal Vasko63f3d842020-07-08 10:10:14 +02001197 in.current = " not-supported {prefix:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001198 assert_int_equal(LY_SUCCESS, parse_deviate(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001199 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001200 assert_string_equal(" ...", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001201 lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001202 in.current = " add {units meters; must 1; must 2; unique x; unique y; default a; default b; config true; mandatory true; min-elements 1; max-elements 2; prefix:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001203 assert_int_equal(LY_SUCCESS, parse_deviate(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001204 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001205 assert_string_equal(" ...", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001206 lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001207 in.current = " delete {units meters; must 1; must 2; unique x; unique y; default a; default b; prefix:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001208 assert_int_equal(LY_SUCCESS, parse_deviate(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001209 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001210 assert_string_equal(" ...", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001211 lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001212 in.current = " replace {type string; units meters; default a; config true; mandatory true; min-elements 1; max-elements 2; prefix:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001213 assert_int_equal(LY_SUCCESS, parse_deviate(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001214 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001215 assert_string_equal(" ...", in.current);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001216 lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001217
1218 /* invalid substatements */
1219#define TEST_NOT_SUP(DEV, STMT, VALUE) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001220 in.current = " "DEV" {"STMT" "VALUE";}..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001221 assert_int_equal(LY_EVALID, parse_deviate(ctx, &in, &d)); \
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001222 logbuf_assert("Deviate \""DEV"\" does not support keyword \""STMT"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001223 lysp_deviate_free(ctx->parsed_mod->mod->ctx, d); free(d); d = NULL
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001224
1225 TEST_NOT_SUP("not-supported", "units", "meters");
1226 TEST_NOT_SUP("not-supported", "must", "1");
1227 TEST_NOT_SUP("not-supported", "unique", "x");
1228 TEST_NOT_SUP("not-supported", "default", "a");
1229 TEST_NOT_SUP("not-supported", "config", "true");
1230 TEST_NOT_SUP("not-supported", "mandatory", "true");
1231 TEST_NOT_SUP("not-supported", "min-elements", "1");
1232 TEST_NOT_SUP("not-supported", "max-elements", "2");
1233 TEST_NOT_SUP("not-supported", "type", "string");
1234 TEST_NOT_SUP("add", "type", "string");
1235 TEST_NOT_SUP("delete", "config", "true");
1236 TEST_NOT_SUP("delete", "mandatory", "true");
1237 TEST_NOT_SUP("delete", "min-elements", "1");
1238 TEST_NOT_SUP("delete", "max-elements", "2");
1239 TEST_NOT_SUP("delete", "type", "string");
1240 TEST_NOT_SUP("replace", "must", "1");
1241 TEST_NOT_SUP("replace", "unique", "a");
1242
Michal Vasko63f3d842020-07-08 10:10:14 +02001243 in.current = " nonsence; ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001244 assert_int_equal(LY_EVALID, parse_deviate(ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001245 logbuf_assert("Invalid value \"nonsence\" of \"deviate\". Line number 1.");
1246 assert_null(d);
1247
1248#undef TEST_NOT_SUP
1249#undef TEST_DUP
Radek Krejci4c6d9bd2018-10-15 16:43:06 +02001250}
1251
Radek Krejci8c370832018-11-02 15:10:03 +01001252static void
1253test_container(void **state)
1254{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001255 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci8c370832018-11-02 15:10:03 +01001256 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001257 struct ly_in in = {0};
Radek Krejci8c370832018-11-02 15:10:03 +01001258
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001259 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci8c370832018-11-02 15:10:03 +01001260
1261 /* invalid cardinality */
1262#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001263 in.current = "cont {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001264 assert_int_equal(LY_EVALID, parse_container(ctx, &in, NULL, (struct lysp_node**)&c)); \
Radek Krejci8c370832018-11-02 15:10:03 +01001265 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001266 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001267
1268 TEST_DUP("config", "true", "false");
1269 TEST_DUP("description", "text1", "text2");
1270 TEST_DUP("presence", "true", "false");
1271 TEST_DUP("reference", "1", "2");
1272 TEST_DUP("status", "current", "obsolete");
1273 TEST_DUP("when", "true", "false");
1274#undef TEST_DUP
1275
1276 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001277 in.current = "cont {action x;anydata any;anyxml anyxml; choice ch;config false;container c;description test;grouping g;if-feature f; leaf l {type string;}"
Radek Krejci313d9902018-11-08 09:42:58 +01001278 "leaf-list ll {type string;} list li;must 'expr';notification not; presence true; reference test;status current;typedef t {type int8;}uses g;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001279 assert_int_equal(LY_SUCCESS, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001280 assert_non_null(c);
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001281 assert_int_equal(LYS_CONTAINER, c->nodetype);
1282 assert_string_equal("cont", c->name);
Radek Krejci8c370832018-11-02 15:10:03 +01001283 assert_non_null(c->actions);
1284 assert_non_null(c->child);
1285 assert_string_equal("test", c->dsc);
1286 assert_non_null(c->exts);
1287 assert_non_null(c->groupings);
1288 assert_non_null(c->iffeatures);
1289 assert_non_null(c->musts);
1290 assert_non_null(c->notifs);
1291 assert_string_equal("true", c->presence);
1292 assert_string_equal("test", c->ref);
1293 assert_non_null(c->typedefs);
1294 assert_non_null(c->when);
1295 assert_null(c->parent);
1296 assert_null(c->next);
1297 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR, c->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001298 ly_set_erase(&ctx->tpdfs_nodes, NULL);
1299 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001300
1301 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001302 in.current = " cont {augment /root;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001303 assert_int_equal(LY_EVALID, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001304 logbuf_assert("Invalid keyword \"augment\" as a child of \"container\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001305 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c); c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001306 in.current = " cont {nonsence true;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001307 assert_int_equal(LY_EVALID, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001308 logbuf_assert("Invalid character sequence \"nonsence\", expected a keyword. Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001309 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001310
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001311 ctx->parsed_mod->version = 1; /* simulate YANG 1.0 */
Michal Vasko63f3d842020-07-08 10:10:14 +02001312 in.current = " cont {action x;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001313 assert_int_equal(LY_EVALID, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejcif538ce52019-03-05 10:46:14 +01001314 logbuf_assert("Invalid keyword \"action\" as a child of \"container\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001315 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001316}
1317
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001318static void
1319test_leaf(void **state)
1320{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001321 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001322 struct lysp_node_leaf *l = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001323 struct ly_in in = {0};
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001324
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001325 /* invalid cardinality */
1326#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001327 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001328 assert_int_equal(LY_EVALID, parse_leaf(ctx, &in, NULL, (struct lysp_node**)&l)); \
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001329 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001330 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001331
1332 TEST_DUP("config", "true", "false");
1333 TEST_DUP("default", "x", "y");
1334 TEST_DUP("description", "text1", "text2");
1335 TEST_DUP("mandatory", "true", "false");
1336 TEST_DUP("reference", "1", "2");
1337 TEST_DUP("status", "current", "obsolete");
Radek Krejci0e5d8382018-11-28 16:37:53 +01001338 TEST_DUP("type", "int8", "uint8");
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001339 TEST_DUP("units", "text1", "text2");
1340 TEST_DUP("when", "true", "false");
1341#undef TEST_DUP
1342
1343 /* full content - without mandatory which is mutual exclusive with default */
Michal Vasko63f3d842020-07-08 10:10:14 +02001344 in.current = "l {config false;default \"xxx\";description test;if-feature f;"
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001345 "must 'expr';reference test;status current;type string; units yyy;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001346 assert_int_equal(LY_SUCCESS, parse_leaf(ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001347 assert_non_null(l);
1348 assert_int_equal(LYS_LEAF, l->nodetype);
1349 assert_string_equal("l", l->name);
1350 assert_string_equal("test", l->dsc);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001351 assert_string_equal("xxx", l->dflt.str);
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001352 assert_string_equal("yyy", l->units);
1353 assert_string_equal("string", l->type.name);
1354 assert_non_null(l->exts);
1355 assert_non_null(l->iffeatures);
1356 assert_non_null(l->musts);
1357 assert_string_equal("test", l->ref);
1358 assert_non_null(l->when);
1359 assert_null(l->parent);
1360 assert_null(l->next);
1361 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR, l->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001362 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001363
1364 /* full content - now with mandatory */
Michal Vasko63f3d842020-07-08 10:10:14 +02001365 in.current = "l {mandatory true; type string;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001366 assert_int_equal(LY_SUCCESS, parse_leaf(ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001367 assert_non_null(l);
1368 assert_int_equal(LYS_LEAF, l->nodetype);
1369 assert_string_equal("l", l->name);
1370 assert_string_equal("string", l->type.name);
1371 assert_int_equal(LYS_MAND_TRUE, l->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001372 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001373
1374 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001375 in.current = " l {description \"missing type\";} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001376 assert_int_equal(LY_EVALID, parse_leaf(ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001377 logbuf_assert("Missing mandatory keyword \"type\" as a child of \"leaf\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001378 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001379}
1380
Radek Krejci0e5d8382018-11-28 16:37:53 +01001381static void
1382test_leaflist(void **state)
1383{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001384 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001385 struct lysp_node_leaflist *ll = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001386 struct ly_in in = {0};
Radek Krejci0e5d8382018-11-28 16:37:53 +01001387
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001388 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci0e5d8382018-11-28 16:37:53 +01001389
1390 /* invalid cardinality */
1391#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001392 in.current = "ll {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001393 assert_int_equal(LY_EVALID, parse_leaflist(ctx, &in, NULL, (struct lysp_node**)&ll)); \
Radek Krejci0e5d8382018-11-28 16:37:53 +01001394 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001395 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ll); ll = NULL;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001396
1397 TEST_DUP("config", "true", "false");
1398 TEST_DUP("description", "text1", "text2");
1399 TEST_DUP("max-elements", "10", "20");
1400 TEST_DUP("min-elements", "10", "20");
1401 TEST_DUP("ordered-by", "user", "system");
1402 TEST_DUP("reference", "1", "2");
1403 TEST_DUP("status", "current", "obsolete");
1404 TEST_DUP("type", "int8", "uint8");
1405 TEST_DUP("units", "text1", "text2");
1406 TEST_DUP("when", "true", "false");
1407#undef TEST_DUP
1408
1409 /* full content - without min-elements which is mutual exclusive with default */
Michal Vasko63f3d842020-07-08 10:10:14 +02001410 in.current = "ll {config false;default \"xxx\"; default \"yyy\";description test;if-feature f;"
Radek Krejci0e5d8382018-11-28 16:37:53 +01001411 "max-elements 10;must 'expr';ordered-by user;reference test;"
1412 "status current;type string; units zzz;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001413 assert_int_equal(LY_SUCCESS, parse_leaflist(ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001414 assert_non_null(ll);
1415 assert_int_equal(LYS_LEAFLIST, ll->nodetype);
1416 assert_string_equal("ll", ll->name);
1417 assert_string_equal("test", ll->dsc);
1418 assert_non_null(ll->dflts);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001419 assert_int_equal(2, LY_ARRAY_COUNT(ll->dflts));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001420 assert_string_equal("xxx", ll->dflts[0].str);
1421 assert_string_equal("yyy", ll->dflts[1].str);
Radek Krejci0e5d8382018-11-28 16:37:53 +01001422 assert_string_equal("zzz", ll->units);
1423 assert_int_equal(10, ll->max);
1424 assert_int_equal(0, ll->min);
1425 assert_string_equal("string", ll->type.name);
1426 assert_non_null(ll->exts);
1427 assert_non_null(ll->iffeatures);
1428 assert_non_null(ll->musts);
1429 assert_string_equal("test", ll->ref);
1430 assert_non_null(ll->when);
1431 assert_null(ll->parent);
1432 assert_null(ll->next);
1433 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_USER | LYS_SET_MAX, ll->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001434 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ll); ll = NULL;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001435
1436 /* full content - now with min-elements */
Michal Vasko63f3d842020-07-08 10:10:14 +02001437 in.current = "ll {min-elements 10; type string;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001438 assert_int_equal(LY_SUCCESS, parse_leaflist(ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001439 assert_non_null(ll);
1440 assert_int_equal(LYS_LEAFLIST, ll->nodetype);
1441 assert_string_equal("ll", ll->name);
1442 assert_string_equal("string", ll->type.name);
1443 assert_int_equal(0, ll->max);
1444 assert_int_equal(10, ll->min);
1445 assert_int_equal(LYS_SET_MIN, ll->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001446 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ll); ll = NULL;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001447
1448 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001449 in.current = " ll {description \"missing type\";} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001450 assert_int_equal(LY_EVALID, parse_leaflist(ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001451 logbuf_assert("Missing mandatory keyword \"type\" as a child of \"leaf-list\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001452 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ll); ll = NULL;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001453
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001454 ctx->parsed_mod->version = 1; /* simulate YANG 1.0 - default statement is not allowed */
Michal Vasko63f3d842020-07-08 10:10:14 +02001455 in.current = " ll {default xx; type string;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001456 assert_int_equal(LY_EVALID, parse_leaflist(ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001457 logbuf_assert("Invalid keyword \"default\" as a child of \"leaf-list\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001458 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ll); ll = NULL;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001459}
1460
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001461static void
1462test_list(void **state)
1463{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001464 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001465 struct lysp_node_list *l = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001466 struct ly_in in = {0};
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001467
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001468 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001469
1470 /* invalid cardinality */
1471#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001472 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001473 assert_int_equal(LY_EVALID, parse_list(ctx, &in, NULL, (struct lysp_node**)&l)); \
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001474 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001475 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001476
1477 TEST_DUP("config", "true", "false");
1478 TEST_DUP("description", "text1", "text2");
1479 TEST_DUP("key", "one", "two");
1480 TEST_DUP("max-elements", "10", "20");
1481 TEST_DUP("min-elements", "10", "20");
1482 TEST_DUP("ordered-by", "user", "system");
1483 TEST_DUP("reference", "1", "2");
1484 TEST_DUP("status", "current", "obsolete");
1485 TEST_DUP("when", "true", "false");
1486#undef TEST_DUP
1487
1488 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001489 in.current = "l {action x;anydata any;anyxml anyxml; choice ch;config false;container c;description test;grouping g;if-feature f; key l; leaf l {type string;}"
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001490 "leaf-list ll {type string;} list li;max-elements 10; min-elements 1;must 'expr';notification not; ordered-by system; reference test;"
1491 "status current;typedef t {type int8;}unique xxx;unique yyy;uses g;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001492 assert_int_equal(LY_SUCCESS, parse_list(ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001493 assert_non_null(l);
1494 assert_int_equal(LYS_LIST, l->nodetype);
1495 assert_string_equal("l", l->name);
1496 assert_string_equal("test", l->dsc);
1497 assert_string_equal("l", l->key);
1498 assert_non_null(l->uniques);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001499 assert_int_equal(2, LY_ARRAY_COUNT(l->uniques));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001500 assert_string_equal("xxx", l->uniques[0].str);
1501 assert_string_equal("yyy", l->uniques[1].str);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001502 assert_int_equal(10, l->max);
1503 assert_int_equal(1, l->min);
1504 assert_non_null(l->exts);
1505 assert_non_null(l->iffeatures);
1506 assert_non_null(l->musts);
1507 assert_string_equal("test", l->ref);
1508 assert_non_null(l->when);
1509 assert_null(l->parent);
1510 assert_null(l->next);
1511 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_MAX | LYS_SET_MIN, l->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001512 ly_set_erase(&ctx->tpdfs_nodes, NULL);
1513 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001514
Radek Krejcif538ce52019-03-05 10:46:14 +01001515 /* invalid content */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001516 ctx->parsed_mod->version = 1; /* simulate YANG 1.0 */
Michal Vasko63f3d842020-07-08 10:10:14 +02001517 in.current = "l {action x;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001518 assert_int_equal(LY_EVALID, parse_list(ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcif538ce52019-03-05 10:46:14 +01001519 logbuf_assert("Invalid keyword \"action\" as a child of \"list\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001520 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)l); l = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001521}
1522
Radek Krejci056d0a82018-12-06 16:57:25 +01001523static void
1524test_choice(void **state)
1525{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001526 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci056d0a82018-12-06 16:57:25 +01001527 struct lysp_node_choice *ch = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001528 struct ly_in in = {0};
Radek Krejci056d0a82018-12-06 16:57:25 +01001529
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001530 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci056d0a82018-12-06 16:57:25 +01001531
1532 /* invalid cardinality */
1533#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001534 in.current = "ch {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001535 assert_int_equal(LY_EVALID, parse_choice(ctx, &in, NULL, (struct lysp_node**)&ch)); \
Radek Krejci056d0a82018-12-06 16:57:25 +01001536 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001537 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ch); ch = NULL;
Radek Krejci056d0a82018-12-06 16:57:25 +01001538
1539 TEST_DUP("config", "true", "false");
1540 TEST_DUP("default", "a", "b");
1541 TEST_DUP("description", "text1", "text2");
1542 TEST_DUP("mandatory", "true", "false");
1543 TEST_DUP("reference", "1", "2");
1544 TEST_DUP("status", "current", "obsolete");
1545 TEST_DUP("when", "true", "false");
1546#undef TEST_DUP
1547
Radek Krejcia9026eb2018-12-12 16:04:47 +01001548 /* full content - without default due to a collision with mandatory */
Michal Vasko63f3d842020-07-08 10:10:14 +02001549 in.current = "ch {anydata any;anyxml anyxml; case c;choice ch;config false;container c;description test;if-feature f;leaf l {type string;}"
Radek Krejci056d0a82018-12-06 16:57:25 +01001550 "leaf-list ll {type string;} list li;mandatory true;reference test;status current;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001551 assert_int_equal(LY_SUCCESS, parse_choice(ctx, &in, NULL, (struct lysp_node**)&ch));
Radek Krejci056d0a82018-12-06 16:57:25 +01001552 assert_non_null(ch);
1553 assert_int_equal(LYS_CHOICE, ch->nodetype);
1554 assert_string_equal("ch", ch->name);
1555 assert_string_equal("test", ch->dsc);
1556 assert_non_null(ch->exts);
1557 assert_non_null(ch->iffeatures);
1558 assert_string_equal("test", ch->ref);
1559 assert_non_null(ch->when);
1560 assert_null(ch->parent);
1561 assert_null(ch->next);
1562 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_MAND_TRUE, ch->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001563 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ch); ch = NULL;
Radek Krejci056d0a82018-12-06 16:57:25 +01001564
Radek Krejcia9026eb2018-12-12 16:04:47 +01001565 /* full content - the default missing from the previous node */
Michal Vasko63f3d842020-07-08 10:10:14 +02001566 in.current = "ch {default c;case c;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001567 assert_int_equal(LY_SUCCESS, parse_choice(ctx, &in, NULL, (struct lysp_node**)&ch));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001568 assert_non_null(ch);
1569 assert_int_equal(LYS_CHOICE, ch->nodetype);
1570 assert_string_equal("ch", ch->name);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001571 assert_string_equal("c", ch->dflt.str);
Radek Krejcia9026eb2018-12-12 16:04:47 +01001572 assert_int_equal(0, ch->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001573 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)ch); ch = NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001574}
1575
1576static void
1577test_case(void **state)
1578{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001579 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001580 struct lysp_node_case *cs = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001581 struct ly_in in = {0};
Radek Krejcia9026eb2018-12-12 16:04:47 +01001582
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001583 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcia9026eb2018-12-12 16:04:47 +01001584
1585 /* invalid cardinality */
1586#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001587 in.current = "cs {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001588 assert_int_equal(LY_EVALID, parse_case(ctx, &in, NULL, (struct lysp_node**)&cs)); \
Radek Krejcia9026eb2018-12-12 16:04:47 +01001589 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001590 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)cs); cs = NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001591
1592 TEST_DUP("description", "text1", "text2");
1593 TEST_DUP("reference", "1", "2");
1594 TEST_DUP("status", "current", "obsolete");
1595 TEST_DUP("when", "true", "false");
1596#undef TEST_DUP
1597
1598 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001599 in.current = "cs {anydata any;anyxml anyxml; choice ch;container c;description test;if-feature f;leaf l {type string;}"
Radek Krejcia9026eb2018-12-12 16:04:47 +01001600 "leaf-list ll {type string;} list li;reference test;status current;uses grp;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001601 assert_int_equal(LY_SUCCESS, parse_case(ctx, &in, NULL, (struct lysp_node**)&cs));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001602 assert_non_null(cs);
1603 assert_int_equal(LYS_CASE, cs->nodetype);
1604 assert_string_equal("cs", cs->name);
1605 assert_string_equal("test", cs->dsc);
1606 assert_non_null(cs->exts);
1607 assert_non_null(cs->iffeatures);
1608 assert_string_equal("test", cs->ref);
1609 assert_non_null(cs->when);
1610 assert_null(cs->parent);
1611 assert_null(cs->next);
1612 assert_int_equal(LYS_STATUS_CURR, cs->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001613 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)cs); cs = NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001614
1615 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001616 in.current = "cs {config true} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001617 assert_int_equal(LY_EVALID, parse_case(ctx, &in, NULL, (struct lysp_node**)&cs));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001618 logbuf_assert("Invalid keyword \"config\" as a child of \"case\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001619 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)cs); cs = NULL;
Radek Krejci056d0a82018-12-06 16:57:25 +01001620}
1621
Radek Krejci9800fb82018-12-13 14:26:23 +01001622static void
Radek Krejcid6b76452019-09-03 17:03:03 +02001623test_any(void **state, enum ly_stmt kw)
Radek Krejci9800fb82018-12-13 14:26:23 +01001624{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001625 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci9800fb82018-12-13 14:26:23 +01001626 struct lysp_node_anydata *any = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001627 struct ly_in in = {0};
Radek Krejci9800fb82018-12-13 14:26:23 +01001628
Radek Krejcid6b76452019-09-03 17:03:03 +02001629 if (kw == LY_STMT_ANYDATA) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001630 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci9800fb82018-12-13 14:26:23 +01001631 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001632 ctx->parsed_mod->version = 1; /* simulate YANG 1.0 */
Radek Krejci9800fb82018-12-13 14:26:23 +01001633 }
1634
1635 /* invalid cardinality */
1636#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001637 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001638 assert_int_equal(LY_EVALID, parse_any(ctx, &in, kw, NULL, (struct lysp_node**)&any)); \
Radek Krejci9800fb82018-12-13 14:26:23 +01001639 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001640 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)any); any = NULL;
Radek Krejci9800fb82018-12-13 14:26:23 +01001641
1642 TEST_DUP("config", "true", "false");
1643 TEST_DUP("description", "text1", "text2");
1644 TEST_DUP("mandatory", "true", "false");
1645 TEST_DUP("reference", "1", "2");
1646 TEST_DUP("status", "current", "obsolete");
1647 TEST_DUP("when", "true", "false");
1648#undef TEST_DUP
1649
1650 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001651 in.current = "any {config true;description test;if-feature f;mandatory true;must 'expr';reference test;status current;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001652 assert_int_equal(LY_SUCCESS, parse_any(ctx, &in, kw, NULL, (struct lysp_node**)&any));
Radek Krejci9800fb82018-12-13 14:26:23 +01001653 assert_non_null(any);
Radek Krejcid6b76452019-09-03 17:03:03 +02001654 assert_int_equal(kw == LY_STMT_ANYDATA ? LYS_ANYDATA : LYS_ANYXML, any->nodetype);
Radek Krejci9800fb82018-12-13 14:26:23 +01001655 assert_string_equal("any", any->name);
1656 assert_string_equal("test", any->dsc);
1657 assert_non_null(any->exts);
1658 assert_non_null(any->iffeatures);
1659 assert_non_null(any->musts);
1660 assert_string_equal("test", any->ref);
1661 assert_non_null(any->when);
1662 assert_null(any->parent);
1663 assert_null(any->next);
1664 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR | LYS_MAND_TRUE, any->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001665 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)any); any = NULL;
Radek Krejci9800fb82018-12-13 14:26:23 +01001666}
1667
1668static void
1669test_anydata(void **state)
1670{
Radek Krejcid6b76452019-09-03 17:03:03 +02001671 return test_any(state, LY_STMT_ANYDATA);
Radek Krejci9800fb82018-12-13 14:26:23 +01001672}
1673
1674static void
1675test_anyxml(void **state)
1676{
Radek Krejcid6b76452019-09-03 17:03:03 +02001677 return test_any(state, LY_STMT_ANYXML);
Radek Krejci9800fb82018-12-13 14:26:23 +01001678}
1679
Radek Krejcie86bf772018-12-14 11:39:53 +01001680static void
1681test_grouping(void **state)
1682{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001683 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcie86bf772018-12-14 11:39:53 +01001684 struct lysp_grp *grp = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001685 struct ly_in in = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01001686
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001687 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcie86bf772018-12-14 11:39:53 +01001688
1689 /* invalid cardinality */
1690#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001691 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001692 assert_int_equal(LY_EVALID, parse_grouping(ctx, &in, NULL, &grp)); \
Radek Krejcie86bf772018-12-14 11:39:53 +01001693 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001694 FREE_ARRAY(ctx->parsed_mod->mod->ctx, grp, lysp_grp_free); grp = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001695
1696 TEST_DUP("description", "text1", "text2");
1697 TEST_DUP("reference", "1", "2");
1698 TEST_DUP("status", "current", "obsolete");
1699#undef TEST_DUP
1700
1701 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001702 in.current = "grp {action x;anydata any;anyxml anyxml; choice ch;container c;description test;grouping g;leaf l {type string;}"
Radek Krejcie86bf772018-12-14 11:39:53 +01001703 "leaf-list ll {type string;} list li;notification not;reference test;status current;typedef t {type int8;}uses g;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001704 assert_int_equal(LY_SUCCESS, parse_grouping(ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001705 assert_non_null(grp);
1706 assert_int_equal(LYS_GROUPING, grp->nodetype);
1707 assert_string_equal("grp", grp->name);
1708 assert_string_equal("test", grp->dsc);
1709 assert_non_null(grp->exts);
1710 assert_string_equal("test", grp->ref);
1711 assert_null(grp->parent);
1712 assert_int_equal( LYS_STATUS_CURR, grp->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001713 ly_set_erase(&ctx->tpdfs_nodes, NULL);
1714 FREE_ARRAY(ctx->parsed_mod->mod->ctx, grp, lysp_grp_free); grp = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001715
1716 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001717 in.current = "grp {config true} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001718 assert_int_equal(LY_EVALID, parse_grouping(ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001719 logbuf_assert("Invalid keyword \"config\" as a child of \"grouping\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001720 FREE_ARRAY(ctx->parsed_mod->mod->ctx, grp, lysp_grp_free); grp = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001721
Michal Vasko63f3d842020-07-08 10:10:14 +02001722 in.current = "grp {must 'expr'} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001723 assert_int_equal(LY_EVALID, parse_grouping(ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001724 logbuf_assert("Invalid keyword \"must\" as a child of \"grouping\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001725 FREE_ARRAY(ctx->parsed_mod->mod->ctx, grp, lysp_grp_free); grp = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001726}
1727
1728static void
Radek Krejcif538ce52019-03-05 10:46:14 +01001729test_action(void **state)
1730{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001731 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcif538ce52019-03-05 10:46:14 +01001732 struct lysp_action *rpcs = NULL;
1733 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001734 struct ly_in in = {0};
Radek Krejcif538ce52019-03-05 10:46:14 +01001735
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001736 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcif538ce52019-03-05 10:46:14 +01001737
1738 /* invalid cardinality */
1739#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001740 in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001741 assert_int_equal(LY_EVALID, parse_action(ctx, &in, NULL, &rpcs)); \
Radek Krejcif538ce52019-03-05 10:46:14 +01001742 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001743 FREE_ARRAY(ctx->parsed_mod->mod->ctx, rpcs, lysp_action_free); rpcs = NULL;
Radek Krejcif538ce52019-03-05 10:46:14 +01001744
1745 TEST_DUP("description", "text1", "text2");
Michal Vaskob83af8a2020-01-06 09:49:22 +01001746 TEST_DUP("input", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a");
1747 TEST_DUP("output", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a");
Radek Krejcif538ce52019-03-05 10:46:14 +01001748 TEST_DUP("reference", "1", "2");
1749 TEST_DUP("status", "current", "obsolete");
1750#undef TEST_DUP
1751
1752 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001753 in.current = "top;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001754 assert_int_equal(LY_SUCCESS, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Michal Vasko63f3d842020-07-08 10:10:14 +02001755 in.current = "func {description test;grouping grp;if-feature f;reference test;status current;typedef mytype {type int8;} m:ext;"
Radek Krejcif538ce52019-03-05 10:46:14 +01001756 "input {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}"
1757 " list li; must 1; typedef mytypei {type int8;} uses grp; m:ext;}"
1758 "output {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}"
1759 " list li; must 1; typedef mytypeo {type int8;} uses grp; m:ext;}} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001760 assert_int_equal(LY_SUCCESS, parse_action(ctx, &in, (struct lysp_node*)c, &rpcs));
Radek Krejcif538ce52019-03-05 10:46:14 +01001761 assert_non_null(rpcs);
1762 assert_int_equal(LYS_ACTION, rpcs->nodetype);
1763 assert_string_equal("func", rpcs->name);
1764 assert_string_equal("test", rpcs->dsc);
1765 assert_non_null(rpcs->exts);
1766 assert_non_null(rpcs->iffeatures);
1767 assert_string_equal("test", rpcs->ref);
1768 assert_non_null(rpcs->groupings);
1769 assert_non_null(rpcs->typedefs);
1770 assert_int_equal(LYS_STATUS_CURR, rpcs->flags);
1771 /* input */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001772 assert_int_equal(rpcs->input.nodetype, LYS_INPUT);
Radek Krejcif538ce52019-03-05 10:46:14 +01001773 assert_non_null(rpcs->input.groupings);
1774 assert_non_null(rpcs->input.exts);
1775 assert_non_null(rpcs->input.musts);
1776 assert_non_null(rpcs->input.typedefs);
1777 assert_non_null(rpcs->input.data);
1778 /* output */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001779 assert_int_equal(rpcs->output.nodetype, LYS_OUTPUT);
Radek Krejcif538ce52019-03-05 10:46:14 +01001780 assert_non_null(rpcs->output.groupings);
1781 assert_non_null(rpcs->output.exts);
1782 assert_non_null(rpcs->output.musts);
1783 assert_non_null(rpcs->output.typedefs);
1784 assert_non_null(rpcs->output.data);
1785
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001786 ly_set_erase(&ctx->tpdfs_nodes, NULL);
1787 FREE_ARRAY(ctx->parsed_mod->mod->ctx, rpcs, lysp_action_free); rpcs = NULL;
Radek Krejcif538ce52019-03-05 10:46:14 +01001788
1789 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001790 in.current = "func {config true} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001791 assert_int_equal(LY_EVALID, parse_action(ctx, &in, NULL, &rpcs));
Radek Krejcif538ce52019-03-05 10:46:14 +01001792 logbuf_assert("Invalid keyword \"config\" as a child of \"rpc\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001793 FREE_ARRAY(ctx->parsed_mod->mod->ctx, rpcs, lysp_action_free); rpcs = NULL;
Radek Krejcif538ce52019-03-05 10:46:14 +01001794
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001795 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c);
Radek Krejcif538ce52019-03-05 10:46:14 +01001796}
1797
1798static void
Radek Krejcifc11bd72019-04-11 16:00:05 +02001799test_notification(void **state)
1800{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001801 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001802 struct lysp_notif *notifs = NULL;
1803 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001804 struct ly_in in = {0};
Radek Krejcifc11bd72019-04-11 16:00:05 +02001805
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001806 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcifc11bd72019-04-11 16:00:05 +02001807
1808 /* invalid cardinality */
1809#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001810 in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001811 assert_int_equal(LY_EVALID, parse_notif(ctx, &in, NULL, &notifs)); \
Radek Krejcifc11bd72019-04-11 16:00:05 +02001812 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001813 FREE_ARRAY(ctx->parsed_mod->mod->ctx, notifs, lysp_notif_free); notifs = NULL;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001814
1815 TEST_DUP("description", "text1", "text2");
1816 TEST_DUP("reference", "1", "2");
1817 TEST_DUP("status", "current", "obsolete");
1818#undef TEST_DUP
1819
1820 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001821 in.current = "top;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001822 assert_int_equal(LY_SUCCESS, parse_container(ctx, &in, NULL, (struct lysp_node**)&c));
Michal Vasko63f3d842020-07-08 10:10:14 +02001823 in.current = "ntf {anydata a1; anyxml a2; choice ch; container c; description test; grouping grp; if-feature f; leaf l {type int8;}"
Radek Krejcifc11bd72019-04-11 16:00:05 +02001824 "leaf-list ll {type int8;} list li; must 1; reference test; status current; typedef mytype {type int8;} uses grp; m:ext;}";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001825 assert_int_equal(LY_SUCCESS, parse_notif(ctx, &in, (struct lysp_node*)c, &notifs));
Radek Krejcifc11bd72019-04-11 16:00:05 +02001826 assert_non_null(notifs);
1827 assert_int_equal(LYS_NOTIF, notifs->nodetype);
1828 assert_string_equal("ntf", notifs->name);
1829 assert_string_equal("test", notifs->dsc);
1830 assert_non_null(notifs->exts);
1831 assert_non_null(notifs->iffeatures);
1832 assert_string_equal("test", notifs->ref);
1833 assert_non_null(notifs->groupings);
1834 assert_non_null(notifs->typedefs);
1835 assert_non_null(notifs->musts);
1836 assert_non_null(notifs->data);
1837 assert_int_equal(LYS_STATUS_CURR, notifs->flags);
1838
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001839 ly_set_erase(&ctx->tpdfs_nodes, NULL);
1840 FREE_ARRAY(ctx->parsed_mod->mod->ctx, notifs, lysp_notif_free); notifs = NULL;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001841
1842 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001843 in.current = "ntf {config true} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001844 assert_int_equal(LY_EVALID, parse_notif(ctx, &in, NULL, &notifs));
Radek Krejcifc11bd72019-04-11 16:00:05 +02001845 logbuf_assert("Invalid keyword \"config\" as a child of \"notification\". Line number 1.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001846 FREE_ARRAY(ctx->parsed_mod->mod->ctx, notifs, lysp_notif_free); notifs = NULL;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001847
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001848 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)c);
Radek Krejcifc11bd72019-04-11 16:00:05 +02001849}
1850
1851static void
Radek Krejcie86bf772018-12-14 11:39:53 +01001852test_uses(void **state)
1853{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001854 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcie86bf772018-12-14 11:39:53 +01001855 struct lysp_node_uses *u = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001856 struct ly_in in = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01001857
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001858 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcie86bf772018-12-14 11:39:53 +01001859
1860 /* invalid cardinality */
1861#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001862 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001863 assert_int_equal(LY_EVALID, parse_uses(ctx, &in, NULL, (struct lysp_node**)&u)); \
Radek Krejcie86bf772018-12-14 11:39:53 +01001864 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001865 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)u); u = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001866
1867 TEST_DUP("description", "text1", "text2");
1868 TEST_DUP("reference", "1", "2");
1869 TEST_DUP("status", "current", "obsolete");
1870 TEST_DUP("when", "true", "false");
1871#undef TEST_DUP
1872
1873 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001874 in.current = "grpref {augment some/node;description test;if-feature f;reference test;refine some/other/node;status current;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001875 assert_int_equal(LY_SUCCESS, parse_uses(ctx, &in, NULL, (struct lysp_node**)&u));
Radek Krejcie86bf772018-12-14 11:39:53 +01001876 assert_non_null(u);
1877 assert_int_equal(LYS_USES, u->nodetype);
1878 assert_string_equal("grpref", u->name);
1879 assert_string_equal("test", u->dsc);
1880 assert_non_null(u->exts);
1881 assert_non_null(u->iffeatures);
1882 assert_string_equal("test", u->ref);
1883 assert_non_null(u->augments);
1884 assert_non_null(u->refines);
1885 assert_non_null(u->when);
1886 assert_null(u->parent);
1887 assert_null(u->next);
1888 assert_int_equal(LYS_STATUS_CURR, u->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001889 lysp_node_free(ctx->parsed_mod->mod->ctx, (struct lysp_node*)u); u = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01001890}
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001891
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001892static void
1893test_augment(void **state)
1894{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001895 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001896 struct lysp_augment *a = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001897 struct ly_in in = {0};
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001898
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001899 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001900
1901 /* invalid cardinality */
1902#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001903 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001904 assert_int_equal(LY_EVALID, parse_augment(ctx, &in, NULL, &a)); \
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001905 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001906 FREE_ARRAY(ctx->parsed_mod->mod->ctx, a, lysp_augment_free); a = NULL;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001907
1908 TEST_DUP("description", "text1", "text2");
1909 TEST_DUP("reference", "1", "2");
1910 TEST_DUP("status", "current", "obsolete");
1911 TEST_DUP("when", "true", "false");
1912#undef TEST_DUP
1913
1914 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001915 in.current = "/target/nodeid {action x; anydata any;anyxml anyxml; case cs; choice ch;container c;description test;if-feature f;leaf l {type string;}"
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001916 "leaf-list ll {type string;} list li;notification not;reference test;status current;uses g;when true;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001917 assert_int_equal(LY_SUCCESS, parse_augment(ctx, &in, NULL, &a));
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001918 assert_non_null(a);
1919 assert_int_equal(LYS_AUGMENT, a->nodetype);
1920 assert_string_equal("/target/nodeid", a->nodeid);
1921 assert_string_equal("test", a->dsc);
1922 assert_non_null(a->exts);
1923 assert_non_null(a->iffeatures);
1924 assert_string_equal("test", a->ref);
1925 assert_non_null(a->when);
1926 assert_null(a->parent);
1927 assert_int_equal(LYS_STATUS_CURR, a->flags);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001928 FREE_ARRAY(ctx->parsed_mod->mod->ctx, a, lysp_augment_free); a = NULL;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01001929}
1930
Radek Krejcif09e4e82019-06-14 15:08:11 +02001931static void
1932test_when(void **state)
1933{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001934 struct lys_yang_parser_ctx *ctx = *state;
Radek Krejcif09e4e82019-06-14 15:08:11 +02001935 struct lysp_when *w = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001936 struct ly_in in = {0};
Radek Krejcif09e4e82019-06-14 15:08:11 +02001937
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001938 ctx->parsed_mod->version = 2; /* simulate YANG 1.1 */
Radek Krejcif09e4e82019-06-14 15:08:11 +02001939
1940 /* invalid cardinality */
1941#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001942 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001943 assert_int_equal(LY_EVALID, parse_when(ctx, &in, &w)); \
Radek Krejcif09e4e82019-06-14 15:08:11 +02001944 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001945 FREE_MEMBER(ctx->parsed_mod->mod->ctx, w, lysp_when_free); w = NULL;
Radek Krejcif09e4e82019-06-14 15:08:11 +02001946
1947 TEST_DUP("description", "text1", "text2");
1948 TEST_DUP("reference", "1", "2");
1949#undef TEST_DUP
1950
1951 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001952 in.current = "expression {description test;reference test;m:ext;} ...";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001953 assert_int_equal(LY_SUCCESS, parse_when(ctx, &in, &w));
Radek Krejcif09e4e82019-06-14 15:08:11 +02001954 assert_non_null(w);
1955 assert_string_equal("expression", w->cond);
1956 assert_string_equal("test", w->dsc);
1957 assert_string_equal("test", w->ref);
1958 assert_non_null(w->exts);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001959 FREE_MEMBER(ctx->parsed_mod->mod->ctx, w, lysp_when_free); w = NULL;
Radek Krejcif09e4e82019-06-14 15:08:11 +02001960
1961 /* empty condition */
Michal Vasko63f3d842020-07-08 10:10:14 +02001962 in.current = "\"\";";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001963 assert_int_equal(LY_SUCCESS, parse_when(ctx, &in, &w));
Radek Krejcif09e4e82019-06-14 15:08:11 +02001964 logbuf_assert("Empty argument of when statement does not make sense.");
1965 assert_non_null(w);
1966 assert_string_equal("", w->cond);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001967 FREE_MEMBER(ctx->parsed_mod->mod->ctx, w, lysp_when_free); w = NULL;
Radek Krejcif09e4e82019-06-14 15:08:11 +02001968}
1969
David Sedlákd6ce6d72019-07-16 17:30:18 +02001970static void
1971test_value(void **state)
1972{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001973 struct lys_yang_parser_ctx *ctx = *state;
Michal Vasko63f3d842020-07-08 10:10:14 +02001974 struct ly_in in = {0};
David Sedlákd6ce6d72019-07-16 17:30:18 +02001975 int64_t val = 0;
1976 uint16_t flags = 0;
1977
Michal Vasko63f3d842020-07-08 10:10:14 +02001978 in.current = "-0;";
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001979 assert_int_equal(parse_type_enum_value_pos(ctx, &in, LY_STMT_VALUE, &val, &flags, NULL), LY_SUCCESS);
David Sedlákd6ce6d72019-07-16 17:30:18 +02001980 assert_int_equal(val, 0);
1981
Michal Vasko63f3d842020-07-08 10:10:14 +02001982 in.current = "-0;";
David Sedlákd6ce6d72019-07-16 17:30:18 +02001983 flags = 0;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001984 assert_int_equal(parse_type_enum_value_pos(ctx, &in, LY_STMT_POSITION, &val, &flags, NULL), LY_EVALID);
David Sedlákd6ce6d72019-07-16 17:30:18 +02001985 logbuf_assert("Invalid value \"-0\" of \"position\". Line number 1.");
David Sedlákd6ce6d72019-07-16 17:30:18 +02001986}
1987
Radek Krejci80dd33e2018-09-26 15:57:18 +02001988int main(void)
1989{
1990 const struct CMUnitTest tests[] = {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001991 cmocka_unit_test_setup_teardown(test_helpers, setup_f, teardown_f),
1992 cmocka_unit_test_setup_teardown(test_comments, setup_f, teardown_f),
1993 cmocka_unit_test_setup_teardown(test_arg, setup_f, teardown_f),
1994 cmocka_unit_test_setup_teardown(test_stmts, setup_f, teardown_f),
1995 cmocka_unit_test_setup_teardown(test_minmax, setup_f, teardown_f),
1996 cmocka_unit_test_setup_teardown(test_module, setup_f, teardown_f),
1997 cmocka_unit_test_setup_teardown(test_deviation, setup_f, teardown_f),
1998 cmocka_unit_test_setup_teardown(test_deviate, setup_f, teardown_f),
1999 cmocka_unit_test_setup_teardown(test_container, setup_f, teardown_f),
2000 cmocka_unit_test_setup_teardown(test_leaf, setup_f, teardown_f),
2001 cmocka_unit_test_setup_teardown(test_leaflist, setup_f, teardown_f),
2002 cmocka_unit_test_setup_teardown(test_list, setup_f, teardown_f),
2003 cmocka_unit_test_setup_teardown(test_choice, setup_f, teardown_f),
2004 cmocka_unit_test_setup_teardown(test_case, setup_f, teardown_f),
2005 cmocka_unit_test_setup_teardown(test_anydata, setup_f, teardown_f),
2006 cmocka_unit_test_setup_teardown(test_anyxml, setup_f, teardown_f),
2007 cmocka_unit_test_setup_teardown(test_action, setup_f, teardown_f),
2008 cmocka_unit_test_setup_teardown(test_notification, setup_f, teardown_f),
2009 cmocka_unit_test_setup_teardown(test_grouping, setup_f, teardown_f),
2010 cmocka_unit_test_setup_teardown(test_uses, setup_f, teardown_f),
2011 cmocka_unit_test_setup_teardown(test_augment, setup_f, teardown_f),
2012 cmocka_unit_test_setup_teardown(test_when, setup_f, teardown_f),
2013 cmocka_unit_test_setup_teardown(test_value, setup_f, teardown_f),
Radek Krejci80dd33e2018-09-26 15:57:18 +02002014 };
2015
2016 return cmocka_run_group_tests(tests, NULL, NULL);
2017}