blob: 56404e02047128b0c9052b31f84cdf6fd51def82 [file] [log] [blame]
/*
* @file test_parser_yang.c
* @author: Radek Krejci <rkrejci@cesnet.cz>
* @brief unit tests for functions from parser_yang.c
*
* Copyright (c) 2018 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*/
#define _BSD_SOURCE
#define _DEFAULT_SOURCE
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdio.h>
#include <string.h>
#include "libyang.h"
#include "../../src/parser_yang.c"
#define BUFSIZE 1024
char logbuf[BUFSIZE] = {0};
/* set to 0 to printing error messages to stderr instead of checking them in code */
#define ENABLE_LOGGER_CHECKING 1
#if ENABLE_LOGGER_CHECKING
static void
logger(LY_LOG_LEVEL level, const char *msg, const char *path)
{
(void) level; /* unused */
if (path) {
snprintf(logbuf, BUFSIZE - 1, "%s %s", msg, path);
} else {
strncpy(logbuf, msg, BUFSIZE - 1);
}
}
#endif
static int
logger_setup(void **state)
{
(void) state; /* unused */
#if ENABLE_LOGGER_CHECKING
ly_set_log_clb(logger, 1);
#endif
return 0;
}
void
logbuf_clean(void)
{
logbuf[0] = '\0';
}
#if ENABLE_LOGGER_CHECKING
# define logbuf_assert(str) assert_string_equal(logbuf, str)
#else
# define logbuf_assert(str)
#endif
static void
test_helpers(void **state)
{
(void) state; /* unused */
const char *str;
char *buf, *p;
size_t len, size;
int prefix;
struct ly_parser_ctx ctx;
ctx.ctx = NULL;
ctx.line = 1;
/* storing into buffer */
str = "abcd";
buf = NULL;
size = len = 0;
assert_int_equal(LY_SUCCESS, buf_add_char(NULL, &str, 2, &buf, &size, &len));
assert_int_not_equal(0, size);
assert_int_equal(2, len);
assert_string_equal("cd", str);
assert_false(strncmp("ab", buf, 2));
free(buf);
buf = NULL;
/* invalid first characters */
len = 0;
str = "2invalid";
assert_int_equal(LY_EVALID, buf_store_char(&ctx, &str, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1));
str = ".invalid";
assert_int_equal(LY_EVALID, buf_store_char(&ctx, &str, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1));
str = "-invalid";
assert_int_equal(LY_EVALID, buf_store_char(&ctx, &str, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1));
/* invalid following characters */
len = 3; /* number of characters read before the str content */
str = "!";
assert_int_equal(LY_EVALID, buf_store_char(&ctx, &str, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1));
str = ":";
assert_int_equal(LY_EVALID, buf_store_char(&ctx, &str, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1));
/* valid colon for prefixed identifiers */
len = size = 0;
p = NULL;
str = "x:id";
assert_int_equal(LY_SUCCESS, buf_store_char(&ctx, &str, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 0));
assert_int_equal(1, len);
assert_null(buf);
assert_string_equal(":id", str);
assert_int_equal('x', p[len - 1]);
assert_int_equal(LY_SUCCESS, buf_store_char(&ctx, &str, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 1));
assert_int_equal(2, len);
assert_string_equal("id", str);
assert_int_equal(':', p[len - 1]);
free(buf);
/* checking identifiers */
assert_int_equal(LY_EVALID, check_identifierchar(&ctx, ':', 0, NULL));
logbuf_assert("Invalid identifier character ':'. Line number 1.");
assert_int_equal(LY_EVALID, check_identifierchar(&ctx, '#', 1, NULL));
logbuf_assert("Invalid identifier first character '#'. Line number 1.");
assert_int_equal(LY_SUCCESS, check_identifierchar(&ctx, 'a', 1, &prefix));
assert_int_equal(0, prefix);
assert_int_equal(LY_SUCCESS, check_identifierchar(&ctx, ':', 0, &prefix));
assert_int_equal(1, prefix);
assert_int_equal(LY_EVALID, check_identifierchar(&ctx, ':', 0, &prefix));
assert_int_equal(1, prefix);
assert_int_equal(LY_SUCCESS, check_identifierchar(&ctx, 'b', 0, &prefix));
assert_int_equal(2, prefix);
/* second colon is invalid */
assert_int_equal(LY_EVALID, check_identifierchar(&ctx, ':', 0, &prefix));
logbuf_assert("Invalid identifier character ':'. Line number 1.");
}
static void
test_comments(void **state)
{
(void) state; /* unused */
struct ly_parser_ctx ctx;
const char *str, *p;
char *word, *buf;
size_t len;
ctx.ctx = NULL;
ctx.line = 1;
str = " // this is a text of / one * line */ comment\nargument";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_string_equal("argument", word);
assert_null(buf);
assert_int_equal(8, len);
str = "/* this is a \n * text // of / block * comment */\"arg\" + \"ume\" \n + \n \"nt\"";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_string_equal("argument", word);
assert_ptr_equal(buf, word);
assert_int_equal(8, len);
free(word);
str = p = " this is one line comment on last line";
assert_int_equal(LY_SUCCESS, skip_comment(&ctx, &str, 1));
assert_true(str[0] == '\0');
str = p = " this is a not terminated comment x";
assert_int_equal(LY_EVALID, skip_comment(&ctx, &str, 2));
logbuf_assert("Unexpected end-of-file, non-terminated comment. Line number 5.");
assert_true(str[0] == '\0');
}
static void
test_arg(void **state)
{
(void) state; /* unused */
struct ly_parser_ctx ctx;
const char *str;
char *word, *buf;
size_t len;
ctx.ctx = NULL;
ctx.line = 1;
/* missing argument */
str = ";";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_MAYBE_STR_ARG, &word, &buf, &len));
assert_null(word);
str = "{";
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Invalid character sequence \"{\", expected an argument. Line number 1.");
/* invalid escape sequence */
str = "\"\\s\"";
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Double-quoted string unknown special character \'\\s\'. Line number 1.");
str = "\'\\s\'"; /* valid, since it is not an escape sequence in single quoted string */
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_int_equal(2, len);
assert_string_equal("\\s\'", word);
assert_int_equal('\0', str[0]); /* input has been eaten */
/* invalid character after the argument */
str = "hello\"";
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Invalid character sequence \"\"\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
str = "hello}";
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Invalid character sequence \"}\", expected unquoted string character, optsep, semicolon or opening brace. Line number 1.");
str = "hello/x\t"; /* slash is not an invalid character */
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_int_equal(7, len);
assert_string_equal("hello/x\t", word);
assert_null(buf);
/* different quoting */
str = "hello ";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_null(buf);
assert_int_equal(5, len);
assert_string_equal("hello ", word);
str = "hello/*comment*/\n";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_null(buf);
assert_int_equal(5, len);
assert_false(strncmp("hello", word, len));
str = "\"hello\\n\\t\\\"\\\\\";";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_null(buf);
assert_int_equal(9, len);
assert_string_equal("hello\\n\\t\\\"\\\\\";", word);
ctx.indent = 14;
str = "\"hello \t\n\t\t world!\"";
/* - space and tabs before newline are stripped out
* - space and tabs after newline (indentation) are stripped out
*/
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_non_null(buf);
assert_ptr_equal(word, buf);
assert_int_equal(14, len);
assert_string_equal("hello\n world!", word);
free(buf);
ctx.indent = 14;
str = "\"hello\n \tworld!\"";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_non_null(buf);
assert_ptr_equal(word, buf);
assert_int_equal(12, len);
assert_string_equal("hello\nworld!", word);
free(buf);
str = "\'hello\'";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_null(buf);
assert_int_equal(5, len);
assert_false(strncmp("hello", word, 5));
str = "\"hel\" +\t\n\"lo\"";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_ptr_equal(word, buf);
assert_int_equal(5, len);
assert_string_equal("hello", word);
free(buf);
str = "\"hel\" +\t\nlo"; /* unquoted the second part */
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Both string parts divided by '+' must be quoted. Line number 5.");
str = "\'he\'\t\n+ \"llo\"";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_ptr_equal(word, buf);
assert_int_equal(5, len);
assert_string_equal("hello", word);
free(buf);
str = " \t\n\"he\"+\'llo\'";
assert_int_equal(LY_SUCCESS, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
assert_ptr_equal(word, buf);
assert_int_equal(5, len);
assert_string_equal("hello", word);
free(buf);
/* missing argument */
str = ";";
assert_int_equal(LY_EVALID, get_argument(&ctx, &str, Y_STR_ARG, &word, &buf, &len));
logbuf_assert("Invalid character sequence \";\", expected an argument. Line number 7.");
}
static void
test_stmts(void **state)
{
(void) state; /* unused */
struct ly_parser_ctx ctx;
const char *str, *p;
enum yang_keyword kw;
char *word;
size_t len;
ctx.ctx = NULL;
ctx.line = 1;
str = "\n// comment\n\tinput\t{";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_INPUT, kw);
assert_int_equal(5, len);
assert_string_equal("input\t{", word);
assert_string_equal("\t{", str);
str = "\t /* comment */\t output\n\t{";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_OUTPUT, kw);
assert_int_equal(6, len);
assert_string_equal("output\n\t{", word);
assert_string_equal("\n\t{", str);
str = "/input { "; /* invalid slash */
assert_int_equal(LY_EVALID, get_keyword(&ctx, &str, &kw, &word, &len));
logbuf_assert("Invalid identifier first character '/'. Line number 4.");
str = "not-a-statement-nor-extension { "; /* invalid identifier */
assert_int_equal(LY_EVALID, get_keyword(&ctx, &str, &kw, &word, &len));
logbuf_assert("Invalid character sequence \"not-a-statement-nor-extension\", expected a keyword. Line number 4.");
str = "path;"; /* missing sep after the keyword */
assert_int_equal(LY_EVALID, get_keyword(&ctx, &str, &kw, &word, &len));
logbuf_assert("Invalid character sequence \"path;\", expected a keyword followed by a separator. Line number 4.");
str = "action ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ACTION, kw);
assert_int_equal(6, len);
str = "anydata ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ANYDATA, kw);
assert_int_equal(7, len);
str = "anyxml ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ANYXML, kw);
assert_int_equal(6, len);
str = "argument ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ARGUMENT, kw);
assert_int_equal(8, len);
str = "augment ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_AUGMENT, kw);
assert_int_equal(7, len);
str = "base ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_BASE, kw);
assert_int_equal(4, len);
str = "belongs-to ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_BELONGS_TO, kw);
assert_int_equal(10, len);
str = "bit ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_BIT, kw);
assert_int_equal(3, len);
str = "case ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CASE, kw);
assert_int_equal(4, len);
str = "choice ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CHOICE, kw);
assert_int_equal(6, len);
str = "config ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CONFIG, kw);
assert_int_equal(6, len);
str = "contact ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CONTACT, kw);
assert_int_equal(7, len);
str = "container ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CONTAINER, kw);
assert_int_equal(9, len);
str = "default ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_DEFAULT, kw);
assert_int_equal(7, len);
str = "description ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_DESCRIPTION, kw);
assert_int_equal(11, len);
str = "deviate ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_DEVIATE, kw);
assert_int_equal(7, len);
str = "deviation ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_DEVIATION, kw);
assert_int_equal(9, len);
str = "enum ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ENUM, kw);
assert_int_equal(4, len);
str = "error-app-tag ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ERROR_APP_TAG, kw);
assert_int_equal(13, len);
str = "error-message ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ERROR_MESSAGE, kw);
assert_int_equal(13, len);
str = "extension ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_EXTENSION, kw);
assert_int_equal(9, len);
str = "feature ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_FEATURE, kw);
assert_int_equal(7, len);
str = "fraction-digits ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_FRACTION_DIGITS, kw);
assert_int_equal(15, len);
str = "grouping ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_GROUPING, kw);
assert_int_equal(8, len);
str = "identity ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_IDENTITY, kw);
assert_int_equal(8, len);
str = "if-feature ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_IF_FEATURE, kw);
assert_int_equal(10, len);
str = "import ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_IMPORT, kw);
assert_int_equal(6, len);
str = "include ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_INCLUDE, kw);
assert_int_equal(7, len);
str = "input{";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_INPUT, kw);
assert_int_equal(5, len);
str = "key ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_KEY, kw);
assert_int_equal(3, len);
str = "leaf ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_LEAF, kw);
assert_int_equal(4, len);
str = "leaf-list ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_LEAF_LIST, kw);
assert_int_equal(9, len);
str = "length ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_LENGTH, kw);
assert_int_equal(6, len);
str = "list ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_LIST, kw);
assert_int_equal(4, len);
str = "mandatory ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MANDATORY, kw);
assert_int_equal(9, len);
str = "max-elements ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MAX_ELEMENTS, kw);
assert_int_equal(12, len);
str = "min-elements ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MIN_ELEMENTS, kw);
assert_int_equal(12, len);
str = "modifier ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MODIFIER, kw);
assert_int_equal(8, len);
str = "module ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MODULE, kw);
assert_int_equal(6, len);
str = "must ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_MUST, kw);
assert_int_equal(4, len);
str = "namespace ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_NAMESPACE, kw);
assert_int_equal(9, len);
str = "notification ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_NOTIFICATION, kw);
assert_int_equal(12, len);
str = "ordered-by ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ORDERED_BY, kw);
assert_int_equal(10, len);
str = "organization ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_ORGANIZATION, kw);
assert_int_equal(12, len);
str = "output ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_OUTPUT, kw);
assert_int_equal(6, len);
str = "path ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_PATH, kw);
assert_int_equal(4, len);
str = "pattern ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_PATTERN, kw);
assert_int_equal(7, len);
str = "position ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_POSITION, kw);
assert_int_equal(8, len);
str = "prefix ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_PREFIX, kw);
assert_int_equal(6, len);
str = "presence ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_PRESENCE, kw);
assert_int_equal(8, len);
str = "range ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_RANGE, kw);
assert_int_equal(5, len);
str = "reference ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_REFERENCE, kw);
assert_int_equal(9, len);
str = "refine ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_REFINE, kw);
assert_int_equal(6, len);
str = "require-instance ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_REQUIRE_INSTANCE, kw);
assert_int_equal(16, len);
str = "revision ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_REVISION, kw);
assert_int_equal(8, len);
str = "revision-date ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_REVISION_DATE, kw);
assert_int_equal(13, len);
str = "rpc ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_RPC, kw);
assert_int_equal(3, len);
str = "status ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_STATUS, kw);
assert_int_equal(6, len);
str = "submodule ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_SUBMODULE, kw);
assert_int_equal(9, len);
str = "type ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_TYPE, kw);
assert_int_equal(4, len);
str = "typedef ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_TYPEDEF, kw);
assert_int_equal(7, len);
str = "unique ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_UNIQUE, kw);
assert_int_equal(6, len);
str = "units ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_UNITS, kw);
assert_int_equal(5, len);
str = "uses ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_USES, kw);
assert_int_equal(4, len);
str = "value ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_VALUE, kw);
assert_int_equal(5, len);
str = "when ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_WHEN, kw);
assert_int_equal(4, len);
str = "yang-version ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_YANG_VERSION, kw);
assert_int_equal(12, len);
str = "yin-element ";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_YIN_ELEMENT, kw);
assert_int_equal(11, len);
str = ";config false;";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_SEMICOLON, kw);
assert_int_equal(1, len);
assert_string_equal("config false;", str);
str = "{ config false;";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_LEFT_BRACE, kw);
assert_int_equal(1, len);
assert_string_equal(" config false;", str);
str = "}";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_RIGHT_BRACE, kw);
assert_int_equal(1, len);
assert_string_equal("", str);
/* geenric extension */
str = p = "nacm:default-deny-write;";
assert_int_equal(LY_SUCCESS, get_keyword(&ctx, &str, &kw, &word, &len));
assert_int_equal(YANG_CUSTOM, kw);
assert_int_equal(23, len);
assert_ptr_equal(p, word);
}
static struct lysp_module *
mod_renew(struct ly_parser_ctx *ctx, struct lysp_module *mod, uint8_t submodule)
{
lysp_module_free(mod);
mod = calloc(1, sizeof *mod);
mod->ctx = ctx->ctx;
mod->submodule = submodule;
assert_non_null(mod);
return mod;
}
static void
test_module(void **state)
{
(void) state; /* unused */
struct ly_parser_ctx ctx;
struct lysp_module *mod;
const char *str;
assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &ctx.ctx));
assert_non_null(ctx.ctx);
ctx.line = 1;
ctx.indent = 0;
mod = mod_renew(&ctx, NULL, 0);
/* missing mandatory substatements */
str = " name {}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
assert_string_equal("name", mod->name);
logbuf_assert("Missing mandatory keyword \"namespace\" as a child of \"module\". Line number 1.");
mod = mod_renew(&ctx, mod, 0);
str = " name {namespace urn:x;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
assert_string_equal("urn:x", mod->ns);
logbuf_assert("Missing mandatory keyword \"prefix\" as a child of \"module\". Line number 1.");
mod = mod_renew(&ctx, mod, 0);
str = " name {namespace urn:x;prefix \"x\";}";
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod));
assert_string_equal("x", mod->prefix);
mod = mod_renew(&ctx, mod, 0);
#define SCHEMA_BEGINNING " name {namespace urn:x;prefix \"x\";"
#define TEST_NODE(NODETYPE, INPUT, NAME) \
str = SCHEMA_BEGINNING INPUT; \
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod)); \
assert_non_null(mod->data); \
assert_int_equal(NODETYPE, mod->data->nodetype); \
assert_string_equal(NAME, mod->data->name); \
mod = mod_renew(&ctx, mod, 0);
#define TEST_GENERIC(INPUT, TARGET, TEST) \
str = SCHEMA_BEGINNING INPUT; \
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod)); \
assert_non_null(TARGET); \
TEST; \
mod = mod_renew(&ctx, mod, 0);
/* duplicated namespace, prefix */
str = SCHEMA_BEGINNING "namespace y;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Duplicate keyword \"namespace\". Line number 1.");
mod = mod_renew(&ctx, mod, 0);
str = SCHEMA_BEGINNING "prefix y;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Duplicate keyword \"prefix\". Line number 1.");
mod = mod_renew(&ctx, mod, 0);
/* not allowed in module (submodule-specific) */
str = SCHEMA_BEGINNING "belongs-to master {prefix m;}}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Invalid keyword \"belongs-to\" as a child of \"module\". Line number 1.");
mod = mod_renew(&ctx, mod, 0);
/* anydata */
TEST_NODE(LYS_ANYDATA, "anydata test;}", "test");
/* anyxml */
TEST_NODE(LYS_ANYXML, "anyxml test;}", "test");
/* augment */
TEST_GENERIC("augment /somepath;}", mod->augments,
assert_string_equal("/somepath", mod->augments[0].nodeid));
/* choice */
TEST_NODE(LYS_CHOICE, "choice test;}", "test");
/* contact 0..1 */
TEST_GENERIC("contact \"firstname\" + \n\t\" surname\";}", mod->contact,
assert_string_equal("firstname surname", mod->contact));
/* container */
TEST_NODE(LYS_CONTAINER, "container test;}", "test");
/* description 0..1 */
TEST_GENERIC("description \'some description\';}", mod->dsc,
assert_string_equal("some description", mod->dsc));
/* deviation */
TEST_GENERIC("deviation /somepath {deviate not-supported;}}", mod->deviations,
assert_string_equal("/somepath", mod->deviations[0].nodeid));
/* extension */
TEST_GENERIC("extension test;}", mod->extensions,
assert_string_equal("test", mod->extensions[0].name));
/* feature */
TEST_GENERIC("feature test;}", mod->features,
assert_string_equal("test", mod->features[0].name));
/* grouping */
TEST_GENERIC("grouping grp;}", mod->groupings,
assert_string_equal("grp", mod->groupings[0].name));
/* identity */
TEST_GENERIC("identity test;}", mod->identities,
assert_string_equal("test", mod->identities[0].name));
/* import */
TEST_GENERIC("import test {prefix z;}}", mod->imports,
assert_string_equal("test", mod->imports[0].name));
/* import - prefix collision */
str = SCHEMA_BEGINNING "import test {prefix x;}}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Prefix \"x\" already used as module prefix. Line number 2.");
mod = mod_renew(&ctx, mod, 0);
/* include */
TEST_GENERIC("include test;}", mod->includes,
assert_string_equal("test", mod->includes[0].name));
/* leaf */
TEST_NODE(LYS_LEAF, "leaf test {type string;}}", "test");
/* leaf-list */
TEST_NODE(LYS_LEAFLIST, "leaf-list test {type string;}}", "test");
/* list */
TEST_NODE(LYS_LIST, "list test {key a;leaf a {type string;}}}", "test");
/* notification */
TEST_GENERIC("notification test;}", mod->notifs,
assert_string_equal("test", mod->notifs[0].name));
/* organization 0..1 */
TEST_GENERIC("organization \"CESNET a.l.e.\";}", mod->org,
assert_string_equal("CESNET a.l.e.", mod->org));
/* reference 0..1 */
TEST_GENERIC("reference RFC7950;}", mod->ref,
assert_string_equal("RFC7950", mod->ref));
/* revision */
TEST_GENERIC("revision 2018-10-12;}", mod->revs,
assert_string_equal("2018-10-12", mod->revs[0].rev));
/* rpc */
TEST_GENERIC("rpc test;}", mod->rpcs,
assert_string_equal("test", mod->rpcs[0].name));
/* typedef */
TEST_GENERIC("typedef test{type string;}}", mod->typedefs,
assert_string_equal("test", mod->typedefs[0].name));
/* uses */
TEST_NODE(LYS_USES, "uses test;}", "test");
/* yang-version */
str = SCHEMA_BEGINNING "\n\tyang-version 10;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Invalid value \"10\" of \"yang-version\". Line number 3.");
mod = mod_renew(&ctx, mod, 0);
str = SCHEMA_BEGINNING "yang-version 1.0;yang-version 1.1;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Duplicate keyword \"yang-version\". Line number 3.");
mod = mod_renew(&ctx, mod, 0);
str = SCHEMA_BEGINNING "yang-version 1.0;}";
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod));
assert_int_equal(1, mod->version);
mod = mod_renew(&ctx, mod, 0);
str = SCHEMA_BEGINNING "yang-version \"1.1\";}";
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod));
assert_int_equal(2, mod->version);
mod = mod_renew(&ctx, mod, 0);
/* submodule */
mod->submodule = 1;
/* missing mandatory substatements */
str = " subname {}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
assert_string_equal("subname", mod->name);
logbuf_assert("Missing mandatory keyword \"belongs-to\" as a child of \"submodule\". Line number 3.");
mod = mod_renew(&ctx, mod, 1);
str = " subname {belongs-to name;}";
assert_int_equal(LY_SUCCESS, parse_sub_module(&ctx, &str, mod));
assert_string_equal("name", mod->belongsto);
mod = mod_renew(&ctx, mod, 1);
#undef SCHEMA_BEGINNING
#define SCHEMA_BEGINNING " subname {belongs-to name;"
/* duplicated namespace, prefix */
str = SCHEMA_BEGINNING "belongs-to othermodule;}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Duplicate keyword \"belongs-to\". Line number 3.");
mod = mod_renew(&ctx, mod, 1);
/* not allowed in submodule (module-specific) */
str = SCHEMA_BEGINNING "namespace \"urn:z\";}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Invalid keyword \"namespace\" as a child of \"submodule\". Line number 3.");
mod = mod_renew(&ctx, mod, 1);
str = SCHEMA_BEGINNING "prefix m;}}";
assert_int_equal(LY_EVALID, parse_sub_module(&ctx, &str, mod));
logbuf_assert("Invalid keyword \"prefix\" as a child of \"submodule\". Line number 3.");
mod = mod_renew(&ctx, mod, 1);
#undef TEST_GENERIC
#undef TEST_NODE
#undef SCHEMA_BEGINNING
lysp_module_free(mod);
ly_ctx_destroy(ctx.ctx, NULL);
}
int main(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test_setup(test_helpers, logger_setup),
cmocka_unit_test_setup(test_comments, logger_setup),
cmocka_unit_test_setup(test_arg, logger_setup),
cmocka_unit_test_setup(test_stmts, logger_setup),
cmocka_unit_test_setup(test_module, logger_setup),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}