blob: 02fa0638be2b07ab05225bbdffa26635cc804683 [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"
24#include "parser_internal.h"
25#include "tree_schema.h"
26#include "tree_schema_internal.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020027
28/* originally static functions from tree_schema_free.c and parser_yang.c */
29void lysp_ext_instance_free(struct ly_ctx *ctx, struct lysp_ext_instance *ext);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020030void lysp_deviation_free(struct ly_ctx *ctx, struct lysp_deviation *dev);
31void lysp_grp_free(struct ly_ctx *ctx, struct lysp_grp *grp);
32void lysp_action_free(struct ly_ctx *ctx, struct lysp_action *action);
33void lysp_notif_free(struct ly_ctx *ctx, struct lysp_notif *notif);
34void lysp_augment_free(struct ly_ctx *ctx, struct lysp_augment *augment);
35void lysp_deviate_free(struct ly_ctx *ctx, struct lysp_deviate *d);
36void lysp_node_free(struct ly_ctx *ctx, struct lysp_node *node);
Radek Krejcif09e4e82019-06-14 15:08:11 +020037void lysp_when_free(struct ly_ctx *ctx, struct lysp_when *when);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020038
Michal Vasko63f3d842020-07-08 10:10:14 +020039LY_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);
40LY_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 +020041 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 +020042LY_ERR get_keyword(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum ly_stmt *kw, char **word_p, size_t *word_len);
43LY_ERR get_argument(struct lys_yang_parser_ctx *ctx, struct ly_in *in, enum yang_arg arg,
Radek Krejci2d7a47b2019-05-16 13:34:10 +020044 uint16_t *flags, char **word_p, char **word_b, size_t *word_len);
Radek Krejci1deb5be2020-08-26 16:43:36 +020045LY_ERR skip_comment(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint8_t comment);
Radek Krejci2d7a47b2019-05-16 13:34:10 +020046
Michal Vasko63f3d842020-07-08 10:10:14 +020047LY_ERR parse_action(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_action **actions);
48LY_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);
49LY_ERR parse_augment(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_augment **augments);
50LY_ERR parse_case(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
51LY_ERR parse_container(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
52LY_ERR parse_deviate(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_deviate **deviates);
53LY_ERR parse_deviation(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_deviation **deviations);
54LY_ERR parse_grouping(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_grp **groupings);
55LY_ERR parse_choice(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
56LY_ERR parse_leaf(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
57LY_ERR parse_leaflist(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
58LY_ERR parse_list(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
59LY_ERR parse_maxelements(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts);
60LY_ERR parse_minelements(struct lys_yang_parser_ctx *ctx, struct ly_in *in, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts);
61LY_ERR parse_module(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_module *mod);
62LY_ERR parse_notif(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_notif **notifs);
63LY_ERR parse_submodule(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_submodule *submod);
64LY_ERR parse_uses(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_node *parent, struct lysp_node **siblings);
65LY_ERR parse_when(struct lys_yang_parser_ctx *ctx, struct ly_in *in, struct lysp_when **when_p);
66LY_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 +020067
68#define BUFSIZE 1024
69char logbuf[BUFSIZE] = {0};
Radek Krejci9ed7a192018-10-31 16:23:51 +010070int store = -1; /* negative for infinite logging, positive for limited logging */
Radek Krejci80dd33e2018-09-26 15:57:18 +020071
72/* set to 0 to printing error messages to stderr instead of checking them in code */
Radek Krejci70853c52018-10-15 14:46:16 +020073#define ENABLE_LOGGER_CHECKING 1
Radek Krejci80dd33e2018-09-26 15:57:18 +020074
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020075#if ENABLE_LOGGER_CHECKING
Radek Krejci80dd33e2018-09-26 15:57:18 +020076static void
77logger(LY_LOG_LEVEL level, const char *msg, const char *path)
78{
79 (void) level; /* unused */
Radek Krejci9ed7a192018-10-31 16:23:51 +010080 if (store) {
81 if (path && path[0]) {
82 snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
83 } else {
84 strncpy(logbuf, msg, BUFSIZE - 1);
85 }
86 if (store > 0) {
87 --store;
88 }
Radek Krejci80dd33e2018-09-26 15:57:18 +020089 }
90}
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020091#endif
Radek Krejci80dd33e2018-09-26 15:57:18 +020092
93static int
94logger_setup(void **state)
95{
96 (void) state; /* unused */
97#if ENABLE_LOGGER_CHECKING
98 ly_set_log_clb(logger, 1);
99#endif
100 return 0;
101}
102
Radek Krejcib1a5dcc2018-11-26 14:50:05 +0100103static int
104logger_teardown(void **state)
105{
106 (void) state; /* unused */
107#if ENABLE_LOGGER_CHECKING
108 if (*state) {
109 fprintf(stderr, "%s\n", logbuf);
110 }
111#endif
112 return 0;
113}
114
Radek Krejci80dd33e2018-09-26 15:57:18 +0200115void
116logbuf_clean(void)
117{
118 logbuf[0] = '\0';
119}
120
121#if ENABLE_LOGGER_CHECKING
122# define logbuf_assert(str) assert_string_equal(logbuf, str)
123#else
124# define logbuf_assert(str)
125#endif
126
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200127#define TEST_DUP_GENERIC(PREFIX, MEMBER, VALUE1, VALUE2, FUNC, RESULT, LINE, CLEANUP) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200128 in.current = PREFIX MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
129 assert_int_equal(LY_EVALID, FUNC(&ctx, &in, RESULT)); \
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200130 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number "LINE"."); \
131 CLEANUP
132
Radek Krejci44ceedc2018-10-02 15:54:31 +0200133static void
134test_helpers(void **state)
135{
136 (void) state; /* unused */
137
Michal Vasko63f3d842020-07-08 10:10:14 +0200138 struct ly_in in = {0};
Radek Krejci404251e2018-10-09 12:06:44 +0200139 char *buf, *p;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200140 size_t len, size;
Michal Vaskob36053d2020-03-26 15:49:30 +0100141 struct lys_yang_parser_ctx ctx;
142 ctx.format = LYS_IN_YANG;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200143 ctx.ctx = NULL;
Radek Krejci99435242019-09-05 16:19:15 +0200144 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200145 ctx.line = 1;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200146 uint8_t prefix = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200147
148 /* storing into buffer */
Michal Vasko63f3d842020-07-08 10:10:14 +0200149 in.current = "abcd";
Radek Krejci44ceedc2018-10-02 15:54:31 +0200150 buf = NULL;
151 size = len = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200152 assert_int_equal(LY_SUCCESS, buf_add_char(NULL, &in, 2, &buf, &size, &len));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200153 assert_int_not_equal(0, size);
154 assert_int_equal(2, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200155 assert_string_equal("cd", in.current);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200156 assert_false(strncmp("ab", buf, 2));
157 free(buf);
Radek Krejci404251e2018-10-09 12:06:44 +0200158 buf = NULL;
159
160 /* invalid first characters */
161 len = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200162 in.current = "2invalid";
163 assert_int_equal(LY_EVALID, buf_store_char(&ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
164 in.current = ".invalid";
165 assert_int_equal(LY_EVALID, buf_store_char(&ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
166 in.current = "-invalid";
167 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 +0200168 /* invalid following characters */
169 len = 3; /* number of characters read before the str content */
Michal Vasko63f3d842020-07-08 10:10:14 +0200170 in.current = "!";
171 assert_int_equal(LY_EVALID, buf_store_char(&ctx, &in, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix));
172 in.current = ":";
173 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 +0200174 /* valid colon for prefixed identifiers */
175 len = size = 0;
176 p = NULL;
David Sedlák40bb13b2019-07-10 14:34:18 +0200177 prefix = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200178 in.current = "x:id";
179 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 +0200180 assert_int_equal(1, len);
181 assert_null(buf);
Michal Vasko63f3d842020-07-08 10:10:14 +0200182 assert_string_equal(":id", in.current);
Radek Krejci404251e2018-10-09 12:06:44 +0200183 assert_int_equal('x', p[len - 1]);
Michal Vasko63f3d842020-07-08 10:10:14 +0200184 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 +0200185 assert_int_equal(2, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200186 assert_string_equal("id", in.current);
Radek Krejci404251e2018-10-09 12:06:44 +0200187 assert_int_equal(':', p[len - 1]);
188 free(buf);
David Sedlák40bb13b2019-07-10 14:34:18 +0200189 prefix = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200190
191 /* checking identifiers */
Michal Vaskob36053d2020-03-26 15:49:30 +0100192 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, ':', 0, NULL));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200193 logbuf_assert("Invalid identifier character ':' (0x003a). Line number 1.");
Michal Vaskob36053d2020-03-26 15:49:30 +0100194 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, '#', 1, NULL));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200195 logbuf_assert("Invalid identifier first character '#' (0x0023). Line number 1.");
Radek Krejci44ceedc2018-10-02 15:54:31 +0200196
Michal Vaskob36053d2020-03-26 15:49:30 +0100197 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, 'a', 1, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200198 assert_int_equal(0, prefix);
Michal Vaskob36053d2020-03-26 15:49:30 +0100199 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, ':', 0, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200200 assert_int_equal(1, prefix);
Michal Vaskob36053d2020-03-26 15:49:30 +0100201 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, ':', 0, &prefix));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200202 assert_int_equal(1, prefix);
Michal Vaskob36053d2020-03-26 15:49:30 +0100203 assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, 'b', 0, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200204 assert_int_equal(2, prefix);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200205 /* second colon is invalid */
Michal Vaskob36053d2020-03-26 15:49:30 +0100206 assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lys_parser_ctx *)&ctx, ':', 0, &prefix));
Radek Krejci1deb5be2020-08-26 16:43:36 +0200207 logbuf_assert("Invalid identifier character ':' (0x003a). Line number 1.");
Radek Krejci44ceedc2018-10-02 15:54:31 +0200208}
Radek Krejci80dd33e2018-09-26 15:57:18 +0200209
210static void
211test_comments(void **state)
212{
213 (void) state; /* unused */
214
Michal Vasko63f3d842020-07-08 10:10:14 +0200215 struct ly_in in = {0};
Michal Vaskob36053d2020-03-26 15:49:30 +0100216 struct lys_yang_parser_ctx ctx;
Radek Krejciefd22f62018-09-27 11:47:58 +0200217 char *word, *buf;
218 size_t len;
Radek Krejci80dd33e2018-09-26 15:57:18 +0200219
Michal Vaskob36053d2020-03-26 15:49:30 +0100220 ctx.format = LYS_IN_YANG;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200221 ctx.ctx = NULL;
Radek Krejci99435242019-09-05 16:19:15 +0200222 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200223 ctx.line = 1;
224
Michal Vasko63f3d842020-07-08 10:10:14 +0200225 in.current = " // this is a text of / one * line */ comment\nargument;";
226 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200227 assert_string_equal("argument;", word);
Radek Krejciefd22f62018-09-27 11:47:58 +0200228 assert_null(buf);
229 assert_int_equal(8, len);
Radek Krejci80dd33e2018-09-26 15:57:18 +0200230
Michal Vasko63f3d842020-07-08 10:10:14 +0200231 in.current = "/* this is a \n * text // of / block * comment */\"arg\" + \"ume\" \n + \n \"nt\";";
232 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200233 assert_string_equal("argument", word);
234 assert_ptr_equal(buf, word);
235 assert_int_equal(8, len);
236 free(word);
Radek Krejci80dd33e2018-09-26 15:57:18 +0200237
Michal Vasko63f3d842020-07-08 10:10:14 +0200238 in.current = " this is one line comment on last line";
239 assert_int_equal(LY_SUCCESS, skip_comment(&ctx, &in, 1));
240 assert_true(in.current[0] == '\0');
Radek Krejci80dd33e2018-09-26 15:57:18 +0200241
Michal Vasko63f3d842020-07-08 10:10:14 +0200242 in.current = " this is a not terminated comment x";
243 assert_int_equal(LY_EVALID, skip_comment(&ctx, &in, 2));
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200244 logbuf_assert("Unexpected end-of-input, non-terminated comment. Line number 5.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200245 assert_true(in.current[0] == '\0');
Radek Krejci80dd33e2018-09-26 15:57:18 +0200246}
247
Radek Krejciefd22f62018-09-27 11:47:58 +0200248static void
249test_arg(void **state)
250{
251 (void) state; /* unused */
252
Michal Vaskob36053d2020-03-26 15:49:30 +0100253 struct lys_yang_parser_ctx ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +0200254 struct ly_in in = {0};
Radek Krejciefd22f62018-09-27 11:47:58 +0200255 char *word, *buf;
256 size_t len;
257
Michal Vaskob36053d2020-03-26 15:49:30 +0100258 ctx.format = LYS_IN_YANG;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200259 ctx.ctx = NULL;
Radek Krejci99435242019-09-05 16:19:15 +0200260 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200261 ctx.line = 1;
262
Radek Krejciefd22f62018-09-27 11:47:58 +0200263 /* missing argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200264 in.current = ";";
265 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_MAYBE_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200266 assert_null(word);
267
Michal Vasko63f3d842020-07-08 10:10:14 +0200268 in.current = "{";
269 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200270 logbuf_assert("Invalid character sequence \"{\", expected an argument. Line number 1.");
271
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200272 /* invalid escape sequence */
Michal Vasko63f3d842020-07-08 10:10:14 +0200273 in.current = "\"\\s\"";
274 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("Double-quoted string unknown special character \'\\s\'. Line number 1.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200276 in.current = "\'\\s\'"; /* valid, since it is not an escape sequence in single quoted string */
277 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200278 assert_int_equal(2, len);
279 assert_string_equal("\\s\'", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200280 assert_int_equal('\0', in.current[0]); /* input has been eaten */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200281
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200282 /* invalid character after the argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200283 in.current = "hello\"";
284 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200285 logbuf_assert("Invalid character sequence \"\"\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
Michal Vasko63f3d842020-07-08 10:10:14 +0200286 in.current = "hello}";
287 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200288 logbuf_assert("Invalid character sequence \"}\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
289
David Sedlák40bb13b2019-07-10 14:34:18 +0200290 /* invalid identifier-ref-arg-str */
Michal Vasko63f3d842020-07-08 10:10:14 +0200291 in.current = "pre:pre:value";
292 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 +0200293
Michal Vasko63f3d842020-07-08 10:10:14 +0200294 in.current = "\"\";"; /* empty identifier is not allowed */
295 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_IDENTIF_ARG, NULL, &word, &buf, &len));
Radek Krejci4e199f52019-05-28 09:09:28 +0200296 logbuf_assert("Statement argument is required. Line number 1.");
297 logbuf_clean();
Michal Vasko63f3d842020-07-08 10:10:14 +0200298 in.current = "\"\";"; /* empty reference identifier is not allowed */
299 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &len));
Radek Krejci4e199f52019-05-28 09:09:28 +0200300 logbuf_assert("Statement argument is required. Line number 1.");
301
Michal Vasko63f3d842020-07-08 10:10:14 +0200302 in.current = "hello/x\t"; /* slash is not an invalid character */
303 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200304 assert_int_equal(7, len);
305 assert_string_equal("hello/x\t", word);
306
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200307 assert_null(buf);
Radek Krejciefd22f62018-09-27 11:47:58 +0200308
309 /* different quoting */
Michal Vasko63f3d842020-07-08 10:10:14 +0200310 in.current = "hello ";
311 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200312 assert_null(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200313 assert_int_equal(5, len);
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200314 assert_string_equal("hello ", word);
Radek Krejciefd22f62018-09-27 11:47:58 +0200315
Michal Vasko63f3d842020-07-08 10:10:14 +0200316 in.current = "hello/*comment*/\n";
317 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200318 assert_null(buf);
319 assert_int_equal(5, len);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200320 assert_false(strncmp("hello", word, len));
321
322
Michal Vasko63f3d842020-07-08 10:10:14 +0200323 in.current = "\"hello\\n\\t\\\"\\\\\";";
324 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
fredgand49fe112019-10-21 20:51:50 +0800325 assert_non_null(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200326 assert_int_equal(9, len);
fredgand49fe112019-10-21 20:51:50 +0800327 assert_string_equal("hello\n\t\"\\", word);
328 free(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200329
330 ctx.indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200331 in.current = "\"hello \t\n\t\t world!\"";
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200332 /* - space and tabs before newline are stripped out
333 * - space and tabs after newline (indentation) are stripped out
334 */
Michal Vasko63f3d842020-07-08 10:10:14 +0200335 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200336 assert_non_null(buf);
337 assert_ptr_equal(word, buf);
338 assert_int_equal(14, len);
339 assert_string_equal("hello\n world!", word);
340 free(buf);
Radek Krejciff13cd12019-10-25 15:34:24 +0200341 /* In contrast to previous, the backslash-escaped tabs are expanded after trimming, so they are preserved */
342 ctx.indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200343 in.current = "\"hello \\t\n\t\\t world!\"";
344 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200345 assert_non_null(buf);
346 assert_ptr_equal(word, buf);
347 assert_int_equal(16, len);
348 assert_string_equal("hello \t\n\t world!", word);
349 free(buf);
350 /* Do not handle whitespaces after backslash-escaped newline as indentation */
351 ctx.indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200352 in.current = "\"hello\\n\t\t world!\"";
353 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200354 assert_non_null(buf);
355 assert_ptr_equal(word, buf);
356 assert_int_equal(15, len);
357 assert_string_equal("hello\n\t\t world!", word);
358 free(buf);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200359
360 ctx.indent = 14;
Michal Vasko63f3d842020-07-08 10:10:14 +0200361 in.current = "\"hello\n \tworld!\"";
362 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200363 assert_non_null(buf);
364 assert_ptr_equal(word, buf);
365 assert_int_equal(12, len);
366 assert_string_equal("hello\nworld!", word);
367 free(buf);
Radek Krejciefd22f62018-09-27 11:47:58 +0200368
Michal Vasko63f3d842020-07-08 10:10:14 +0200369 in.current = "\'hello\'";
370 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200371 assert_null(buf);
372 assert_int_equal(5, len);
373 assert_false(strncmp("hello", word, 5));
374
Michal Vasko63f3d842020-07-08 10:10:14 +0200375 in.current = "\"hel\" +\t\n\"lo\"";
376 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200377 assert_ptr_equal(word, buf);
378 assert_int_equal(5, len);
379 assert_string_equal("hello", word);
380 free(buf);
Michal Vasko63f3d842020-07-08 10:10:14 +0200381 in.current = "\"hel\" +\t\nlo"; /* unquoted the second part */
382 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200383 logbuf_assert("Both string parts divided by '+' must be quoted. Line number 6.");
Radek Krejciefd22f62018-09-27 11:47:58 +0200384
Michal Vasko63f3d842020-07-08 10:10:14 +0200385 in.current = "\'he\'\t\n+ \"llo\"";
386 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200387 assert_ptr_equal(word, buf);
388 assert_int_equal(5, len);
389 assert_string_equal("hello", word);
390 free(buf);
391
Michal Vasko63f3d842020-07-08 10:10:14 +0200392 in.current = " \t\n\"he\"+\'llo\'";
393 assert_int_equal(LY_SUCCESS, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciefd22f62018-09-27 11:47:58 +0200394 assert_ptr_equal(word, buf);
395 assert_int_equal(5, len);
396 assert_string_equal("hello", word);
397 free(buf);
398
Radek Krejci44ceedc2018-10-02 15:54:31 +0200399 /* missing argument */
Michal Vasko63f3d842020-07-08 10:10:14 +0200400 in.current = ";";
401 assert_int_equal(LY_EVALID, get_argument(&ctx, &in, Y_STR_ARG, NULL, &word, &buf, &len));
Radek Krejciff13cd12019-10-25 15:34:24 +0200402 logbuf_assert("Invalid character sequence \";\", expected an argument. Line number 8.");
Radek Krejcidcc7b322018-10-11 14:24:02 +0200403}
404
405static void
406test_stmts(void **state)
407{
408 (void) state; /* unused */
409
Michal Vaskob36053d2020-03-26 15:49:30 +0100410 struct lys_yang_parser_ctx ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +0200411 struct ly_in in = {0};
412 const char *p;
Radek Krejcid6b76452019-09-03 17:03:03 +0200413 enum ly_stmt kw;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200414 char *word;
415 size_t len;
416
Michal Vaskob36053d2020-03-26 15:49:30 +0100417 ctx.format = LYS_IN_YANG;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200418 ctx.ctx = NULL;
Radek Krejci99435242019-09-05 16:19:15 +0200419 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200420 ctx.line = 1;
421
Michal Vasko63f3d842020-07-08 10:10:14 +0200422 in.current = "\n// comment\n\tinput\t{";
423 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200424 assert_int_equal(LY_STMT_INPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200425 assert_int_equal(5, len);
426 assert_string_equal("input\t{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200427 assert_string_equal("\t{", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200428
Michal Vasko63f3d842020-07-08 10:10:14 +0200429 in.current = "\t /* comment */\t output\n\t{";
430 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200431 assert_int_equal(LY_STMT_OUTPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200432 assert_int_equal(6, len);
433 assert_string_equal("output\n\t{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200434 assert_string_equal("\n\t{", in.current);
435 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200436 assert_int_equal(LY_STMT_SYNTAX_LEFT_BRACE, kw);
Radek Krejciabdd8062019-06-11 16:44:19 +0200437 assert_int_equal(1, len);
438 assert_string_equal("{", word);
Michal Vasko63f3d842020-07-08 10:10:14 +0200439 assert_string_equal("", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200440
Michal Vasko63f3d842020-07-08 10:10:14 +0200441 in.current = "/input { "; /* invalid slash */
442 assert_int_equal(LY_EVALID, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200443 logbuf_assert("Invalid identifier first character '/'. Line number 4.");
444
Michal Vasko63f3d842020-07-08 10:10:14 +0200445 in.current = "not-a-statement-nor-extension { "; /* invalid identifier */
446 assert_int_equal(LY_EVALID, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200447 logbuf_assert("Invalid character sequence \"not-a-statement-nor-extension\", expected a keyword. Line number 4.");
448
Michal Vasko63f3d842020-07-08 10:10:14 +0200449 in.current = "path;"; /* missing sep after the keyword */
450 assert_int_equal(LY_EVALID, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200451 logbuf_assert("Invalid character sequence \"path;\", expected a keyword followed by a separator. Line number 4.");
452
Michal Vasko63f3d842020-07-08 10:10:14 +0200453 in.current = "action ";
454 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200455 assert_int_equal(LY_STMT_ACTION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200456 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200457 in.current = "anydata ";
458 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200459 assert_int_equal(LY_STMT_ANYDATA, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200460 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200461 in.current = "anyxml ";
462 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200463 assert_int_equal(LY_STMT_ANYXML, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200464 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200465 in.current = "argument ";
466 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200467 assert_int_equal(LY_STMT_ARGUMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200468 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200469 in.current = "augment ";
470 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200471 assert_int_equal(LY_STMT_AUGMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200472 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200473 in.current = "base ";
474 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200475 assert_int_equal(LY_STMT_BASE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200476 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200477 in.current = "belongs-to ";
478 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200479 assert_int_equal(LY_STMT_BELONGS_TO, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200480 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200481 in.current = "bit ";
482 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200483 assert_int_equal(LY_STMT_BIT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200484 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200485 in.current = "case ";
486 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200487 assert_int_equal(LY_STMT_CASE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200488 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200489 in.current = "choice ";
490 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200491 assert_int_equal(LY_STMT_CHOICE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200492 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200493 in.current = "config ";
494 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200495 assert_int_equal(LY_STMT_CONFIG, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200496 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200497 in.current = "contact ";
498 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200499 assert_int_equal(LY_STMT_CONTACT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200500 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200501 in.current = "container ";
502 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200503 assert_int_equal(LY_STMT_CONTAINER, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200504 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200505 in.current = "default ";
506 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200507 assert_int_equal(LY_STMT_DEFAULT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200508 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200509 in.current = "description ";
510 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200511 assert_int_equal(LY_STMT_DESCRIPTION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200512 assert_int_equal(11, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200513 in.current = "deviate ";
514 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200515 assert_int_equal(LY_STMT_DEVIATE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200516 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200517 in.current = "deviation ";
518 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200519 assert_int_equal(LY_STMT_DEVIATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200520 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200521 in.current = "enum ";
522 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200523 assert_int_equal(LY_STMT_ENUM, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200524 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200525 in.current = "error-app-tag ";
526 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200527 assert_int_equal(LY_STMT_ERROR_APP_TAG, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200528 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200529 in.current = "error-message ";
530 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200531 assert_int_equal(LY_STMT_ERROR_MESSAGE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200532 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200533 in.current = "extension ";
534 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200535 assert_int_equal(LY_STMT_EXTENSION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200536 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200537 in.current = "feature ";
538 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200539 assert_int_equal(LY_STMT_FEATURE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200540 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200541 in.current = "fraction-digits ";
542 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200543 assert_int_equal(LY_STMT_FRACTION_DIGITS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200544 assert_int_equal(15, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200545 in.current = "grouping ";
546 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200547 assert_int_equal(LY_STMT_GROUPING, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200548 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200549 in.current = "identity ";
550 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200551 assert_int_equal(LY_STMT_IDENTITY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200552 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200553 in.current = "if-feature ";
554 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200555 assert_int_equal(LY_STMT_IF_FEATURE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200556 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200557 in.current = "import ";
558 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200559 assert_int_equal(LY_STMT_IMPORT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200560 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200561 in.current = "include ";
562 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200563 assert_int_equal(LY_STMT_INCLUDE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200564 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200565 in.current = "input{";
566 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200567 assert_int_equal(LY_STMT_INPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200568 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200569 in.current = "key ";
570 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200571 assert_int_equal(LY_STMT_KEY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200572 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200573 in.current = "leaf ";
574 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200575 assert_int_equal(LY_STMT_LEAF, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200576 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200577 in.current = "leaf-list ";
578 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200579 assert_int_equal(LY_STMT_LEAF_LIST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200580 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200581 in.current = "length ";
582 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200583 assert_int_equal(LY_STMT_LENGTH, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200584 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200585 in.current = "list ";
586 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200587 assert_int_equal(LY_STMT_LIST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200588 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200589 in.current = "mandatory ";
590 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200591 assert_int_equal(LY_STMT_MANDATORY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200592 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200593 in.current = "max-elements ";
594 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200595 assert_int_equal(LY_STMT_MAX_ELEMENTS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200596 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200597 in.current = "min-elements ";
598 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200599 assert_int_equal(LY_STMT_MIN_ELEMENTS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200600 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200601 in.current = "modifier ";
602 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200603 assert_int_equal(LY_STMT_MODIFIER, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200604 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200605 in.current = "module ";
606 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200607 assert_int_equal(LY_STMT_MODULE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200608 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200609 in.current = "must ";
610 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200611 assert_int_equal(LY_STMT_MUST, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200612 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200613 in.current = "namespace ";
614 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200615 assert_int_equal(LY_STMT_NAMESPACE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200616 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200617 in.current = "notification ";
618 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200619 assert_int_equal(LY_STMT_NOTIFICATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200620 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200621 in.current = "ordered-by ";
622 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200623 assert_int_equal(LY_STMT_ORDERED_BY, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200624 assert_int_equal(10, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200625 in.current = "organization ";
626 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200627 assert_int_equal(LY_STMT_ORGANIZATION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200628 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200629 in.current = "output ";
630 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200631 assert_int_equal(LY_STMT_OUTPUT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200632 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200633 in.current = "path ";
634 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200635 assert_int_equal(LY_STMT_PATH, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200636 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200637 in.current = "pattern ";
638 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200639 assert_int_equal(LY_STMT_PATTERN, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200640 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200641 in.current = "position ";
642 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200643 assert_int_equal(LY_STMT_POSITION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200644 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200645 in.current = "prefix ";
646 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200647 assert_int_equal(LY_STMT_PREFIX, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200648 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200649 in.current = "presence ";
650 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200651 assert_int_equal(LY_STMT_PRESENCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200652 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200653 in.current = "range ";
654 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200655 assert_int_equal(LY_STMT_RANGE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200656 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200657 in.current = "reference ";
658 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200659 assert_int_equal(LY_STMT_REFERENCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200660 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200661 in.current = "refine ";
662 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200663 assert_int_equal(LY_STMT_REFINE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200664 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200665 in.current = "require-instance ";
666 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200667 assert_int_equal(LY_STMT_REQUIRE_INSTANCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200668 assert_int_equal(16, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200669 in.current = "revision ";
670 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200671 assert_int_equal(LY_STMT_REVISION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200672 assert_int_equal(8, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200673 in.current = "revision-date ";
674 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200675 assert_int_equal(LY_STMT_REVISION_DATE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200676 assert_int_equal(13, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200677 in.current = "rpc ";
678 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200679 assert_int_equal(LY_STMT_RPC, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200680 assert_int_equal(3, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200681 in.current = "status ";
682 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200683 assert_int_equal(LY_STMT_STATUS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200684 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200685 in.current = "submodule ";
686 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200687 assert_int_equal(LY_STMT_SUBMODULE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200688 assert_int_equal(9, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200689 in.current = "type ";
690 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200691 assert_int_equal(LY_STMT_TYPE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200692 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200693 in.current = "typedef ";
694 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200695 assert_int_equal(LY_STMT_TYPEDEF, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200696 assert_int_equal(7, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200697 in.current = "unique ";
698 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200699 assert_int_equal(LY_STMT_UNIQUE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200700 assert_int_equal(6, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200701 in.current = "units ";
702 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200703 assert_int_equal(LY_STMT_UNITS, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200704 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200705 in.current = "uses ";
706 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200707 assert_int_equal(LY_STMT_USES, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200708 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200709 in.current = "value ";
710 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200711 assert_int_equal(LY_STMT_VALUE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200712 assert_int_equal(5, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200713 in.current = "when ";
714 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200715 assert_int_equal(LY_STMT_WHEN, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200716 assert_int_equal(4, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200717 in.current = "yang-version ";
718 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200719 assert_int_equal(LY_STMT_YANG_VERSION, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200720 assert_int_equal(12, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200721 in.current = "yin-element ";
722 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200723 assert_int_equal(LY_STMT_YIN_ELEMENT, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200724 assert_int_equal(11, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200725 in.current = ";config false;";
726 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200727 assert_int_equal(LY_STMT_SYNTAX_SEMICOLON, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200728 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200729 assert_string_equal("config false;", in.current);
730 in.current = "{ config false;";
731 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200732 assert_int_equal(LY_STMT_SYNTAX_LEFT_BRACE, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200733 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200734 assert_string_equal(" config false;", in.current);
735 in.current = "}";
736 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200737 assert_int_equal(LY_STMT_SYNTAX_RIGHT_BRACE, kw);
Radek Krejci626df482018-10-11 15:06:31 +0200738 assert_int_equal(1, len);
Michal Vasko63f3d842020-07-08 10:10:14 +0200739 assert_string_equal("", in.current);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200740
741 /* geenric extension */
Michal Vasko63f3d842020-07-08 10:10:14 +0200742 in.current = p = "nacm:default-deny-write;";
743 assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &in, &kw, &word, &len));
Radek Krejcid6b76452019-09-03 17:03:03 +0200744 assert_int_equal(LY_STMT_EXTENSION_INSTANCE, kw);
Radek Krejcidcc7b322018-10-11 14:24:02 +0200745 assert_int_equal(23, len);
746 assert_ptr_equal(p, word);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200747}
Radek Krejci44ceedc2018-10-02 15:54:31 +0200748
Radek Krejci05b13982018-11-28 16:22:07 +0100749static void
750test_minmax(void **state)
751{
752 *state = test_minmax;
753
Michal Vaskob36053d2020-03-26 15:49:30 +0100754 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci05b13982018-11-28 16:22:07 +0100755 uint16_t flags = 0;
756 uint32_t value = 0;
757 struct lysp_ext_instance *ext = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +0200758 struct ly_in in = {0};
Radek Krejci05b13982018-11-28 16:22:07 +0100759
Michal Vaskob36053d2020-03-26 15:49:30 +0100760 ctx.format = LYS_IN_YANG;
Radek Krejci05b13982018-11-28 16:22:07 +0100761 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
762 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +0200763 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci05b13982018-11-28 16:22:07 +0100764 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100765 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci05b13982018-11-28 16:22:07 +0100766
Michal Vasko63f3d842020-07-08 10:10:14 +0200767 in.current = " 1invalid; ...";
768 assert_int_equal(LY_EVALID, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100769 logbuf_assert("Invalid value \"1invalid\" of \"min-elements\". Line number 1.");
Radek Krejci05b13982018-11-28 16:22:07 +0100770
771 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200772 in.current = " -1; ...";
773 assert_int_equal(LY_EVALID, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100774 logbuf_assert("Invalid value \"-1\" of \"min-elements\". Line number 1.");
775
Radek Krejcidf6cad12018-11-28 17:10:55 +0100776 /* implementation limit */
777 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200778 in.current = " 4294967296; ...";
779 assert_int_equal(LY_EVALID, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100780 logbuf_assert("Value \"4294967296\" is out of \"min-elements\" bounds. Line number 1.");
781
Radek Krejci05b13982018-11-28 16:22:07 +0100782 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200783 in.current = " 1; ...";
784 assert_int_equal(LY_SUCCESS, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100785 assert_int_equal(LYS_SET_MIN, flags);
786 assert_int_equal(1, value);
787
788 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200789 in.current = " 1 {m:ext;} ...";
790 assert_int_equal(LY_SUCCESS, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100791 assert_int_equal(LYS_SET_MIN, flags);
792 assert_int_equal(1, value);
793 assert_non_null(ext);
794 FREE_ARRAY(ctx.ctx, ext, lysp_ext_instance_free);
795 ext = NULL;
796
797 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200798 in.current = " 1 {config true;} ...";
799 assert_int_equal(LY_EVALID, parse_minelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100800 logbuf_assert("Invalid keyword \"config\" as a child of \"min-elements\". Line number 1.");
801
Michal Vasko63f3d842020-07-08 10:10:14 +0200802 in.current = " 1invalid; ...";
803 assert_int_equal(LY_EVALID, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100804 logbuf_assert("Invalid value \"1invalid\" of \"max-elements\". Line number 1.");
Radek Krejci05b13982018-11-28 16:22:07 +0100805
806 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200807 in.current = " -1; ...";
808 assert_int_equal(LY_EVALID, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100809 logbuf_assert("Invalid value \"-1\" of \"max-elements\". Line number 1.");
810
Radek Krejcidf6cad12018-11-28 17:10:55 +0100811 /* implementation limit */
812 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200813 in.current = " 4294967296; ...";
814 assert_int_equal(LY_EVALID, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejcidf6cad12018-11-28 17:10:55 +0100815 logbuf_assert("Value \"4294967296\" is out of \"max-elements\" bounds. Line number 1.");
816
Radek Krejci05b13982018-11-28 16:22:07 +0100817 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200818 in.current = " 1; ...";
819 assert_int_equal(LY_SUCCESS, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100820 assert_int_equal(LYS_SET_MAX, flags);
821 assert_int_equal(1, value);
822
823 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200824 in.current = " unbounded; ...";
825 assert_int_equal(LY_SUCCESS, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100826 assert_int_equal(LYS_SET_MAX, flags);
827 assert_int_equal(0, value);
828
829 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200830 in.current = " 1 {m:ext;} ...";
831 assert_int_equal(LY_SUCCESS, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100832 assert_int_equal(LYS_SET_MAX, flags);
833 assert_int_equal(1, value);
834 assert_non_null(ext);
835 FREE_ARRAY(ctx.ctx, ext, lysp_ext_instance_free);
836 ext = NULL;
837
838 flags = value = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +0200839 in.current = " 1 {config true;} ...";
840 assert_int_equal(LY_EVALID, parse_maxelements(&ctx, &in, &value, &flags, &ext));
Radek Krejci05b13982018-11-28 16:22:07 +0100841 logbuf_assert("Invalid keyword \"config\" as a child of \"max-elements\". Line number 1.");
842
843 *state = NULL;
844 ly_ctx_destroy(ctx.ctx, NULL);
845}
846
Radek Krejci9fcacc12018-10-11 15:59:11 +0200847static struct lysp_module *
Michal Vaskob36053d2020-03-26 15:49:30 +0100848mod_renew(struct lys_yang_parser_ctx *ctx)
Radek Krejci9fcacc12018-10-11 15:59:11 +0200849{
Radek Krejci40544fa2019-01-11 09:38:37 +0100850 struct lysp_module *mod_p;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100851 static struct lys_module mod = {0};
852
853 lysc_module_free(mod.compiled, NULL);
854 lysp_module_free(mod.parsed);
855 FREE_STRING(mod.ctx, mod.name);
856 FREE_STRING(mod.ctx, mod.ns);
857 FREE_STRING(mod.ctx, mod.prefix);
858 FREE_STRING(mod.ctx, mod.filepath);
859 FREE_STRING(mod.ctx, mod.org);
860 FREE_STRING(mod.ctx, mod.contact);
861 FREE_STRING(mod.ctx, mod.dsc);
862 FREE_STRING(mod.ctx, mod.ref);
863 memset(&mod, 0, sizeof mod);
864 mod.ctx = ctx->ctx;
865
866 mod_p = calloc(1, sizeof *mod_p);
867 mod.parsed = mod_p;
868 mod_p->mod = &mod;
869 assert_non_null(mod_p);
870 return mod_p;
871}
872
873static struct lysp_submodule *
Michal Vaskob36053d2020-03-26 15:49:30 +0100874submod_renew(struct lys_yang_parser_ctx *ctx, struct lysp_submodule *submod)
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100875{
876 lysp_submodule_free(ctx->ctx, submod);
877 submod = calloc(1, sizeof *submod);
878 assert_non_null(submod);
879 return submod;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200880}
881
Radek Krejcid33273d2018-10-25 14:55:52 +0200882static LY_ERR test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name),
883 const char *UNUSED(sub_rev), void *user_data, LYS_INFORMAT *format,
884 const char **module_data, void (**free_module_data)(void *model_data, void *user_data))
885{
886 *module_data = user_data;
887 *format = LYS_IN_YANG;
888 *free_module_data = NULL;
889 return LY_SUCCESS;
890}
891
Radek Krejci9fcacc12018-10-11 15:59:11 +0200892static void
893test_module(void **state)
894{
Radek Krejci40544fa2019-01-11 09:38:37 +0100895 *state = test_module;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200896
Michal Vaskob36053d2020-03-26 15:49:30 +0100897 struct lys_yang_parser_ctx ctx;
Radek Krejci40544fa2019-01-11 09:38:37 +0100898 struct lysp_module *mod = NULL;
899 struct lysp_submodule *submod = NULL;
900 struct lys_module *m;
Michal Vasko63f3d842020-07-08 10:10:14 +0200901 struct ly_in in = {0};
Radek Krejci9fcacc12018-10-11 15:59:11 +0200902
Michal Vaskob36053d2020-03-26 15:49:30 +0100903 ctx.format = LYS_IN_YANG;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200904 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
905 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +0200906 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200907 ctx.line = 1;
Radek Krejcia042ea12018-10-13 07:52:15 +0200908 ctx.indent = 0;
Radek Krejci9fcacc12018-10-11 15:59:11 +0200909
Radek Krejci40544fa2019-01-11 09:38:37 +0100910 mod = mod_renew(&ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200911
912 /* missing mandatory substatements */
Michal Vasko63f3d842020-07-08 10:10:14 +0200913 in.current = " name {}";
914 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100915 assert_string_equal("name", mod->mod->name);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200916 logbuf_assert("Missing mandatory keyword \"namespace\" as a child of \"module\". Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +0100917 mod = mod_renew(&ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200918
Michal Vasko63f3d842020-07-08 10:10:14 +0200919 in.current = " name {namespace urn:x;}";
920 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100921 assert_string_equal("urn:x", mod->mod->ns);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200922 logbuf_assert("Missing mandatory keyword \"prefix\" as a child of \"module\". Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +0100923 mod = mod_renew(&ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200924
Michal Vasko63f3d842020-07-08 10:10:14 +0200925 in.current = " name {namespace urn:x;prefix \"x\";}";
926 assert_int_equal(LY_SUCCESS, parse_module(&ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100927 assert_string_equal("x", mod->mod->prefix);
Radek Krejci40544fa2019-01-11 09:38:37 +0100928 mod = mod_renew(&ctx);
Radek Krejci9fcacc12018-10-11 15:59:11 +0200929
Radek Krejci027d5802018-11-14 16:57:28 +0100930#define SCHEMA_BEGINNING " name {yang-version 1.1;namespace urn:x;prefix \"x\";"
931#define SCHEMA_BEGINNING2 " name {namespace urn:x;prefix \"x\";"
Radek Krejcia042ea12018-10-13 07:52:15 +0200932#define TEST_NODE(NODETYPE, INPUT, NAME) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200933 in.current = SCHEMA_BEGINNING INPUT; \
934 assert_int_equal(LY_SUCCESS, parse_module(&ctx, &in, mod)); \
Radek Krejcia042ea12018-10-13 07:52:15 +0200935 assert_non_null(mod->data); \
936 assert_int_equal(NODETYPE, mod->data->nodetype); \
937 assert_string_equal(NAME, mod->data->name); \
Radek Krejci40544fa2019-01-11 09:38:37 +0100938 mod = mod_renew(&ctx);
Radek Krejcia042ea12018-10-13 07:52:15 +0200939#define TEST_GENERIC(INPUT, TARGET, TEST) \
Michal Vasko63f3d842020-07-08 10:10:14 +0200940 in.current = SCHEMA_BEGINNING INPUT; \
941 assert_int_equal(LY_SUCCESS, parse_module(&ctx, &in, mod)); \
Radek Krejcia042ea12018-10-13 07:52:15 +0200942 assert_non_null(TARGET); \
943 TEST; \
Radek Krejci40544fa2019-01-11 09:38:37 +0100944 mod = mod_renew(&ctx);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100945#define TEST_DUP(MEMBER, VALUE1, VALUE2, LINE) \
Radek Krejci2c02f3e2018-10-16 10:54:38 +0200946 TEST_DUP_GENERIC(SCHEMA_BEGINNING, MEMBER, VALUE1, VALUE2, \
Radek Krejci40544fa2019-01-11 09:38:37 +0100947 parse_module, mod, LINE, mod = mod_renew(&ctx))
Radek Krejcia042ea12018-10-13 07:52:15 +0200948
949 /* duplicated namespace, prefix */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100950 TEST_DUP("namespace", "y", "z", "1");
951 TEST_DUP("prefix", "y", "z", "1");
952 TEST_DUP("contact", "a", "b", "1");
953 TEST_DUP("description", "a", "b", "1");
954 TEST_DUP("organization", "a", "b", "1");
955 TEST_DUP("reference", "a", "b", "1");
Radek Krejcia042ea12018-10-13 07:52:15 +0200956
Radek Krejci70853c52018-10-15 14:46:16 +0200957 /* not allowed in module (submodule-specific) */
Michal Vasko63f3d842020-07-08 10:10:14 +0200958 in.current = SCHEMA_BEGINNING "belongs-to master {prefix m;}}";
959 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci70853c52018-10-15 14:46:16 +0200960 logbuf_assert("Invalid keyword \"belongs-to\" as a child of \"module\". Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +0100961 mod = mod_renew(&ctx);
Radek Krejci70853c52018-10-15 14:46:16 +0200962
Radek Krejcia042ea12018-10-13 07:52:15 +0200963 /* anydata */
964 TEST_NODE(LYS_ANYDATA, "anydata test;}", "test");
965 /* anyxml */
966 TEST_NODE(LYS_ANYXML, "anyxml test;}", "test");
967 /* augment */
968 TEST_GENERIC("augment /somepath;}", mod->augments,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200969 assert_string_equal("/somepath", mod->augments[0].nodeid));
Radek Krejcia042ea12018-10-13 07:52:15 +0200970 /* choice */
971 TEST_NODE(LYS_CHOICE, "choice test;}", "test");
972 /* contact 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100973 TEST_GENERIC("contact \"firstname\" + \n\t\" surname\";}", mod->mod->contact,
974 assert_string_equal("firstname surname", mod->mod->contact));
Radek Krejcia042ea12018-10-13 07:52:15 +0200975 /* container */
976 TEST_NODE(LYS_CONTAINER, "container test;}", "test");
977 /* description 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100978 TEST_GENERIC("description \'some description\';}", mod->mod->dsc,
979 assert_string_equal("some description", mod->mod->dsc));
Radek Krejcia042ea12018-10-13 07:52:15 +0200980 /* deviation */
981 TEST_GENERIC("deviation /somepath {deviate not-supported;}}", mod->deviations,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200982 assert_string_equal("/somepath", mod->deviations[0].nodeid));
Radek Krejcia042ea12018-10-13 07:52:15 +0200983 /* extension */
984 TEST_GENERIC("extension test;}", mod->extensions,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200985 assert_string_equal("test", mod->extensions[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200986 /* feature */
987 TEST_GENERIC("feature test;}", mod->features,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200988 assert_string_equal("test", mod->features[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200989 /* grouping */
990 TEST_GENERIC("grouping grp;}", mod->groupings,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200991 assert_string_equal("grp", mod->groupings[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200992 /* identity */
993 TEST_GENERIC("identity test;}", mod->identities,
Radek Krejci2c4e7172018-10-19 15:56:26 +0200994 assert_string_equal("test", mod->identities[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +0200995 /* import */
Radek Krejci086c7132018-10-26 15:29:04 +0200996 ly_ctx_set_module_imp_clb(ctx.ctx, test_imp_clb, "module zzz { namespace urn:zzz; prefix z;}");
997 TEST_GENERIC("import zzz {prefix z;}}", mod->imports,
998 assert_string_equal("zzz", mod->imports[0].name));
Radek Krejci70853c52018-10-15 14:46:16 +0200999
Radek Krejcia042ea12018-10-13 07:52:15 +02001000 /* import - prefix collision */
Michal Vasko63f3d842020-07-08 10:10:14 +02001001 in.current = SCHEMA_BEGINNING "import zzz {prefix x;}}";
1002 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci70853c52018-10-15 14:46:16 +02001003 logbuf_assert("Prefix \"x\" already used as module prefix. Line number 2.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001004 mod = mod_renew(&ctx);
Michal Vasko63f3d842020-07-08 10:10:14 +02001005 in.current = SCHEMA_BEGINNING "import zzz {prefix y;}import zzz {prefix y;}}";
1006 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci086c7132018-10-26 15:29:04 +02001007 logbuf_assert("Prefix \"y\" already used to import \"zzz\" module. Line number 2.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001008 mod = mod_renew(&ctx);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001009 in.current = "module name10 {yang-version 1.1;namespace urn:x;prefix \"x\";import zzz {prefix y;}import zzz {prefix z;}}";
1010 assert_int_equal(lys_parse_mem(ctx.ctx, in.current, LYS_IN_YANG, NULL), LY_SUCCESS);
1011 logbuf_assert("Single revision of the module \"zzz\" imported twice.");
Radek Krejci70853c52018-10-15 14:46:16 +02001012
Radek Krejcia042ea12018-10-13 07:52:15 +02001013 /* include */
Radek Krejci9ed7a192018-10-31 16:23:51 +01001014 store = 1;
Radek Krejcid33273d2018-10-25 14:55:52 +02001015 ly_ctx_set_module_imp_clb(ctx.ctx, test_imp_clb, "module xxx { namespace urn:xxx; prefix x;}");
Michal Vasko63f3d842020-07-08 10:10:14 +02001016 in.current = "module" SCHEMA_BEGINNING "include xxx;}";
Michal Vasko3a41dff2020-07-15 14:30:28 +02001017 assert_int_equal(lys_parse_mem(ctx.ctx, in.current, LYS_IN_YANG, NULL), LY_EVALID);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001018 logbuf_assert("Input data contains module in situation when a submodule is expected.");
Radek Krejci9ed7a192018-10-31 16:23:51 +01001019 store = -1;
Radek Krejcid33273d2018-10-25 14:55:52 +02001020
Radek Krejci9ed7a192018-10-31 16:23:51 +01001021 store = 1;
Radek Krejci313d9902018-11-08 09:42:58 +01001022 ly_ctx_set_module_imp_clb(ctx.ctx, test_imp_clb, "submodule xxx {belongs-to wrong-name {prefix w;}}");
Michal Vasko63f3d842020-07-08 10:10:14 +02001023 in.current = "module" SCHEMA_BEGINNING "include xxx;}";
Michal Vasko3a41dff2020-07-15 14:30:28 +02001024 assert_int_equal(lys_parse_mem(ctx.ctx, in.current, LYS_IN_YANG, NULL), LY_EVALID);
Radek Krejci086c7132018-10-26 15:29:04 +02001025 logbuf_assert("Included \"xxx\" submodule from \"name\" belongs-to a different module \"wrong-name\".");
Radek Krejci9ed7a192018-10-31 16:23:51 +01001026 store = -1;
Radek Krejcid33273d2018-10-25 14:55:52 +02001027
Radek Krejci313d9902018-11-08 09:42:58 +01001028 ly_ctx_set_module_imp_clb(ctx.ctx, test_imp_clb, "submodule xxx {belongs-to name {prefix x;}}");
Radek Krejcid33273d2018-10-25 14:55:52 +02001029 TEST_GENERIC("include xxx;}", mod->includes,
Radek Krejci086c7132018-10-26 15:29:04 +02001030 assert_string_equal("xxx", mod->includes[0].name));
Radek Krejcid33273d2018-10-25 14:55:52 +02001031
Radek Krejcia042ea12018-10-13 07:52:15 +02001032 /* leaf */
1033 TEST_NODE(LYS_LEAF, "leaf test {type string;}}", "test");
1034 /* leaf-list */
1035 TEST_NODE(LYS_LEAFLIST, "leaf-list test {type string;}}", "test");
1036 /* list */
1037 TEST_NODE(LYS_LIST, "list test {key a;leaf a {type string;}}}", "test");
1038 /* notification */
1039 TEST_GENERIC("notification test;}", mod->notifs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001040 assert_string_equal("test", mod->notifs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001041 /* organization 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001042 TEST_GENERIC("organization \"CESNET a.l.e.\";}", mod->mod->org,
1043 assert_string_equal("CESNET a.l.e.", mod->mod->org));
Radek Krejcia042ea12018-10-13 07:52:15 +02001044 /* reference 0..1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001045 TEST_GENERIC("reference RFC7950;}", mod->mod->ref,
1046 assert_string_equal("RFC7950", mod->mod->ref));
Radek Krejcia042ea12018-10-13 07:52:15 +02001047 /* revision */
1048 TEST_GENERIC("revision 2018-10-12;}", mod->revs,
Radek Krejcib7db73a2018-10-24 14:18:40 +02001049 assert_string_equal("2018-10-12", mod->revs[0].date));
Radek Krejcia042ea12018-10-13 07:52:15 +02001050 /* rpc */
1051 TEST_GENERIC("rpc test;}", mod->rpcs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001052 assert_string_equal("test", mod->rpcs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001053 /* typedef */
1054 TEST_GENERIC("typedef test{type string;}}", mod->typedefs,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001055 assert_string_equal("test", mod->typedefs[0].name));
Radek Krejcia042ea12018-10-13 07:52:15 +02001056 /* uses */
1057 TEST_NODE(LYS_USES, "uses test;}", "test");
1058 /* yang-version */
Michal Vasko63f3d842020-07-08 10:10:14 +02001059 in.current = SCHEMA_BEGINNING2 "\n\tyang-version 10;}";
1060 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejcia042ea12018-10-13 07:52:15 +02001061 logbuf_assert("Invalid value \"10\" of \"yang-version\". Line number 3.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001062 mod = mod_renew(&ctx);
Radek Krejci96e48da2020-09-04 13:18:06 +02001063 in.current = SCHEMA_BEGINNING2 "yang-version 1;yang-version 1.1;}";
Michal Vasko63f3d842020-07-08 10:10:14 +02001064 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejcia042ea12018-10-13 07:52:15 +02001065 logbuf_assert("Duplicate keyword \"yang-version\". Line number 3.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001066 mod = mod_renew(&ctx);
Radek Krejci96e48da2020-09-04 13:18:06 +02001067 in.current = SCHEMA_BEGINNING2 "yang-version 1;}";
Michal Vasko63f3d842020-07-08 10:10:14 +02001068 assert_int_equal(LY_SUCCESS, parse_module(&ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001069 assert_int_equal(1, mod->mod->version);
Radek Krejci40544fa2019-01-11 09:38:37 +01001070 mod = mod_renew(&ctx);
Michal Vasko63f3d842020-07-08 10:10:14 +02001071 in.current = SCHEMA_BEGINNING2 "yang-version \"1.1\";}";
1072 assert_int_equal(LY_SUCCESS, parse_module(&ctx, &in, mod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001073 assert_int_equal(2, mod->mod->version);
Radek Krejci40544fa2019-01-11 09:38:37 +01001074 mod = mod_renew(&ctx);
1075
Michal Vaskob36053d2020-03-26 15:49:30 +01001076 struct lys_yang_parser_ctx *ctx_p = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001077 in.current = "module " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}";
Radek Krejci40544fa2019-01-11 09:38:37 +01001078 m = mod->mod;
1079 free(mod);
1080 m->parsed = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001081 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
David Sedlák1b623122019-08-05 15:27:49 +02001082 logbuf_assert("Trailing garbage \"module q {names...\" after module, expected end-of-input. Line number 1.");
Michal Vaskob36053d2020-03-26 15:49:30 +01001083 yang_parser_ctx_free(ctx_p);
Radek Krejci40544fa2019-01-11 09:38:37 +01001084 mod = mod_renew(&ctx);
1085
Michal Vasko63f3d842020-07-08 10:10:14 +02001086 in.current = "prefix " SCHEMA_BEGINNING "}";
Radek Krejci40544fa2019-01-11 09:38:37 +01001087 m = mod->mod;
1088 free(mod);
1089 m->parsed = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001090 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
Michal Vaskob36053d2020-03-26 15:49:30 +01001091 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001092 logbuf_assert("Invalid keyword \"prefix\", expected \"module\" or \"submodule\". Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001093 mod = mod_renew(&ctx);
Radek Krejci09306362018-10-15 15:26:01 +02001094
Michal Vasko63f3d842020-07-08 10:10:14 +02001095 in.current = "module " SCHEMA_BEGINNING "leaf enum {type enumeration {enum seven { position 7;}}}}";
David Sedlák9fb515f2019-07-11 10:33:58 +02001096 m = mod->mod;
1097 free(mod);
1098 m->parsed = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001099 assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m));
Michal Vaskob36053d2020-03-26 15:49:30 +01001100 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001101 logbuf_assert("Invalid keyword \"position\" as a child of \"enum\". Line number 1.");
David Sedlák9fb515f2019-07-11 10:33:58 +02001102 mod = mod_renew(&ctx);
1103
Radek Krejci156ccaf2018-10-15 15:49:17 +02001104 /* extensions */
1105 TEST_GENERIC("prefix:test;}", mod->exts,
Radek Krejci2c4e7172018-10-19 15:56:26 +02001106 assert_string_equal("prefix:test", mod->exts[0].name);
1107 assert_int_equal(LYEXT_SUBSTMT_SELF, mod->exts[0].insubstmt));
Radek Krejci40544fa2019-01-11 09:38:37 +01001108 mod = mod_renew(&ctx);
Radek Krejci156ccaf2018-10-15 15:49:17 +02001109
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001110 /* invalid substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001111 in.current = SCHEMA_BEGINNING "must false;}";
1112 assert_int_equal(LY_EVALID, parse_module(&ctx, &in, mod));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001113 logbuf_assert("Invalid keyword \"must\" as a child of \"module\". Line number 3.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001114 mod = mod_renew(&ctx);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001115
Radek Krejci09306362018-10-15 15:26:01 +02001116 /* submodule */
Radek Krejci40544fa2019-01-11 09:38:37 +01001117 submod = submod_renew(&ctx, submod);
Radek Krejci09306362018-10-15 15:26:01 +02001118
1119 /* missing mandatory substatements */
Michal Vasko63f3d842020-07-08 10:10:14 +02001120 in.current = " subname {}";
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001121 lydict_remove(ctx.ctx, submod->name);
Michal Vasko63f3d842020-07-08 10:10:14 +02001122 assert_int_equal(LY_EVALID, parse_submodule(&ctx, &in, submod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001123 assert_string_equal("subname", submod->name);
Radek Krejci09306362018-10-15 15:26:01 +02001124 logbuf_assert("Missing mandatory keyword \"belongs-to\" as a child of \"submodule\". Line number 3.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001125 submod = submod_renew(&ctx, submod);
Radek Krejci09306362018-10-15 15:26:01 +02001126
Michal Vasko63f3d842020-07-08 10:10:14 +02001127 in.current = " subname {belongs-to name {prefix x;}}";
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001128 lydict_remove(ctx.ctx, submod->name);
Michal Vasko63f3d842020-07-08 10:10:14 +02001129 assert_int_equal(LY_SUCCESS, parse_submodule(&ctx, &in, submod));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001130 assert_string_equal("name", submod->belongsto);
1131 submod = submod_renew(&ctx, submod);
Radek Krejci09306362018-10-15 15:26:01 +02001132
1133#undef SCHEMA_BEGINNING
Radek Krejci313d9902018-11-08 09:42:58 +01001134#define SCHEMA_BEGINNING " subname {belongs-to name {prefix x;}"
Radek Krejci09306362018-10-15 15:26:01 +02001135
1136 /* duplicated namespace, prefix */
Michal Vasko63f3d842020-07-08 10:10:14 +02001137 in.current = " subname {belongs-to name {prefix x;}belongs-to module1;belongs-to module2;} ...";
1138 assert_int_equal(LY_EVALID, parse_submodule(&ctx, &in, submod)); \
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001139 logbuf_assert("Duplicate keyword \"belongs-to\". Line number 3."); \
1140 submod = submod_renew(&ctx, submod);
Radek Krejci09306362018-10-15 15:26:01 +02001141
1142 /* not allowed in submodule (module-specific) */
Michal Vasko63f3d842020-07-08 10:10:14 +02001143 in.current = SCHEMA_BEGINNING "namespace \"urn:z\";}";
1144 assert_int_equal(LY_EVALID, parse_submodule(&ctx, &in, submod));
Radek Krejci09306362018-10-15 15:26:01 +02001145 logbuf_assert("Invalid keyword \"namespace\" as a child of \"submodule\". Line number 3.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001146 submod = submod_renew(&ctx, submod);
Michal Vasko63f3d842020-07-08 10:10:14 +02001147 in.current = SCHEMA_BEGINNING "prefix m;}}";
1148 assert_int_equal(LY_EVALID, parse_submodule(&ctx, &in, submod));
Radek Krejci09306362018-10-15 15:26:01 +02001149 logbuf_assert("Invalid keyword \"prefix\" as a child of \"submodule\". Line number 3.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001150 submod = submod_renew(&ctx, submod);
Radek Krejcia042ea12018-10-13 07:52:15 +02001151
Michal Vasko63f3d842020-07-08 10:10:14 +02001152 in.current = "submodule " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}";
Radek Krejci40544fa2019-01-11 09:38:37 +01001153 lysp_submodule_free(ctx.ctx, submod);
1154 submod = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001155 assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, ctx.ctx, (struct lys_parser_ctx *)&ctx, &in, &submod));
Michal Vaskob36053d2020-03-26 15:49:30 +01001156 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001157 logbuf_assert("Trailing garbage \"module q {names...\" after submodule, expected end-of-input. Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001158
Michal Vasko63f3d842020-07-08 10:10:14 +02001159 in.current = "prefix " SCHEMA_BEGINNING "}";
1160 assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, ctx.ctx, (struct lys_parser_ctx *)&ctx, &in, &submod));
Michal Vaskob36053d2020-03-26 15:49:30 +01001161 yang_parser_ctx_free(ctx_p);
David Sedlák1b623122019-08-05 15:27:49 +02001162 logbuf_assert("Invalid keyword \"prefix\", expected \"module\" or \"submodule\". Line number 1.");
Radek Krejci40544fa2019-01-11 09:38:37 +01001163 submod = submod_renew(&ctx, submod);
1164
Radek Krejcia042ea12018-10-13 07:52:15 +02001165#undef TEST_GENERIC
1166#undef TEST_NODE
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001167#undef TEST_DUP
Radek Krejcia042ea12018-10-13 07:52:15 +02001168#undef SCHEMA_BEGINNING
1169
Radek Krejci9fcacc12018-10-11 15:59:11 +02001170 lysp_module_free(mod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001171 lysp_submodule_free(ctx.ctx, submod);
Radek Krejci9fcacc12018-10-11 15:59:11 +02001172 ly_ctx_destroy(ctx.ctx, NULL);
Radek Krejci40544fa2019-01-11 09:38:37 +01001173
1174 *state = NULL;
Radek Krejciefd22f62018-09-27 11:47:58 +02001175}
1176
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001177static void
1178test_deviation(void **state)
1179{
1180 (void) state; /* unused */
1181
Michal Vaskob36053d2020-03-26 15:49:30 +01001182 struct lys_yang_parser_ctx ctx;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001183 struct lysp_deviation *d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001184 struct ly_in in = {0};
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001185
Michal Vaskob36053d2020-03-26 15:49:30 +01001186 ctx.format = LYS_IN_YANG;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001187 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1188 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001189 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001190 ctx.line = 1;
1191 ctx.indent = 0;
1192
1193 /* invalid cardinality */
1194#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
1195 TEST_DUP_GENERIC(" test {deviate not-supported;", MEMBER, VALUE1, VALUE2, parse_deviation, \
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001196 &d, "1", FREE_ARRAY(ctx.ctx, d, lysp_deviation_free); d = NULL)
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001197
1198 TEST_DUP("description", "a", "b");
1199 TEST_DUP("reference", "a", "b");
1200
1201 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001202 in.current = " test {deviate not-supported;description text;reference \'another text\';prefix:ext;} ...";
1203 assert_int_equal(LY_SUCCESS, parse_deviation(&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);
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001206 FREE_ARRAY(ctx.ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001207 d = NULL;
1208
1209 /* missing mandatory substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001210 in.current = " test {description text;}";
1211 assert_int_equal(LY_EVALID, parse_deviation(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001212 logbuf_assert("Missing mandatory keyword \"deviate\" as a child of \"deviation\". Line number 1.");
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001213 FREE_ARRAY(ctx.ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001214 d = NULL;
1215
1216 /* invalid substatement */
Michal Vasko63f3d842020-07-08 10:10:14 +02001217 in.current = " test {deviate not-supported; status obsolete;}";
1218 assert_int_equal(LY_EVALID, parse_deviation(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001219 logbuf_assert("Invalid keyword \"status\" as a child of \"deviation\". Line number 1.");
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001220 FREE_ARRAY(ctx.ctx, d, lysp_deviation_free);
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001221 d = NULL;
1222
1223#undef TEST_DUP
1224
1225 ly_ctx_destroy(ctx.ctx, NULL);
1226}
1227
1228static void
1229test_deviate(void **state)
1230{
1231 (void) state; /* unused */
1232
Michal Vaskob36053d2020-03-26 15:49:30 +01001233 struct lys_yang_parser_ctx ctx;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001234 struct lysp_deviate *d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001235 struct ly_in in = {0};
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001236
Michal Vaskob36053d2020-03-26 15:49:30 +01001237 ctx.format = LYS_IN_YANG;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001238 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1239 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001240 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001241 ctx.line = 1;
1242 ctx.indent = 0;
1243
1244 /* invalid cardinality */
1245#define TEST_DUP(TYPE, MEMBER, VALUE1, VALUE2) \
1246 TEST_DUP_GENERIC(TYPE" {", MEMBER, VALUE1, VALUE2, parse_deviate, \
Radek Krejci4f28eda2018-11-12 11:46:16 +01001247 &d, "1", lysp_deviate_free(ctx.ctx, d); free(d); d = NULL)
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001248
1249 TEST_DUP("add", "config", "true", "false");
1250 TEST_DUP("replace", "default", "int8", "uint8");
1251 TEST_DUP("add", "mandatory", "true", "false");
1252 TEST_DUP("add", "max-elements", "1", "2");
1253 TEST_DUP("add", "min-elements", "1", "2");
1254 TEST_DUP("replace", "type", "int8", "uint8");
1255 TEST_DUP("add", "units", "kilometers", "miles");
1256
1257 /* full contents */
Michal Vasko63f3d842020-07-08 10:10:14 +02001258 in.current = " not-supported {prefix:ext;} ...";
1259 assert_int_equal(LY_SUCCESS, parse_deviate(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001260 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001261 assert_string_equal(" ...", in.current);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001262 lysp_deviate_free(ctx.ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001263 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;} ...";
1264 assert_int_equal(LY_SUCCESS, parse_deviate(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001265 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001266 assert_string_equal(" ...", in.current);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001267 lysp_deviate_free(ctx.ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001268 in.current = " delete {units meters; must 1; must 2; unique x; unique y; default a; default b; prefix:ext;} ...";
1269 assert_int_equal(LY_SUCCESS, parse_deviate(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001270 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001271 assert_string_equal(" ...", in.current);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001272 lysp_deviate_free(ctx.ctx, d); free(d); d = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001273 in.current = " replace {type string; units meters; default a; config true; mandatory true; min-elements 1; max-elements 2; prefix:ext;} ...";
1274 assert_int_equal(LY_SUCCESS, parse_deviate(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001275 assert_non_null(d);
Michal Vasko63f3d842020-07-08 10:10:14 +02001276 assert_string_equal(" ...", in.current);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001277 lysp_deviate_free(ctx.ctx, d); free(d); d = NULL;
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001278
1279 /* invalid substatements */
1280#define TEST_NOT_SUP(DEV, STMT, VALUE) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001281 in.current = " "DEV" {"STMT" "VALUE";}..."; \
1282 assert_int_equal(LY_EVALID, parse_deviate(&ctx, &in, &d)); \
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001283 logbuf_assert("Deviate \""DEV"\" does not support keyword \""STMT"\". Line number 1."); \
Radek Krejci4f28eda2018-11-12 11:46:16 +01001284 lysp_deviate_free(ctx.ctx, d); free(d); d = NULL
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001285
1286 TEST_NOT_SUP("not-supported", "units", "meters");
1287 TEST_NOT_SUP("not-supported", "must", "1");
1288 TEST_NOT_SUP("not-supported", "unique", "x");
1289 TEST_NOT_SUP("not-supported", "default", "a");
1290 TEST_NOT_SUP("not-supported", "config", "true");
1291 TEST_NOT_SUP("not-supported", "mandatory", "true");
1292 TEST_NOT_SUP("not-supported", "min-elements", "1");
1293 TEST_NOT_SUP("not-supported", "max-elements", "2");
1294 TEST_NOT_SUP("not-supported", "type", "string");
1295 TEST_NOT_SUP("add", "type", "string");
1296 TEST_NOT_SUP("delete", "config", "true");
1297 TEST_NOT_SUP("delete", "mandatory", "true");
1298 TEST_NOT_SUP("delete", "min-elements", "1");
1299 TEST_NOT_SUP("delete", "max-elements", "2");
1300 TEST_NOT_SUP("delete", "type", "string");
1301 TEST_NOT_SUP("replace", "must", "1");
1302 TEST_NOT_SUP("replace", "unique", "a");
1303
Michal Vasko63f3d842020-07-08 10:10:14 +02001304 in.current = " nonsence; ...";
1305 assert_int_equal(LY_EVALID, parse_deviate(&ctx, &in, &d));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02001306 logbuf_assert("Invalid value \"nonsence\" of \"deviate\". Line number 1.");
1307 assert_null(d);
1308
1309#undef TEST_NOT_SUP
1310#undef TEST_DUP
Radek Krejci4c6d9bd2018-10-15 16:43:06 +02001311
1312 ly_ctx_destroy(ctx.ctx, NULL);
1313}
1314
Radek Krejci8c370832018-11-02 15:10:03 +01001315static void
1316test_container(void **state)
1317{
1318 (void) state; /* unused */
1319
Michal Vaskob36053d2020-03-26 15:49:30 +01001320 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci8c370832018-11-02 15:10:03 +01001321 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001322 struct ly_in in = {0};
Radek Krejci8c370832018-11-02 15:10:03 +01001323
Michal Vaskob36053d2020-03-26 15:49:30 +01001324 ctx.format = LYS_IN_YANG;
Radek Krejci8c370832018-11-02 15:10:03 +01001325 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1326 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001327 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci8c370832018-11-02 15:10:03 +01001328 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001329 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci8c370832018-11-02 15:10:03 +01001330
1331 /* invalid cardinality */
1332#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001333 in.current = "cont {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1334 assert_int_equal(LY_EVALID, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c)); \
Radek Krejci8c370832018-11-02 15:10:03 +01001335 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Radek Krejci4f28eda2018-11-12 11:46:16 +01001336 lysp_node_free(ctx.ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001337
1338 TEST_DUP("config", "true", "false");
1339 TEST_DUP("description", "text1", "text2");
1340 TEST_DUP("presence", "true", "false");
1341 TEST_DUP("reference", "1", "2");
1342 TEST_DUP("status", "current", "obsolete");
1343 TEST_DUP("when", "true", "false");
1344#undef TEST_DUP
1345
1346 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001347 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 +01001348 "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 Vasko63f3d842020-07-08 10:10:14 +02001349 assert_int_equal(LY_SUCCESS, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001350 assert_non_null(c);
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001351 assert_int_equal(LYS_CONTAINER, c->nodetype);
1352 assert_string_equal("cont", c->name);
Radek Krejci8c370832018-11-02 15:10:03 +01001353 assert_non_null(c->actions);
1354 assert_non_null(c->child);
1355 assert_string_equal("test", c->dsc);
1356 assert_non_null(c->exts);
1357 assert_non_null(c->groupings);
1358 assert_non_null(c->iffeatures);
1359 assert_non_null(c->musts);
1360 assert_non_null(c->notifs);
1361 assert_string_equal("true", c->presence);
1362 assert_string_equal("test", c->ref);
1363 assert_non_null(c->typedefs);
1364 assert_non_null(c->when);
1365 assert_null(c->parent);
1366 assert_null(c->next);
1367 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR, c->flags);
Radek Krejci313d9902018-11-08 09:42:58 +01001368 ly_set_erase(&ctx.tpdfs_nodes, NULL);
Radek Krejci4f28eda2018-11-12 11:46:16 +01001369 lysp_node_free(ctx.ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001370
1371 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001372 in.current = " cont {augment /root;} ...";
1373 assert_int_equal(LY_EVALID, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001374 logbuf_assert("Invalid keyword \"augment\" as a child of \"container\". Line number 1.");
Radek Krejci4f28eda2018-11-12 11:46:16 +01001375 lysp_node_free(ctx.ctx, (struct lysp_node*)c); c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001376 in.current = " cont {nonsence true;} ...";
1377 assert_int_equal(LY_EVALID, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejci8c370832018-11-02 15:10:03 +01001378 logbuf_assert("Invalid character sequence \"nonsence\", expected a keyword. Line number 1.");
Radek Krejci4f28eda2018-11-12 11:46:16 +01001379 lysp_node_free(ctx.ctx, (struct lysp_node*)c); c = NULL;
Radek Krejci8c370832018-11-02 15:10:03 +01001380
Radek Krejcif538ce52019-03-05 10:46:14 +01001381 ctx.mod_version = 1; /* simulate YANG 1.0 */
Michal Vasko63f3d842020-07-08 10:10:14 +02001382 in.current = " cont {action x;} ...";
1383 assert_int_equal(LY_EVALID, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
Radek Krejcif538ce52019-03-05 10:46:14 +01001384 logbuf_assert("Invalid keyword \"action\" as a child of \"container\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
1385 lysp_node_free(ctx.ctx, (struct lysp_node*)c); c = NULL;
1386
Radek Krejci8c370832018-11-02 15:10:03 +01001387 ly_ctx_destroy(ctx.ctx, NULL);
1388}
1389
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001390static void
1391test_leaf(void **state)
1392{
1393 *state = test_leaf;
1394
Michal Vaskob36053d2020-03-26 15:49:30 +01001395 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001396 struct lysp_node_leaf *l = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001397 struct ly_in in = {0};
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001398
Michal Vaskob36053d2020-03-26 15:49:30 +01001399 ctx.format = LYS_IN_YANG;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001400 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1401 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001402 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001403 ctx.line = 1;
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001404 //ctx.mod->version = 2; /* simulate YANG 1.1 */
1405
1406 /* invalid cardinality */
1407#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001408 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1409 assert_int_equal(LY_EVALID, parse_leaf(&ctx, &in, NULL, (struct lysp_node**)&l)); \
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001410 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1411 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1412
1413 TEST_DUP("config", "true", "false");
1414 TEST_DUP("default", "x", "y");
1415 TEST_DUP("description", "text1", "text2");
1416 TEST_DUP("mandatory", "true", "false");
1417 TEST_DUP("reference", "1", "2");
1418 TEST_DUP("status", "current", "obsolete");
Radek Krejci0e5d8382018-11-28 16:37:53 +01001419 TEST_DUP("type", "int8", "uint8");
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001420 TEST_DUP("units", "text1", "text2");
1421 TEST_DUP("when", "true", "false");
1422#undef TEST_DUP
1423
1424 /* full content - without mandatory which is mutual exclusive with default */
Michal Vasko63f3d842020-07-08 10:10:14 +02001425 in.current = "l {config false;default \"xxx\";description test;if-feature f;"
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001426 "must 'expr';reference test;status current;type string; units yyy;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001427 assert_int_equal(LY_SUCCESS, parse_leaf(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001428 assert_non_null(l);
1429 assert_int_equal(LYS_LEAF, l->nodetype);
1430 assert_string_equal("l", l->name);
1431 assert_string_equal("test", l->dsc);
1432 assert_string_equal("xxx", l->dflt);
1433 assert_string_equal("yyy", l->units);
1434 assert_string_equal("string", l->type.name);
1435 assert_non_null(l->exts);
1436 assert_non_null(l->iffeatures);
1437 assert_non_null(l->musts);
1438 assert_string_equal("test", l->ref);
1439 assert_non_null(l->when);
1440 assert_null(l->parent);
1441 assert_null(l->next);
1442 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR, l->flags);
1443 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1444
1445 /* full content - now with mandatory */
Michal Vasko63f3d842020-07-08 10:10:14 +02001446 in.current = "l {mandatory true; type string;} ...";
1447 assert_int_equal(LY_SUCCESS, parse_leaf(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001448 assert_non_null(l);
1449 assert_int_equal(LYS_LEAF, l->nodetype);
1450 assert_string_equal("l", l->name);
1451 assert_string_equal("string", l->type.name);
1452 assert_int_equal(LYS_MAND_TRUE, l->flags);
1453 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1454
1455 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001456 in.current = " l {mandatory true; default xx; type string;} ...";
1457 assert_int_equal(LY_EVALID, parse_leaf(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001458 logbuf_assert("Invalid combination of keywords \"mandatory\" and \"default\" as substatements of \"leaf\". Line number 1.");
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001459 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1460
Michal Vasko63f3d842020-07-08 10:10:14 +02001461 in.current = " l {description \"missing type\";} ...";
1462 assert_int_equal(LY_EVALID, parse_leaf(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01001463 logbuf_assert("Missing mandatory keyword \"type\" as a child of \"leaf\". Line number 1.");
1464 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1465
1466 *state = NULL;
1467 ly_ctx_destroy(ctx.ctx, NULL);
1468}
1469
Radek Krejci0e5d8382018-11-28 16:37:53 +01001470static void
1471test_leaflist(void **state)
1472{
1473 *state = test_leaf;
1474
Michal Vaskob36053d2020-03-26 15:49:30 +01001475 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci0e5d8382018-11-28 16:37:53 +01001476 struct lysp_node_leaflist *ll = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001477 struct ly_in in = {0};
Radek Krejci0e5d8382018-11-28 16:37:53 +01001478
Michal Vaskob36053d2020-03-26 15:49:30 +01001479 ctx.format = LYS_IN_YANG;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001480 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1481 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001482 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci0e5d8382018-11-28 16:37:53 +01001483 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001484 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci0e5d8382018-11-28 16:37:53 +01001485
1486 /* invalid cardinality */
1487#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001488 in.current = "ll {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1489 assert_int_equal(LY_EVALID, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll)); \
Radek Krejci0e5d8382018-11-28 16:37:53 +01001490 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1491 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1492
1493 TEST_DUP("config", "true", "false");
1494 TEST_DUP("description", "text1", "text2");
1495 TEST_DUP("max-elements", "10", "20");
1496 TEST_DUP("min-elements", "10", "20");
1497 TEST_DUP("ordered-by", "user", "system");
1498 TEST_DUP("reference", "1", "2");
1499 TEST_DUP("status", "current", "obsolete");
1500 TEST_DUP("type", "int8", "uint8");
1501 TEST_DUP("units", "text1", "text2");
1502 TEST_DUP("when", "true", "false");
1503#undef TEST_DUP
1504
1505 /* full content - without min-elements which is mutual exclusive with default */
Michal Vasko63f3d842020-07-08 10:10:14 +02001506 in.current = "ll {config false;default \"xxx\"; default \"yyy\";description test;if-feature f;"
Radek Krejci0e5d8382018-11-28 16:37:53 +01001507 "max-elements 10;must 'expr';ordered-by user;reference test;"
1508 "status current;type string; units zzz;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001509 assert_int_equal(LY_SUCCESS, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001510 assert_non_null(ll);
1511 assert_int_equal(LYS_LEAFLIST, ll->nodetype);
1512 assert_string_equal("ll", ll->name);
1513 assert_string_equal("test", ll->dsc);
1514 assert_non_null(ll->dflts);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001515 assert_int_equal(2, LY_ARRAY_COUNT(ll->dflts));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001516 assert_string_equal("xxx", ll->dflts[0]);
1517 assert_string_equal("yyy", ll->dflts[1]);
1518 assert_string_equal("zzz", ll->units);
1519 assert_int_equal(10, ll->max);
1520 assert_int_equal(0, ll->min);
1521 assert_string_equal("string", ll->type.name);
1522 assert_non_null(ll->exts);
1523 assert_non_null(ll->iffeatures);
1524 assert_non_null(ll->musts);
1525 assert_string_equal("test", ll->ref);
1526 assert_non_null(ll->when);
1527 assert_null(ll->parent);
1528 assert_null(ll->next);
1529 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_USER | LYS_SET_MAX, ll->flags);
1530 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1531
1532 /* full content - now with min-elements */
Michal Vasko63f3d842020-07-08 10:10:14 +02001533 in.current = "ll {min-elements 10; type string;} ...";
1534 assert_int_equal(LY_SUCCESS, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001535 assert_non_null(ll);
1536 assert_int_equal(LYS_LEAFLIST, ll->nodetype);
1537 assert_string_equal("ll", ll->name);
1538 assert_string_equal("string", ll->type.name);
1539 assert_int_equal(0, ll->max);
1540 assert_int_equal(10, ll->min);
1541 assert_int_equal(LYS_SET_MIN, ll->flags);
1542 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1543
1544 /* invalid */
Michal Vasko63f3d842020-07-08 10:10:14 +02001545 in.current = " ll {min-elements 1; default xx; type string;} ...";
1546 assert_int_equal(LY_EVALID, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001547 logbuf_assert("Invalid combination of keywords \"min-elements\" and \"default\" as substatements of \"leaf-list\". Line number 1.");
Radek Krejci0e5d8382018-11-28 16:37:53 +01001548 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1549
Michal Vasko63f3d842020-07-08 10:10:14 +02001550 in.current = " ll {description \"missing type\";} ...";
1551 assert_int_equal(LY_EVALID, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001552 logbuf_assert("Missing mandatory keyword \"type\" as a child of \"leaf-list\". Line number 1.");
1553 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1554
Michal Vasko63f3d842020-07-08 10:10:14 +02001555 in.current = " ll {type string; min-elements 10; max-elements 1;} ..."; /* invalid combination of min/max */
1556 assert_int_equal(LY_EVALID, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejcidf6cad12018-11-28 17:10:55 +01001557 logbuf_assert("Invalid combination of min-elements and max-elements: min value 10 is bigger than the max value 1. Line number 1.");
1558 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1559
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001560 ctx.mod_version = 1; /* simulate YANG 1.0 - default statement is not allowed */
Michal Vasko63f3d842020-07-08 10:10:14 +02001561 in.current = " ll {default xx; type string;} ...";
1562 assert_int_equal(LY_EVALID, parse_leaflist(&ctx, &in, NULL, (struct lysp_node**)&ll));
Radek Krejci0e5d8382018-11-28 16:37:53 +01001563 logbuf_assert("Invalid keyword \"default\" as a child of \"leaf-list\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
1564 lysp_node_free(ctx.ctx, (struct lysp_node*)ll); ll = NULL;
1565
1566 *state = NULL;
1567 ly_ctx_destroy(ctx.ctx, NULL);
1568}
1569
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001570static void
1571test_list(void **state)
1572{
1573 *state = test_list;
1574
Michal Vaskob36053d2020-03-26 15:49:30 +01001575 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001576 struct lysp_node_list *l = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001577 struct ly_in in = {0};
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001578
Michal Vaskob36053d2020-03-26 15:49:30 +01001579 ctx.format = LYS_IN_YANG;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001580 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1581 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001582 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001583 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001584 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001585
1586 /* invalid cardinality */
1587#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001588 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1589 assert_int_equal(LY_EVALID, parse_list(&ctx, &in, NULL, (struct lysp_node**)&l)); \
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001590 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1591 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1592
1593 TEST_DUP("config", "true", "false");
1594 TEST_DUP("description", "text1", "text2");
1595 TEST_DUP("key", "one", "two");
1596 TEST_DUP("max-elements", "10", "20");
1597 TEST_DUP("min-elements", "10", "20");
1598 TEST_DUP("ordered-by", "user", "system");
1599 TEST_DUP("reference", "1", "2");
1600 TEST_DUP("status", "current", "obsolete");
1601 TEST_DUP("when", "true", "false");
1602#undef TEST_DUP
1603
1604 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001605 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 +01001606 "leaf-list ll {type string;} list li;max-elements 10; min-elements 1;must 'expr';notification not; ordered-by system; reference test;"
1607 "status current;typedef t {type int8;}unique xxx;unique yyy;uses g;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001608 assert_int_equal(LY_SUCCESS, parse_list(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001609 assert_non_null(l);
1610 assert_int_equal(LYS_LIST, l->nodetype);
1611 assert_string_equal("l", l->name);
1612 assert_string_equal("test", l->dsc);
1613 assert_string_equal("l", l->key);
1614 assert_non_null(l->uniques);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001615 assert_int_equal(2, LY_ARRAY_COUNT(l->uniques));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001616 assert_string_equal("xxx", l->uniques[0]);
1617 assert_string_equal("yyy", l->uniques[1]);
1618 assert_int_equal(10, l->max);
1619 assert_int_equal(1, l->min);
1620 assert_non_null(l->exts);
1621 assert_non_null(l->iffeatures);
1622 assert_non_null(l->musts);
1623 assert_string_equal("test", l->ref);
1624 assert_non_null(l->when);
1625 assert_null(l->parent);
1626 assert_null(l->next);
1627 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_MAX | LYS_SET_MIN, l->flags);
1628 ly_set_erase(&ctx.tpdfs_nodes, NULL);
1629 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1630
Radek Krejcif538ce52019-03-05 10:46:14 +01001631 /* invalid content */
1632 ctx.mod_version = 1; /* simulate YANG 1.0 */
Michal Vasko63f3d842020-07-08 10:10:14 +02001633 in.current = "l {action x;} ...";
1634 assert_int_equal(LY_EVALID, parse_list(&ctx, &in, NULL, (struct lysp_node**)&l));
Radek Krejcif538ce52019-03-05 10:46:14 +01001635 logbuf_assert("Invalid keyword \"action\" as a child of \"list\" - the statement is allowed only in YANG 1.1 modules. Line number 1.");
1636 lysp_node_free(ctx.ctx, (struct lysp_node*)l); l = NULL;
1637
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001638 *state = NULL;
1639 ly_ctx_destroy(ctx.ctx, NULL);
1640}
1641
Radek Krejci056d0a82018-12-06 16:57:25 +01001642static void
1643test_choice(void **state)
1644{
1645 *state = test_choice;
1646
Michal Vaskob36053d2020-03-26 15:49:30 +01001647 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci056d0a82018-12-06 16:57:25 +01001648 struct lysp_node_choice *ch = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001649 struct ly_in in = {0};
Radek Krejci056d0a82018-12-06 16:57:25 +01001650
Michal Vaskob36053d2020-03-26 15:49:30 +01001651 ctx.format = LYS_IN_YANG;
Radek Krejci056d0a82018-12-06 16:57:25 +01001652 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1653 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001654 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci056d0a82018-12-06 16:57:25 +01001655 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001656 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci056d0a82018-12-06 16:57:25 +01001657
1658 /* invalid cardinality */
1659#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001660 in.current = "ch {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1661 assert_int_equal(LY_EVALID, parse_choice(&ctx, &in, NULL, (struct lysp_node**)&ch)); \
Radek Krejci056d0a82018-12-06 16:57:25 +01001662 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1663 lysp_node_free(ctx.ctx, (struct lysp_node*)ch); ch = NULL;
1664
1665 TEST_DUP("config", "true", "false");
1666 TEST_DUP("default", "a", "b");
1667 TEST_DUP("description", "text1", "text2");
1668 TEST_DUP("mandatory", "true", "false");
1669 TEST_DUP("reference", "1", "2");
1670 TEST_DUP("status", "current", "obsolete");
1671 TEST_DUP("when", "true", "false");
1672#undef TEST_DUP
1673
Radek Krejcia9026eb2018-12-12 16:04:47 +01001674 /* full content - without default due to a collision with mandatory */
Michal Vasko63f3d842020-07-08 10:10:14 +02001675 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 +01001676 "leaf-list ll {type string;} list li;mandatory true;reference test;status current;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001677 assert_int_equal(LY_SUCCESS, parse_choice(&ctx, &in, NULL, (struct lysp_node**)&ch));
Radek Krejci056d0a82018-12-06 16:57:25 +01001678 assert_non_null(ch);
1679 assert_int_equal(LYS_CHOICE, ch->nodetype);
1680 assert_string_equal("ch", ch->name);
1681 assert_string_equal("test", ch->dsc);
1682 assert_non_null(ch->exts);
1683 assert_non_null(ch->iffeatures);
1684 assert_string_equal("test", ch->ref);
1685 assert_non_null(ch->when);
1686 assert_null(ch->parent);
1687 assert_null(ch->next);
1688 assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_MAND_TRUE, ch->flags);
1689 lysp_node_free(ctx.ctx, (struct lysp_node*)ch); ch = NULL;
1690
Radek Krejcia9026eb2018-12-12 16:04:47 +01001691 /* full content - the default missing from the previous node */
Michal Vasko63f3d842020-07-08 10:10:14 +02001692 in.current = "ch {default c;case c;} ...";
1693 assert_int_equal(LY_SUCCESS, parse_choice(&ctx, &in, NULL, (struct lysp_node**)&ch));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001694 assert_non_null(ch);
1695 assert_int_equal(LYS_CHOICE, ch->nodetype);
1696 assert_string_equal("ch", ch->name);
1697 assert_string_equal("c", ch->dflt);
1698 assert_int_equal(0, ch->flags);
1699 lysp_node_free(ctx.ctx, (struct lysp_node*)ch); ch = NULL;
1700
1701 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001702 in.current = "ch {mandatory true; default c1; case c1 {leaf x{type string;}}} ...";
1703 assert_int_equal(LY_EVALID, parse_choice(&ctx, &in, NULL, (struct lysp_node**)&ch));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001704 logbuf_assert("Invalid combination of keywords \"mandatory\" and \"default\" as substatements of \"choice\". Line number 1.");
1705 lysp_node_free(ctx.ctx, (struct lysp_node*)ch); ch = NULL;
1706
1707 *state = NULL;
1708 ly_ctx_destroy(ctx.ctx, NULL);
1709}
1710
1711static void
1712test_case(void **state)
1713{
1714 *state = test_case;
1715
Michal Vaskob36053d2020-03-26 15:49:30 +01001716 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcia9026eb2018-12-12 16:04:47 +01001717 struct lysp_node_case *cs = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001718 struct ly_in in = {0};
Radek Krejcia9026eb2018-12-12 16:04:47 +01001719
Michal Vaskob36053d2020-03-26 15:49:30 +01001720 ctx.format = LYS_IN_YANG;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001721 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1722 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001723 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcia9026eb2018-12-12 16:04:47 +01001724 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001725 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejcia9026eb2018-12-12 16:04:47 +01001726
1727 /* invalid cardinality */
1728#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001729 in.current = "cs {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1730 assert_int_equal(LY_EVALID, parse_case(&ctx, &in, NULL, (struct lysp_node**)&cs)); \
Radek Krejcia9026eb2018-12-12 16:04:47 +01001731 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1732 lysp_node_free(ctx.ctx, (struct lysp_node*)cs); cs = NULL;
1733
1734 TEST_DUP("description", "text1", "text2");
1735 TEST_DUP("reference", "1", "2");
1736 TEST_DUP("status", "current", "obsolete");
1737 TEST_DUP("when", "true", "false");
1738#undef TEST_DUP
1739
1740 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001741 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 +01001742 "leaf-list ll {type string;} list li;reference test;status current;uses grp;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001743 assert_int_equal(LY_SUCCESS, parse_case(&ctx, &in, NULL, (struct lysp_node**)&cs));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001744 assert_non_null(cs);
1745 assert_int_equal(LYS_CASE, cs->nodetype);
1746 assert_string_equal("cs", cs->name);
1747 assert_string_equal("test", cs->dsc);
1748 assert_non_null(cs->exts);
1749 assert_non_null(cs->iffeatures);
1750 assert_string_equal("test", cs->ref);
1751 assert_non_null(cs->when);
1752 assert_null(cs->parent);
1753 assert_null(cs->next);
1754 assert_int_equal(LYS_STATUS_CURR, cs->flags);
1755 lysp_node_free(ctx.ctx, (struct lysp_node*)cs); cs = NULL;
1756
1757 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001758 in.current = "cs {config true} ...";
1759 assert_int_equal(LY_EVALID, parse_case(&ctx, &in, NULL, (struct lysp_node**)&cs));
Radek Krejcia9026eb2018-12-12 16:04:47 +01001760 logbuf_assert("Invalid keyword \"config\" as a child of \"case\". Line number 1.");
1761 lysp_node_free(ctx.ctx, (struct lysp_node*)cs); cs = NULL;
1762
Radek Krejci056d0a82018-12-06 16:57:25 +01001763 *state = NULL;
1764 ly_ctx_destroy(ctx.ctx, NULL);
1765}
1766
Radek Krejci9800fb82018-12-13 14:26:23 +01001767static void
Radek Krejcid6b76452019-09-03 17:03:03 +02001768test_any(void **state, enum ly_stmt kw)
Radek Krejci9800fb82018-12-13 14:26:23 +01001769{
1770 *state = test_any;
1771
Michal Vaskob36053d2020-03-26 15:49:30 +01001772 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci9800fb82018-12-13 14:26:23 +01001773 struct lysp_node_anydata *any = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001774 struct ly_in in = {0};
Radek Krejci9800fb82018-12-13 14:26:23 +01001775
Michal Vaskob36053d2020-03-26 15:49:30 +01001776 ctx.format = LYS_IN_YANG;
Radek Krejci9800fb82018-12-13 14:26:23 +01001777 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1778 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001779 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci9800fb82018-12-13 14:26:23 +01001780 ctx.line = 1;
Radek Krejcid6b76452019-09-03 17:03:03 +02001781 if (kw == LY_STMT_ANYDATA) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001782 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci9800fb82018-12-13 14:26:23 +01001783 } else {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001784 ctx.mod_version = 1; /* simulate YANG 1.0 */
Radek Krejci9800fb82018-12-13 14:26:23 +01001785 }
1786
1787 /* invalid cardinality */
1788#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001789 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1790 assert_int_equal(LY_EVALID, parse_any(&ctx, &in, kw, NULL, (struct lysp_node**)&any)); \
Radek Krejci9800fb82018-12-13 14:26:23 +01001791 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1792 lysp_node_free(ctx.ctx, (struct lysp_node*)any); any = NULL;
1793
1794 TEST_DUP("config", "true", "false");
1795 TEST_DUP("description", "text1", "text2");
1796 TEST_DUP("mandatory", "true", "false");
1797 TEST_DUP("reference", "1", "2");
1798 TEST_DUP("status", "current", "obsolete");
1799 TEST_DUP("when", "true", "false");
1800#undef TEST_DUP
1801
1802 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001803 in.current = "any {config true;description test;if-feature f;mandatory true;must 'expr';reference test;status current;when true;m:ext;} ...";
1804 assert_int_equal(LY_SUCCESS, parse_any(&ctx, &in, kw, NULL, (struct lysp_node**)&any));
Radek Krejci9800fb82018-12-13 14:26:23 +01001805 assert_non_null(any);
Radek Krejcid6b76452019-09-03 17:03:03 +02001806 assert_int_equal(kw == LY_STMT_ANYDATA ? LYS_ANYDATA : LYS_ANYXML, any->nodetype);
Radek Krejci9800fb82018-12-13 14:26:23 +01001807 assert_string_equal("any", any->name);
1808 assert_string_equal("test", any->dsc);
1809 assert_non_null(any->exts);
1810 assert_non_null(any->iffeatures);
1811 assert_non_null(any->musts);
1812 assert_string_equal("test", any->ref);
1813 assert_non_null(any->when);
1814 assert_null(any->parent);
1815 assert_null(any->next);
1816 assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR | LYS_MAND_TRUE, any->flags);
1817 lysp_node_free(ctx.ctx, (struct lysp_node*)any); any = NULL;
1818
1819 *state = NULL;
1820 ly_ctx_destroy(ctx.ctx, NULL);
1821}
1822
1823static void
1824test_anydata(void **state)
1825{
Radek Krejcid6b76452019-09-03 17:03:03 +02001826 return test_any(state, LY_STMT_ANYDATA);
Radek Krejci9800fb82018-12-13 14:26:23 +01001827}
1828
1829static void
1830test_anyxml(void **state)
1831{
Radek Krejcid6b76452019-09-03 17:03:03 +02001832 return test_any(state, LY_STMT_ANYXML);
Radek Krejci9800fb82018-12-13 14:26:23 +01001833}
1834
Radek Krejcie86bf772018-12-14 11:39:53 +01001835static void
1836test_grouping(void **state)
1837{
1838 *state = test_grouping;
1839
Michal Vaskob36053d2020-03-26 15:49:30 +01001840 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01001841 struct lysp_grp *grp = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001842 struct ly_in in = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01001843
Michal Vaskob36053d2020-03-26 15:49:30 +01001844 ctx.format = LYS_IN_YANG;
Radek Krejcie86bf772018-12-14 11:39:53 +01001845 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1846 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001847 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcie86bf772018-12-14 11:39:53 +01001848 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001849 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejcie86bf772018-12-14 11:39:53 +01001850
1851 /* invalid cardinality */
1852#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001853 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1854 assert_int_equal(LY_EVALID, parse_grouping(&ctx, &in, NULL, &grp)); \
Radek Krejcie86bf772018-12-14 11:39:53 +01001855 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1856 FREE_ARRAY(ctx.ctx, grp, lysp_grp_free); grp = NULL;
1857
1858 TEST_DUP("description", "text1", "text2");
1859 TEST_DUP("reference", "1", "2");
1860 TEST_DUP("status", "current", "obsolete");
1861#undef TEST_DUP
1862
1863 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001864 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 +01001865 "leaf-list ll {type string;} list li;notification not;reference test;status current;typedef t {type int8;}uses g;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001866 assert_int_equal(LY_SUCCESS, parse_grouping(&ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001867 assert_non_null(grp);
1868 assert_int_equal(LYS_GROUPING, grp->nodetype);
1869 assert_string_equal("grp", grp->name);
1870 assert_string_equal("test", grp->dsc);
1871 assert_non_null(grp->exts);
1872 assert_string_equal("test", grp->ref);
1873 assert_null(grp->parent);
1874 assert_int_equal( LYS_STATUS_CURR, grp->flags);
1875 ly_set_erase(&ctx.tpdfs_nodes, NULL);
1876 FREE_ARRAY(ctx.ctx, grp, lysp_grp_free); grp = NULL;
1877
1878 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001879 in.current = "grp {config true} ...";
1880 assert_int_equal(LY_EVALID, parse_grouping(&ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001881 logbuf_assert("Invalid keyword \"config\" as a child of \"grouping\". Line number 1.");
1882 FREE_ARRAY(ctx.ctx, grp, lysp_grp_free); grp = NULL;
1883
Michal Vasko63f3d842020-07-08 10:10:14 +02001884 in.current = "grp {must 'expr'} ...";
1885 assert_int_equal(LY_EVALID, parse_grouping(&ctx, &in, NULL, &grp));
Radek Krejcie86bf772018-12-14 11:39:53 +01001886 logbuf_assert("Invalid keyword \"must\" as a child of \"grouping\". Line number 1.");
1887 FREE_ARRAY(ctx.ctx, grp, lysp_grp_free); grp = NULL;
1888
1889 *state = NULL;
1890 ly_ctx_destroy(ctx.ctx, NULL);
1891}
1892
1893static void
Radek Krejcif538ce52019-03-05 10:46:14 +01001894test_action(void **state)
1895{
1896 *state = test_action;
1897
Michal Vaskob36053d2020-03-26 15:49:30 +01001898 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcif538ce52019-03-05 10:46:14 +01001899 struct lysp_action *rpcs = NULL;
1900 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001901 struct ly_in in = {0};
Radek Krejcif538ce52019-03-05 10:46:14 +01001902
Michal Vaskob36053d2020-03-26 15:49:30 +01001903 ctx.format = LYS_IN_YANG;
Radek Krejcif538ce52019-03-05 10:46:14 +01001904 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1905 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001906 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcif538ce52019-03-05 10:46:14 +01001907 ctx.line = 1;
1908 ctx.mod_version = 2; /* simulate YANG 1.1 */
1909
1910 /* invalid cardinality */
1911#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001912 in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1913 assert_int_equal(LY_EVALID, parse_action(&ctx, &in, NULL, &rpcs)); \
Radek Krejcif538ce52019-03-05 10:46:14 +01001914 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1915 FREE_ARRAY(ctx.ctx, rpcs, lysp_action_free); rpcs = NULL;
1916
1917 TEST_DUP("description", "text1", "text2");
Michal Vaskob83af8a2020-01-06 09:49:22 +01001918 TEST_DUP("input", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a");
1919 TEST_DUP("output", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a");
Radek Krejcif538ce52019-03-05 10:46:14 +01001920 TEST_DUP("reference", "1", "2");
1921 TEST_DUP("status", "current", "obsolete");
1922#undef TEST_DUP
1923
1924 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001925 in.current = "top;";
1926 assert_int_equal(LY_SUCCESS, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
1927 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 +01001928 "input {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}"
1929 " list li; must 1; typedef mytypei {type int8;} uses grp; m:ext;}"
1930 "output {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}"
1931 " list li; must 1; typedef mytypeo {type int8;} uses grp; m:ext;}} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02001932 assert_int_equal(LY_SUCCESS, parse_action(&ctx, &in, (struct lysp_node*)c, &rpcs));
Radek Krejcif538ce52019-03-05 10:46:14 +01001933 assert_non_null(rpcs);
1934 assert_int_equal(LYS_ACTION, rpcs->nodetype);
1935 assert_string_equal("func", rpcs->name);
1936 assert_string_equal("test", rpcs->dsc);
1937 assert_non_null(rpcs->exts);
1938 assert_non_null(rpcs->iffeatures);
1939 assert_string_equal("test", rpcs->ref);
1940 assert_non_null(rpcs->groupings);
1941 assert_non_null(rpcs->typedefs);
1942 assert_int_equal(LYS_STATUS_CURR, rpcs->flags);
1943 /* input */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001944 assert_int_equal(rpcs->input.nodetype, LYS_INPUT);
Radek Krejcif538ce52019-03-05 10:46:14 +01001945 assert_non_null(rpcs->input.groupings);
1946 assert_non_null(rpcs->input.exts);
1947 assert_non_null(rpcs->input.musts);
1948 assert_non_null(rpcs->input.typedefs);
1949 assert_non_null(rpcs->input.data);
1950 /* output */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001951 assert_int_equal(rpcs->output.nodetype, LYS_OUTPUT);
Radek Krejcif538ce52019-03-05 10:46:14 +01001952 assert_non_null(rpcs->output.groupings);
1953 assert_non_null(rpcs->output.exts);
1954 assert_non_null(rpcs->output.musts);
1955 assert_non_null(rpcs->output.typedefs);
1956 assert_non_null(rpcs->output.data);
1957
1958 ly_set_erase(&ctx.tpdfs_nodes, NULL);
1959 FREE_ARRAY(ctx.ctx, rpcs, lysp_action_free); rpcs = NULL;
1960
1961 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02001962 in.current = "func {config true} ...";
1963 assert_int_equal(LY_EVALID, parse_action(&ctx, &in, NULL, &rpcs));
Radek Krejcif538ce52019-03-05 10:46:14 +01001964 logbuf_assert("Invalid keyword \"config\" as a child of \"rpc\". Line number 1.");
1965 FREE_ARRAY(ctx.ctx, rpcs, lysp_action_free); rpcs = NULL;
1966
1967 *state = NULL;
1968 lysp_node_free(ctx.ctx, (struct lysp_node*)c);
1969 ly_ctx_destroy(ctx.ctx, NULL);
1970}
1971
1972static void
Radek Krejcifc11bd72019-04-11 16:00:05 +02001973test_notification(void **state)
1974{
1975 *state = test_notification;
1976
Michal Vaskob36053d2020-03-26 15:49:30 +01001977 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcifc11bd72019-04-11 16:00:05 +02001978 struct lysp_notif *notifs = NULL;
1979 struct lysp_node_container *c = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02001980 struct ly_in in = {0};
Radek Krejcifc11bd72019-04-11 16:00:05 +02001981
Michal Vaskob36053d2020-03-26 15:49:30 +01001982 ctx.format = LYS_IN_YANG;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001983 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
1984 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02001985 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001986 ctx.line = 1;
1987 ctx.mod_version = 2; /* simulate YANG 1.1 */
1988
1989 /* invalid cardinality */
1990#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02001991 in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
1992 assert_int_equal(LY_EVALID, parse_notif(&ctx, &in, NULL, &notifs)); \
Radek Krejcifc11bd72019-04-11 16:00:05 +02001993 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
1994 FREE_ARRAY(ctx.ctx, notifs, lysp_notif_free); notifs = NULL;
1995
1996 TEST_DUP("description", "text1", "text2");
1997 TEST_DUP("reference", "1", "2");
1998 TEST_DUP("status", "current", "obsolete");
1999#undef TEST_DUP
2000
2001 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02002002 in.current = "top;";
2003 assert_int_equal(LY_SUCCESS, parse_container(&ctx, &in, NULL, (struct lysp_node**)&c));
2004 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 +02002005 "leaf-list ll {type int8;} list li; must 1; reference test; status current; typedef mytype {type int8;} uses grp; m:ext;}";
Michal Vasko63f3d842020-07-08 10:10:14 +02002006 assert_int_equal(LY_SUCCESS, parse_notif(&ctx, &in, (struct lysp_node*)c, &notifs));
Radek Krejcifc11bd72019-04-11 16:00:05 +02002007 assert_non_null(notifs);
2008 assert_int_equal(LYS_NOTIF, notifs->nodetype);
2009 assert_string_equal("ntf", notifs->name);
2010 assert_string_equal("test", notifs->dsc);
2011 assert_non_null(notifs->exts);
2012 assert_non_null(notifs->iffeatures);
2013 assert_string_equal("test", notifs->ref);
2014 assert_non_null(notifs->groupings);
2015 assert_non_null(notifs->typedefs);
2016 assert_non_null(notifs->musts);
2017 assert_non_null(notifs->data);
2018 assert_int_equal(LYS_STATUS_CURR, notifs->flags);
2019
2020 ly_set_erase(&ctx.tpdfs_nodes, NULL);
2021 FREE_ARRAY(ctx.ctx, notifs, lysp_notif_free); notifs = NULL;
2022
2023 /* invalid content */
Michal Vasko63f3d842020-07-08 10:10:14 +02002024 in.current = "ntf {config true} ...";
2025 assert_int_equal(LY_EVALID, parse_notif(&ctx, &in, NULL, &notifs));
Radek Krejcifc11bd72019-04-11 16:00:05 +02002026 logbuf_assert("Invalid keyword \"config\" as a child of \"notification\". Line number 1.");
2027 FREE_ARRAY(ctx.ctx, notifs, lysp_notif_free); notifs = NULL;
2028
2029 *state = NULL;
2030 lysp_node_free(ctx.ctx, (struct lysp_node*)c);
2031 ly_ctx_destroy(ctx.ctx, NULL);
2032}
2033
2034static void
Radek Krejcie86bf772018-12-14 11:39:53 +01002035test_uses(void **state)
2036{
2037 *state = test_uses;
2038
Michal Vaskob36053d2020-03-26 15:49:30 +01002039 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01002040 struct lysp_node_uses *u = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02002041 struct ly_in in = {0};
Radek Krejcie86bf772018-12-14 11:39:53 +01002042
Michal Vaskob36053d2020-03-26 15:49:30 +01002043 ctx.format = LYS_IN_YANG;
Radek Krejcie86bf772018-12-14 11:39:53 +01002044 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
2045 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02002046 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcie86bf772018-12-14 11:39:53 +01002047 ctx.line = 1;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002048 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejcie86bf772018-12-14 11:39:53 +01002049
2050 /* invalid cardinality */
2051#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02002052 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
2053 assert_int_equal(LY_EVALID, parse_uses(&ctx, &in, NULL, (struct lysp_node**)&u)); \
Radek Krejcie86bf772018-12-14 11:39:53 +01002054 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
2055 lysp_node_free(ctx.ctx, (struct lysp_node*)u); u = NULL;
2056
2057 TEST_DUP("description", "text1", "text2");
2058 TEST_DUP("reference", "1", "2");
2059 TEST_DUP("status", "current", "obsolete");
2060 TEST_DUP("when", "true", "false");
2061#undef TEST_DUP
2062
2063 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02002064 in.current = "grpref {augment some/node;description test;if-feature f;reference test;refine some/other/node;status current;when true;m:ext;} ...";
2065 assert_int_equal(LY_SUCCESS, parse_uses(&ctx, &in, NULL, (struct lysp_node**)&u));
Radek Krejcie86bf772018-12-14 11:39:53 +01002066 assert_non_null(u);
2067 assert_int_equal(LYS_USES, u->nodetype);
2068 assert_string_equal("grpref", u->name);
2069 assert_string_equal("test", u->dsc);
2070 assert_non_null(u->exts);
2071 assert_non_null(u->iffeatures);
2072 assert_string_equal("test", u->ref);
2073 assert_non_null(u->augments);
2074 assert_non_null(u->refines);
2075 assert_non_null(u->when);
2076 assert_null(u->parent);
2077 assert_null(u->next);
2078 assert_int_equal(LYS_STATUS_CURR, u->flags);
2079 lysp_node_free(ctx.ctx, (struct lysp_node*)u); u = NULL;
2080
2081 *state = NULL;
2082 ly_ctx_destroy(ctx.ctx, NULL);
2083}
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002084
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002085static void
2086test_augment(void **state)
2087{
2088 *state = test_augment;
2089
Michal Vaskob36053d2020-03-26 15:49:30 +01002090 struct lys_yang_parser_ctx ctx = {0};
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002091 struct lysp_augment *a = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02002092 struct ly_in in = {0};
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002093
Michal Vaskob36053d2020-03-26 15:49:30 +01002094 ctx.format = LYS_IN_YANG;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002095 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
2096 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02002097 ctx.pos_type = LY_VLOG_LINE;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002098 ctx.line = 1;
Radek Krejcib4adbf12019-02-25 13:35:22 +01002099 ctx.mod_version = 2; /* simulate YANG 1.1 */
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002100
2101 /* invalid cardinality */
2102#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02002103 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
2104 assert_int_equal(LY_EVALID, parse_augment(&ctx, &in, NULL, &a)); \
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002105 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
Radek Krejcib4adbf12019-02-25 13:35:22 +01002106 FREE_ARRAY(ctx.ctx, a, lysp_augment_free); a = NULL;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002107
2108 TEST_DUP("description", "text1", "text2");
2109 TEST_DUP("reference", "1", "2");
2110 TEST_DUP("status", "current", "obsolete");
2111 TEST_DUP("when", "true", "false");
2112#undef TEST_DUP
2113
2114 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02002115 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 +01002116 "leaf-list ll {type string;} list li;notification not;reference test;status current;uses g;when true;m:ext;} ...";
Michal Vasko63f3d842020-07-08 10:10:14 +02002117 assert_int_equal(LY_SUCCESS, parse_augment(&ctx, &in, NULL, &a));
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002118 assert_non_null(a);
2119 assert_int_equal(LYS_AUGMENT, a->nodetype);
2120 assert_string_equal("/target/nodeid", a->nodeid);
2121 assert_string_equal("test", a->dsc);
2122 assert_non_null(a->exts);
2123 assert_non_null(a->iffeatures);
2124 assert_string_equal("test", a->ref);
2125 assert_non_null(a->when);
2126 assert_null(a->parent);
2127 assert_int_equal(LYS_STATUS_CURR, a->flags);
Radek Krejcib4adbf12019-02-25 13:35:22 +01002128 FREE_ARRAY(ctx.ctx, a, lysp_augment_free); a = NULL;
Radek Krejci5a7c4a52019-02-12 15:45:11 +01002129
2130 *state = NULL;
2131 ly_ctx_destroy(ctx.ctx, NULL);
2132}
2133
Radek Krejcif09e4e82019-06-14 15:08:11 +02002134static void
2135test_when(void **state)
2136{
2137 *state = test_when;
2138
Michal Vaskob36053d2020-03-26 15:49:30 +01002139 struct lys_yang_parser_ctx ctx = {0};
Radek Krejcif09e4e82019-06-14 15:08:11 +02002140 struct lysp_when *w = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +02002141 struct ly_in in = {0};
Radek Krejcif09e4e82019-06-14 15:08:11 +02002142
Michal Vaskob36053d2020-03-26 15:49:30 +01002143 ctx.format = LYS_IN_YANG;
Radek Krejcif09e4e82019-06-14 15:08:11 +02002144 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
2145 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02002146 ctx.pos_type = LY_VLOG_LINE;
Radek Krejcif09e4e82019-06-14 15:08:11 +02002147 ctx.line = 1;
2148 ctx.mod_version = 2; /* simulate YANG 1.1 */
2149
2150 /* invalid cardinality */
2151#define TEST_DUP(MEMBER, VALUE1, VALUE2) \
Michal Vasko63f3d842020-07-08 10:10:14 +02002152 in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \
2153 assert_int_equal(LY_EVALID, parse_when(&ctx, &in, &w)); \
Radek Krejcif09e4e82019-06-14 15:08:11 +02002154 logbuf_assert("Duplicate keyword \""MEMBER"\". Line number 1."); \
2155 FREE_MEMBER(ctx.ctx, w, lysp_when_free); w = NULL;
2156
2157 TEST_DUP("description", "text1", "text2");
2158 TEST_DUP("reference", "1", "2");
2159#undef TEST_DUP
2160
2161 /* full content */
Michal Vasko63f3d842020-07-08 10:10:14 +02002162 in.current = "expression {description test;reference test;m:ext;} ...";
2163 assert_int_equal(LY_SUCCESS, parse_when(&ctx, &in, &w));
Radek Krejcif09e4e82019-06-14 15:08:11 +02002164 assert_non_null(w);
2165 assert_string_equal("expression", w->cond);
2166 assert_string_equal("test", w->dsc);
2167 assert_string_equal("test", w->ref);
2168 assert_non_null(w->exts);
2169 FREE_MEMBER(ctx.ctx, w, lysp_when_free); w = NULL;
2170
2171 /* empty condition */
Michal Vasko63f3d842020-07-08 10:10:14 +02002172 in.current = "\"\";";
2173 assert_int_equal(LY_SUCCESS, parse_when(&ctx, &in, &w));
Radek Krejcif09e4e82019-06-14 15:08:11 +02002174 logbuf_assert("Empty argument of when statement does not make sense.");
2175 assert_non_null(w);
2176 assert_string_equal("", w->cond);
2177 FREE_MEMBER(ctx.ctx, w, lysp_when_free); w = NULL;
2178
2179 *state = NULL;
2180 ly_ctx_destroy(ctx.ctx, NULL);
2181}
2182
David Sedlákd6ce6d72019-07-16 17:30:18 +02002183static void
2184test_value(void **state)
2185{
2186 *state = test_value;
Michal Vaskob36053d2020-03-26 15:49:30 +01002187 struct lys_yang_parser_ctx ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +02002188 struct ly_in in = {0};
David Sedlákd6ce6d72019-07-16 17:30:18 +02002189
Michal Vaskob36053d2020-03-26 15:49:30 +01002190 ctx.format = LYS_IN_YANG;
David Sedlákd6ce6d72019-07-16 17:30:18 +02002191 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
2192 assert_non_null(ctx.ctx);
Radek Krejci99435242019-09-05 16:19:15 +02002193 ctx.pos_type = LY_VLOG_LINE;
David Sedlákd6ce6d72019-07-16 17:30:18 +02002194 ctx.line = 1;
2195 ctx.indent = 0;
2196 int64_t val = 0;
2197 uint16_t flags = 0;
2198
Michal Vasko63f3d842020-07-08 10:10:14 +02002199 in.current = "-0;";
2200 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 +02002201 assert_int_equal(val, 0);
2202
Michal Vasko63f3d842020-07-08 10:10:14 +02002203 in.current = "-0;";
David Sedlákd6ce6d72019-07-16 17:30:18 +02002204 flags = 0;
Michal Vasko63f3d842020-07-08 10:10:14 +02002205 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 +02002206 logbuf_assert("Invalid value \"-0\" of \"position\". Line number 1.");
2207
David Sedlák1af868e2019-07-17 17:03:14 +02002208 *state = NULL;
David Sedlákd6ce6d72019-07-16 17:30:18 +02002209 ly_ctx_destroy(ctx.ctx, NULL);
2210}
2211
Radek Krejci80dd33e2018-09-26 15:57:18 +02002212int main(void)
2213{
2214 const struct CMUnitTest tests[] = {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002215 cmocka_unit_test_setup(test_helpers, logger_setup),
Radek Krejci80dd33e2018-09-26 15:57:18 +02002216 cmocka_unit_test_setup(test_comments, logger_setup),
Radek Krejciefd22f62018-09-27 11:47:58 +02002217 cmocka_unit_test_setup(test_arg, logger_setup),
Radek Krejcidcc7b322018-10-11 14:24:02 +02002218 cmocka_unit_test_setup(test_stmts, logger_setup),
Radek Krejci05b13982018-11-28 16:22:07 +01002219 cmocka_unit_test_setup_teardown(test_minmax, logger_setup, logger_teardown),
Radek Krejci40544fa2019-01-11 09:38:37 +01002220 cmocka_unit_test_setup_teardown(test_module, logger_setup, logger_teardown),
Radek Krejci2c02f3e2018-10-16 10:54:38 +02002221 cmocka_unit_test_setup(test_deviation, logger_setup),
2222 cmocka_unit_test_setup(test_deviate, logger_setup),
Radek Krejci8c370832018-11-02 15:10:03 +01002223 cmocka_unit_test_setup(test_container, logger_setup),
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01002224 cmocka_unit_test_setup_teardown(test_leaf, logger_setup, logger_teardown),
Radek Krejci0e5d8382018-11-28 16:37:53 +01002225 cmocka_unit_test_setup_teardown(test_leaflist, logger_setup, logger_teardown),
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002226 cmocka_unit_test_setup_teardown(test_list, logger_setup, logger_teardown),
Radek Krejci056d0a82018-12-06 16:57:25 +01002227 cmocka_unit_test_setup_teardown(test_choice, logger_setup, logger_teardown),
Radek Krejcia9026eb2018-12-12 16:04:47 +01002228 cmocka_unit_test_setup_teardown(test_case, logger_setup, logger_teardown),
Radek Krejci9800fb82018-12-13 14:26:23 +01002229 cmocka_unit_test_setup_teardown(test_anydata, logger_setup, logger_teardown),
2230 cmocka_unit_test_setup_teardown(test_anyxml, logger_setup, logger_teardown),
Radek Krejcif538ce52019-03-05 10:46:14 +01002231 cmocka_unit_test_setup_teardown(test_action, logger_setup, logger_teardown),
Radek Krejcifc11bd72019-04-11 16:00:05 +02002232 cmocka_unit_test_setup_teardown(test_notification, logger_setup, logger_teardown),
Radek Krejcie86bf772018-12-14 11:39:53 +01002233 cmocka_unit_test_setup_teardown(test_grouping, logger_setup, logger_teardown),
2234 cmocka_unit_test_setup_teardown(test_uses, logger_setup, logger_teardown),
Radek Krejcib4adbf12019-02-25 13:35:22 +01002235 cmocka_unit_test_setup_teardown(test_augment, logger_setup, logger_teardown),
Radek Krejcif09e4e82019-06-14 15:08:11 +02002236 cmocka_unit_test_setup_teardown(test_when, logger_setup, logger_teardown),
David Sedlákd6ce6d72019-07-16 17:30:18 +02002237 cmocka_unit_test_setup_teardown(test_value, logger_setup, logger_teardown),
Radek Krejci80dd33e2018-09-26 15:57:18 +02002238 };
2239
2240 return cmocka_run_group_tests(tests, NULL, NULL);
2241}