| /* |
| * @file test_context.c |
| * @author: Radek Krejci <rkrejci@cesnet.cz> |
| * @brief unit tests for functions from context.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 _UTEST_MAIN_ |
| #include "utests.h" |
| |
| #include "common.h" |
| #include "context.h" |
| #include "in.h" |
| #include "schema_compile.h" |
| #include "tests_config.h" |
| #include "tree_schema_internal.h" |
| #include "utests.h" |
| |
| #ifdef _WIN32 |
| static void |
| slashes_to_backslashes(char *path) |
| { |
| while ((path = strchr(path, '/'))) { |
| *path++ = '\\'; |
| } |
| } |
| |
| static void |
| test_searchdirs(void **state) |
| { |
| const char * const *list; |
| char *path1 = strdup(TESTS_BIN "/utests"); |
| char *path2 = strdup(TESTS_SRC); |
| |
| slashes_to_backslashes(path1); |
| slashes_to_backslashes(path2); |
| |
| assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_set_searchdir()).", NULL); |
| assert_null(ly_ctx_get_searchdirs(NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_searchdirs()).", NULL); |
| assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_unset_searchdir()).", NULL); |
| |
| /* correct path */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path1)); |
| assert_int_equal(1, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[0]); |
| |
| /* duplicated paths */ |
| assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, path1)); |
| assert_int_equal(1, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[0]); |
| |
| /* another path */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path2)); |
| assert_int_equal(2, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(path2, UTEST_LYCTX->search_paths.objs[1]); |
| |
| /* get searchpaths */ |
| list = ly_ctx_get_searchdirs(UTEST_LYCTX); |
| assert_non_null(list); |
| assert_string_equal(path1, list[0]); |
| assert_string_equal(path2, list[1]); |
| assert_null(list[2]); |
| |
| /* removing searchpaths */ |
| /* nonexisting */ |
| assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(UTEST_LYCTX, "/nonexistingfile")); |
| CHECK_LOG_CTX("Invalid argument value (ly_ctx_unset_searchdir()).", NULL); |
| |
| /* first */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path1)); |
| assert_int_equal(1, UTEST_LYCTX->search_paths.count); |
| assert_string_not_equal(path1, list[0]); |
| |
| /* second */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path2)); |
| assert_int_equal(0, UTEST_LYCTX->search_paths.count); |
| |
| free(path1); |
| free(path2); |
| } |
| |
| #else |
| |
| static void |
| test_searchdirs(void **state) |
| { |
| const char * const *list; |
| |
| /* invalid arguments */ |
| assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_set_searchdir()).", NULL); |
| assert_null(ly_ctx_get_searchdirs(NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_searchdirs()).", NULL); |
| assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_unset_searchdir()).", NULL); |
| |
| /* readable and executable, but not a directory */ |
| assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utest_context")); |
| CHECK_LOG_CTX("Given search directory \""TESTS_BIN "/utest_context\" is not a directory.", NULL); |
| /* not executable */ |
| assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(UTEST_LYCTX, __FILE__)); |
| CHECK_LOG_CTX("Unable to fully access search directory \""__FILE__ "\" (Permission denied).", NULL); |
| /* not existing */ |
| assert_int_equal(LY_EINVAL, ly_ctx_set_searchdir(UTEST_LYCTX, "/nonexistingfile")); |
| CHECK_LOG_CTX("Unable to use search directory \"/nonexistingfile\" (No such file or directory).", NULL); |
| |
| /* ly_set_add() fails */ |
| /* no change */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, NULL)); |
| |
| /* correct path */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests")); |
| assert_int_equal(1, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[0]); |
| |
| /* duplicated paths */ |
| assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests")); |
| assert_int_equal(1, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[0]); |
| |
| /* another paths - add 8 to fill the initial buffer of the searchpaths list */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/CMakeFiles")); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../src")); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../CMakeModules")); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC "/../doc")); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_SRC)); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN)); |
| assert_int_equal(7, UTEST_LYCTX->search_paths.count); |
| |
| /* get searchpaths */ |
| list = ly_ctx_get_searchdirs(UTEST_LYCTX); |
| assert_non_null(list); |
| assert_string_equal(TESTS_BIN "/utests", list[0]); |
| assert_string_equal(TESTS_BIN "/CMakeFiles", list[1]); |
| assert_string_equal(TESTS_SRC, list[5]); |
| assert_string_equal(TESTS_BIN, list[6]); |
| assert_null(list[7]); |
| |
| /* removing searchpaths */ |
| /* nonexisting */ |
| assert_int_equal(LY_EINVAL, ly_ctx_unset_searchdir(UTEST_LYCTX, "/nonexistingfile")); |
| CHECK_LOG_CTX("Invalid argument value (ly_ctx_unset_searchdir()).", NULL); |
| /* first */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_BIN "/utests")); |
| assert_string_not_equal(TESTS_BIN "/utests", list[0]); |
| assert_int_equal(6, UTEST_LYCTX->search_paths.count); |
| /* middle */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_SRC)); |
| assert_int_equal(5, UTEST_LYCTX->search_paths.count); |
| /* last */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_BIN)); |
| assert_int_equal(4, UTEST_LYCTX->search_paths.count); |
| /* all */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL)); |
| assert_int_equal(0, UTEST_LYCTX->search_paths.count); |
| |
| /* again - no change */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL)); |
| |
| /* cleanup */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| |
| /* test searchdir list in ly_ctx_new() */ |
| assert_int_equal(LY_EINVAL, ly_ctx_new("/nonexistingfile", 0, &UTEST_LYCTX)); |
| CHECK_LOG("Unable to use search directory \"/nonexistingfile\" (No such file or directory).", NULL); |
| assert_int_equal(LY_SUCCESS, |
| ly_ctx_new(TESTS_SRC PATH_SEPARATOR TESTS_BIN PATH_SEPARATOR TESTS_BIN PATH_SEPARATOR TESTS_SRC, |
| LY_CTX_DISABLE_SEARCHDIRS, &UTEST_LYCTX)); |
| assert_int_equal(2, UTEST_LYCTX->search_paths.count); |
| assert_string_equal(TESTS_SRC, UTEST_LYCTX->search_paths.objs[0]); |
| assert_string_equal(TESTS_BIN, UTEST_LYCTX->search_paths.objs[1]); |
| } |
| |
| #endif |
| |
| static void |
| test_options(void **state) |
| { |
| /* use own context with extra flags */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0xffff, &UTEST_LYCTX)); |
| |
| /* invalid arguments */ |
| assert_int_equal(0, ly_ctx_get_options(NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_options()).", NULL); |
| |
| assert_int_equal(LY_EINVAL, ly_ctx_set_options(NULL, 0)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_set_options()).", NULL); |
| assert_int_equal(LY_EINVAL, ly_ctx_unset_options(NULL, 0)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_unset_options()).", NULL); |
| |
| /* unset */ |
| /* LY_CTX_ALL_IMPLEMENTED */ |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_ALL_IMPLEMENTED)); |
| assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED); |
| |
| /* LY_CTX_REF_IMPLEMENTED */ |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_REF_IMPLEMENTED)); |
| assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED); |
| |
| /* LY_CTX_DISABLE_SEARCHDIRS */ |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIRS)); |
| assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS); |
| |
| /* LY_CTX_DISABLE_SEARCHDIR_CWD */ |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIR_CWD)); |
| assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD); |
| |
| /* LY_CTX_PREFER_SEARCHDIRS */ |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_PREFER_SEARCHDIRS)); |
| assert_int_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS); |
| |
| assert_int_equal(UTEST_LYCTX->flags, ly_ctx_get_options(UTEST_LYCTX)); |
| |
| /* set back */ |
| /* LY_CTX_ALL_IMPLEMENTED */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_ALL_IMPLEMENTED)); |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_ALL_IMPLEMENTED); |
| |
| /* LY_CTX_REF_IMPLEMENTED */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_REF_IMPLEMENTED)); |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_REF_IMPLEMENTED); |
| |
| /* LY_CTX_DISABLE_SEARCHDIRS */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIRS)); |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIRS); |
| |
| /* LY_CTX_DISABLE_SEARCHDIR_CWD */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_DISABLE_SEARCHDIR_CWD)); |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_DISABLE_SEARCHDIR_CWD); |
| |
| /* LY_CTX_PREFER_SEARCHDIRS */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_PREFER_SEARCHDIRS)); |
| assert_int_not_equal(0, UTEST_LYCTX->flags & LY_CTX_PREFER_SEARCHDIRS); |
| |
| assert_int_equal(UTEST_LYCTX->flags, ly_ctx_get_options(UTEST_LYCTX)); |
| } |
| |
| static LY_ERR |
| test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name), |
| const char *UNUSED(sub_rev), void *user_data, LYS_INFORMAT *format, |
| const char **module_data, void (**free_module_data)(void *model_data, void *user_data)) |
| { |
| *module_data = user_data; |
| *format = LYS_IN_YANG; |
| *free_module_data = NULL; |
| return LY_SUCCESS; |
| } |
| |
| static void |
| test_models(void **state) |
| { |
| struct ly_in *in; |
| const char *str; |
| struct lys_module *mod1, *mod2; |
| struct lys_glob_unres unres = {0}; |
| |
| /* use own context with extra flags */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| |
| /* invalid arguments */ |
| assert_int_equal(0, ly_ctx_get_change_count(NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_change_count()).", NULL); |
| |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &UTEST_LYCTX)); |
| assert_int_equal(UTEST_LYCTX->change_count, ly_ctx_get_change_count(UTEST_LYCTX)); |
| |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module x {namespace urn:x;prefix x;}", &in)); |
| assert_int_equal(LY_EINVAL, lys_parse_in(UTEST_LYCTX, in, 4, NULL, NULL, &unres.creating, &mod1)); |
| lys_unres_glob_erase(&unres); |
| ly_in_free(in, 0); |
| CHECK_LOG_CTX("Invalid schema input format.", NULL); |
| |
| /* import callback */ |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, (void *)(str = "test")); |
| assert_ptr_equal(test_imp_clb, UTEST_LYCTX->imp_clb); |
| assert_ptr_equal(str, UTEST_LYCTX->imp_clb_data); |
| assert_ptr_equal(test_imp_clb, ly_ctx_get_module_imp_clb(UTEST_LYCTX, (void **)&str)); |
| assert_string_equal("test", str); |
| |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, NULL, NULL); |
| assert_null(UTEST_LYCTX->imp_clb); |
| assert_null(UTEST_LYCTX->imp_clb_data); |
| |
| /* name collision of module and submodule */ |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to a {prefix a;} revision 2018-10-30;}"); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module y {namespace urn:y;prefix y;include y;}", &in)); |
| assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1)); |
| lys_unres_glob_erase(&unres); |
| ly_in_free(in, 0); |
| CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL, |
| "Name collision between module and submodule of name \"y\".", "Line number 1."); |
| |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module a {namespace urn:a;prefix a;include y;revision 2018-10-30; }", &in)); |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1)); |
| ly_in_free(in, 0); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module y {namespace urn:y;prefix y;}", &in)); |
| assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1)); |
| lys_unres_glob_erase(&unres); |
| ly_in_free(in, 0); |
| CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL, |
| "Name collision between module and submodule of name \"y\".", "Line number 1."); |
| |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to b {prefix b;}}"); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module b {namespace urn:b;prefix b;include y;}", &in)); |
| assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1)); |
| lys_unres_glob_revert(UTEST_LYCTX, &unres); |
| lys_unres_glob_erase(&unres); |
| ly_in_free(in, 0); |
| CHECK_LOG_CTX("Parsing module \"b\" failed.", NULL, |
| "Including \"y\" submodule into \"b\" failed.", NULL, |
| "Parsing submodule failed.", NULL, |
| "Name collision between submodules of name \"y\".", "Line number 1."); |
| |
| /* selecting correct revision of the submodules */ |
| ly_ctx_reset_latests(UTEST_LYCTX); |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to a {prefix a;} revision 2018-10-31;}"); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module a {namespace urn:a;prefix a;include y; revision 2018-10-31;}", &in)); |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2)); |
| lys_unres_glob_erase(&unres); |
| ly_in_free(in, 0); |
| assert_string_equal("2018-10-31", mod2->parsed->includes[0].submodule->revs[0].date); |
| |
| /* reloading module in case only the compiled module resists in the context */ |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module w {namespace urn:w;prefix w;revision 2018-10-24;}", &in)); |
| assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod1)); |
| ly_in_free(in, 0); |
| assert_non_null(mod1->compiled); |
| assert_non_null(mod1->parsed); |
| |
| #if 0 |
| /* TODO in case we are able to remove the parsed schema, here we will test how it will handle missing import parsed schema */ |
| |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in)); |
| /* mod1->parsed is necessary to compile mod2 because of possible groupings, typedefs, ... */ |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, NULL, NULL); |
| assert_int_equal(LY_ENOTFOUND, lys_create_module(UTEST_LYCTX, in, LYS_IN_YANG, 1, NULL, NULL, &mod2)); |
| /*logbuf_assert("Unable to reload \"w\" module to import it into \"z\", source data not found.");*/ |
| CHECK_LOG_CTX("Recompilation of module \"w\" failed.", NULL); |
| assert_null(mod2); |
| ly_in_free(in, 0); |
| #endif |
| |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in)); |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module w {namespace urn:w;prefix w;revision 2018-10-24;}"); |
| assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod2)); |
| ly_in_free(in, 0); |
| assert_non_null(mod2); |
| assert_non_null(mod1->parsed); |
| assert_string_equal("w", mod1->name); |
| } |
| |
| static void |
| test_imports(void **state) |
| { |
| struct lys_module *mod1, *mod2, *mod3, *import; |
| char *str; |
| uint16_t ctx_options; |
| |
| /* use own context with extra flags */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| ctx_options = LY_CTX_DISABLE_SEARCHDIRS | LY_CTX_NO_YANGLIBRARY; |
| |
| /* Import callback provides newer revision of module 'a', |
| * however the older revision is implemented soon and therefore it is preferred. */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX)); |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module a {namespace urn:a; prefix a; revision 2019-09-17;}"); |
| assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module a {namespace urn:a;prefix a;revision 2019-09-16;}", |
| LYS_IN_YANG, &mod1)); |
| assert_true(LYS_MOD_LATEST_REV & mod1->latest_revision); |
| assert_int_equal(1, mod1->implemented); |
| assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module b {namespace urn:b;prefix b;import a {prefix a;}}", |
| LYS_IN_YANG, &mod2)); |
| assert_ptr_equal(mod1, mod2->parsed->imports[0].module); |
| assert_true((LYS_MOD_LATEST_REV | LYS_MOD_IMPORTED_REV) & mod1->latest_revision); |
| assert_string_equal("2019-09-16", mod1->revision); |
| assert_int_equal(1, mod1->implemented); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-16")); |
| ly_ctx_destroy(UTEST_LYCTX); |
| |
| /* Import callback provides older revision of module 'a' and it is |
| * imported by another module, so it is preferred even if newer |
| * revision is implemented later. */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX)); |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module a {namespace urn:a; prefix a; revision 2019-09-16;}"); |
| assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module b {namespace urn:b;prefix b;import a {prefix a;}}", |
| LYS_IN_YANG, &mod2)); |
| assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module a {namespace urn:a;prefix a;revision 2019-09-17;}", |
| LYS_IN_YANG, &mod1)); |
| ly_log_level(LY_LLVRB); |
| assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module c {namespace urn:c;prefix c;import a {prefix a;}}", |
| LYS_IN_YANG, &mod3)); |
| CHECK_LOG("Implemented module \"a@2019-09-17\" is not used for import, revision \"2019-09-16\" is imported instead.", NULL); |
| ly_log_level(LY_LLWRN); |
| assert_true(LYS_MOD_LATEST_SEARCHDIRS & mod1->latest_revision); |
| assert_int_equal(1, mod1->implemented); |
| import = mod2->parsed->imports[0].module; |
| assert_true(LYS_MOD_IMPORTED_REV & import->latest_revision); |
| assert_string_equal("2019-09-16", import->revision); |
| assert_int_equal(0, import->implemented); |
| import = mod3->parsed->imports[0].module; |
| assert_string_equal("2019-09-16", import->revision); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-16")); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "a", "2019-09-17")); |
| assert_string_equal("2019-09-17", ly_ctx_get_module_implemented(UTEST_LYCTX, "a")->revision); |
| ly_ctx_destroy(UTEST_LYCTX); |
| |
| /* check of circular dependency */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, ctx_options, &UTEST_LYCTX)); |
| str = "module a {namespace urn:a; prefix a;" |
| "import b {prefix b;}" |
| "}"; |
| ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, str); |
| str = "module b { yang-version 1.1; namespace urn:b; prefix b;" |
| "import a {prefix a;}" |
| "}"; |
| assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, str, LYS_IN_YANG, NULL)); |
| } |
| |
| static void |
| test_get_models(void **state) |
| { |
| struct lys_module *mod, *mod2; |
| const char *str0 = "module a {namespace urn:a;prefix a;}"; |
| const char *str1 = "module a {namespace urn:a;prefix a;revision 2018-10-23;}"; |
| const char *str2 = "module a {namespace urn:a;prefix a;revision 2018-10-23;revision 2018-10-24;}"; |
| struct ly_in *in0, *in1, *in2; |
| struct lys_glob_unres unres = {0}; |
| |
| unsigned int index = 0; |
| const char *names[] = {"ietf-yang-metadata", "yang", "ietf-inet-types", "ietf-yang-types", "ietf-datastores", "ietf-yang-library", "a", "a", "a"}; |
| |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory(str0, &in0)); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory(str1, &in1)); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory(str2, &in2)); |
| |
| /* invalid arguments */ |
| assert_ptr_equal(NULL, ly_ctx_get_module(NULL, NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_module()).", NULL); |
| assert_ptr_equal(NULL, ly_ctx_get_module(UTEST_LYCTX, NULL, NULL)); |
| CHECK_LOG_CTX("Invalid argument name (ly_ctx_get_module()).", NULL); |
| assert_ptr_equal(NULL, ly_ctx_get_module_ns(NULL, NULL, NULL)); |
| CHECK_LOG("Invalid argument ctx (ly_ctx_get_module_ns()).", NULL); |
| assert_ptr_equal(NULL, ly_ctx_get_module_ns(UTEST_LYCTX, NULL, NULL)); |
| CHECK_LOG_CTX("Invalid argument ns (ly_ctx_get_module_ns()).", NULL); |
| assert_null(ly_ctx_get_module(UTEST_LYCTX, "nonsence", NULL)); |
| |
| /* internal modules */ |
| assert_null(ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-yang-types")); |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "yang"); |
| assert_non_null(mod); |
| assert_non_null(mod->parsed); |
| assert_string_equal("yang", mod->name); |
| mod2 = ly_ctx_get_module_implemented_ns(UTEST_LYCTX, mod->ns); |
| assert_ptr_equal(mod, mod2); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-yang-metadata", "2016-08-05")); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-yang-types", "2013-07-15")); |
| assert_non_null(ly_ctx_get_module(UTEST_LYCTX, "ietf-inet-types", "2013-07-15")); |
| assert_non_null(ly_ctx_get_module_ns(UTEST_LYCTX, "urn:ietf:params:xml:ns:yang:ietf-datastores", "2018-02-14")); |
| |
| /* select module by revision */ |
| assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, &mod)); |
| /* invalid attempts - implementing module of the same name and inserting the same module */ |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in2, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2)); |
| assert_int_equal(LY_EDENIED, lys_implement(mod2, NULL, &unres)); |
| CHECK_LOG_CTX("Module \"a@2018-10-24\" is present in the context in other implemented revision (2018-10-23).", NULL); |
| lys_unres_glob_erase(&unres); |
| ly_in_reset(in1); |
| /* it is already there, fine */ |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, NULL, &unres.creating, NULL)); |
| /* insert the second module only as imported, not implemented */ |
| lys_unres_glob_erase(&unres); |
| ly_in_reset(in2); |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in2, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod2)); |
| lys_unres_glob_erase(&unres); |
| assert_non_null(mod2); |
| assert_ptr_not_equal(mod, mod2); |
| mod = ly_ctx_get_module_latest(UTEST_LYCTX, "a"); |
| assert_ptr_equal(mod, mod2); |
| mod2 = ly_ctx_get_module_latest_ns(UTEST_LYCTX, mod->ns); |
| assert_ptr_equal(mod, mod2); |
| /* work with module with no revision */ |
| assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in0, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod)); |
| lys_unres_glob_erase(&unres); |
| assert_ptr_equal(mod, ly_ctx_get_module(UTEST_LYCTX, "a", NULL)); |
| assert_ptr_not_equal(mod, ly_ctx_get_module_latest(UTEST_LYCTX, "a")); |
| |
| str1 = "submodule b {belongs-to a {prefix a;}}"; |
| ly_in_free(in1, 0); |
| assert_int_equal(LY_SUCCESS, ly_in_new_memory(str1, &in1)); |
| assert_int_equal(LY_EINVAL, lys_parse_in(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod)); |
| CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL); |
| lys_unres_glob_erase(&unres); |
| |
| while ((mod = (struct lys_module *)ly_ctx_get_module_iter(UTEST_LYCTX, &index))) { |
| assert_string_equal(names[index - 1], mod->name); |
| } |
| assert_int_equal(9, index); |
| |
| /* cleanup */ |
| ly_in_free(in0, 0); |
| ly_in_free(in1, 0); |
| ly_in_free(in2, 0); |
| } |
| |
| static void |
| test_ylmem(void **state) |
| { |
| #define DATA_YANG_LIBRARY_START "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"\ |
| " <module-set>\n"\ |
| " <name>complete</name>\n"\ |
| " <module>\n"\ |
| " <name>yang</name>\n"\ |
| " <revision>2021-04-07</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>ietf-yang-library</name>\n"\ |
| " <revision>2019-01-04</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n"\ |
| " </module>\n" |
| |
| #define DATA_YANG_BASE_IMPORTS " <import-only-module>\n"\ |
| " <name>ietf-yang-metadata</name>\n"\ |
| " <revision>2016-08-05</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n"\ |
| " </import-only-module>\n"\ |
| " <import-only-module>\n"\ |
| " <name>ietf-inet-types</name>\n"\ |
| " <revision>2013-07-15</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n"\ |
| " </import-only-module>\n"\ |
| " <import-only-module>\n"\ |
| " <name>ietf-yang-types</name>\n"\ |
| " <revision>2013-07-15</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n"\ |
| " </import-only-module>\n"\ |
| " <import-only-module>\n"\ |
| " <name>ietf-datastores</name>\n"\ |
| " <revision>2018-02-14</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n"\ |
| " </import-only-module>\n" |
| |
| #define DATA_YANG_SCHEMA_MODULE_STATE " </module-set>\n"\ |
| " <schema>\n"\ |
| " <name>complete</name>\n"\ |
| " <module-set>complete</module-set>\n"\ |
| " </schema>\n"\ |
| " <content-id>9</content-id>\n"\ |
| "</yang-library>\n"\ |
| "<modules-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n"\ |
| " <module-set-id>12</module-set-id>\n"\ |
| " <module>\n"\ |
| " <name>ietf-yang-metadata</name>\n"\ |
| " <revision>2016-08-05</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n"\ |
| " <conformance-type>import</conformance-type>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>yang</name>\n"\ |
| " <revision>2020-06-17</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n"\ |
| " <conformance-type>implement</conformance-type>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>ietf-inet-types</name>\n"\ |
| " <revision>2013-07-15</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n"\ |
| " <conformance-type>import</conformance-type>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>ietf-yang-types</name>\n"\ |
| " <revision>2013-07-15</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n"\ |
| " <conformance-type>import</conformance-type>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>ietf-yang-library</name>\n"\ |
| " <revision>2019-01-04</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n"\ |
| " <conformance-type>implement</conformance-type>\n"\ |
| " </module>\n"\ |
| " <module>\n"\ |
| " <name>ietf-datastores</name>\n"\ |
| " <revision>2018-02-14</revision>\n"\ |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n"\ |
| " <conformance-type>import</conformance-type>\n"\ |
| " </module>\n" |
| |
| const char *yanglibrary_only = |
| DATA_YANG_LIBRARY_START |
| DATA_YANG_BASE_IMPORTS |
| DATA_YANG_SCHEMA_MODULE_STATE |
| "</modules-state>\n"; |
| |
| const char *with_netconf = |
| DATA_YANG_LIBRARY_START |
| " <module>\n" |
| " <name>ietf-netconf</name>\n" |
| " <revision>2011-06-01</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n" |
| " </module>\n" |
| DATA_YANG_BASE_IMPORTS |
| " <import-only-module>\n" |
| " <name>ietf-netconf-acm</name>\n" |
| " <revision>2018-02-14</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n" |
| " </import-only-module>\n" |
| DATA_YANG_SCHEMA_MODULE_STATE |
| " <module>\n" |
| " <name>ietf-netconf</name>\n" |
| " <revision>2011-06-01</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n" |
| " <conformance-type>implement</conformance-type>\n" |
| " </module>\n" |
| " <module>\n" |
| " <name>ietf-netconf-acm</name>\n" |
| " <revision>2018-02-14</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n" |
| " <conformance-type>import</conformance-type>\n" |
| " </module>\n" |
| "</modules-state>"; |
| |
| char *with_netconf_features = malloc(8096); |
| strcpy(with_netconf_features, |
| DATA_YANG_LIBRARY_START |
| " <module>\n" |
| " <name>ietf-netconf</name>\n" |
| " <revision>2011-06-01</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n" |
| " <feature>writable-running</feature>\n" |
| " <feature>candidate</feature>\n" |
| " <feature>confirmed-commit</feature>\n" |
| " <feature>rollback-on-error</feature>\n" |
| " <feature>validate</feature>\n" |
| " <feature>startup</feature>\n" |
| " <feature>url</feature>\n" |
| " <feature>xpath</feature>\n" |
| " </module>\n" |
| " <import-only-module>\n" |
| " <name>ietf-yang-metadata</name>\n" |
| " <revision>2016-08-05</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-metadata</namespace>\n" |
| " </import-only-module>\n" |
| " <import-only-module>\n" |
| " <name>ietf-inet-types</name>\n" |
| " <revision>2013-07-15</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-inet-types</namespace>\n" |
| " </import-only-module>\n" |
| " <import-only-module>\n" |
| " <name>ietf-yang-types</name>\n" |
| " <revision>2013-07-15</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-types</namespace>\n" |
| " </import-only-module>\n" |
| " <import-only-module>\n" |
| " <name>ietf-datastores</name>\n" |
| " <revision>2018-02-14</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-datastores</namespace>\n" |
| " </import-only-module>\n" |
| " <import-only-module>\n" |
| " <name>ietf-netconf-acm</name>\n" |
| " <revision>2018-02-14</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n" |
| " </import-only-module>\n"); |
| strcpy(with_netconf_features + strlen(with_netconf_features), |
| DATA_YANG_SCHEMA_MODULE_STATE |
| " <module>\n" |
| " <name>ietf-netconf</name>\n" |
| " <revision>2011-06-01</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:netconf:base:1.0</namespace>\n" |
| " <feature>writable-running</feature>\n" |
| " <feature>candidate</feature>\n" |
| " <feature>confirmed-commit</feature>\n" |
| " <feature>rollback-on-error</feature>\n" |
| " <feature>validate</feature>\n" |
| " <feature>startup</feature>\n" |
| " <feature>url</feature>\n" |
| " <feature>xpath</feature>\n" |
| " <conformance-type>implement</conformance-type>\n" |
| " </module>\n" |
| " <module>\n" |
| " <name>ietf-netconf-acm</name>\n" |
| " <revision>2018-02-14</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-netconf-acm</namespace>\n" |
| " <conformance-type>import</conformance-type>\n" |
| " </module>\n" |
| "</modules-state>"); |
| |
| const char *garbage_revision = |
| "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n" |
| " <module-set>\n" |
| " <name>complete</name>\n" |
| " <module>\n" |
| " <name>yang</name>\n" |
| " <revision>2020-06-17</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n" |
| " </module>\n" |
| " <module>\n" |
| " <name>ietf-yang-library</name>\n" |
| " <revision>2019-01-01</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:ietf-yang-library</namespace>\n" |
| " </module>\n" |
| DATA_YANG_BASE_IMPORTS |
| DATA_YANG_SCHEMA_MODULE_STATE |
| "</modules-state>\n"; |
| |
| const char *no_yanglibrary = |
| "<yang-library xmlns=\"urn:ietf:params:xml:ns:yang:ietf-yang-library\">\n" |
| " <module-set>\n" |
| " <name>complete</name>\n" |
| " <module>\n" |
| " <name>yang</name>\n" |
| " <revision>2021-04-07</revision>\n" |
| " <namespace>urn:ietf:params:xml:ns:yang:1</namespace>\n" |
| " </module>\n" |
| DATA_YANG_BASE_IMPORTS |
| DATA_YANG_SCHEMA_MODULE_STATE |
| "</modules-state>\n"; |
| |
| (void) state; |
| /* seperate context to avoid double free during teadown */ |
| struct ly_ctx *ctx_test = NULL; |
| |
| /* test invalid parameters */ |
| assert_int_equal(LY_EINVAL, ly_ctx_new_ylpath(NULL, NULL, LYD_XML, 0, &ctx_test)); |
| assert_int_equal(LY_EINVAL, ly_ctx_new_ylpath(NULL, TESTS_SRC, LYD_XML, 0, NULL)); |
| assert_int_equal(LY_ESYS, ly_ctx_new_ylpath(NULL, TESTS_SRC "garbage", LYD_XML, 0, &ctx_test)); |
| |
| /* basic test with ietf-yang-library-only */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", yanglibrary_only, LYD_XML, 0, &ctx_test)); |
| assert_non_null(ly_ctx_get_module(ctx_test, "ietf-yang-library", "2019-01-04")); |
| assert_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01")); |
| ly_ctx_destroy(ctx_test); |
| |
| /* test loading module, should also import other module */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf, LYD_XML, 0, &ctx_test)); |
| assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01")); |
| assert_int_equal(1, ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01")->implemented); |
| assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14")); |
| assert_int_equal(0, ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14")->implemented); |
| assert_int_equal(LY_ENOT, lys_feature_value(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"), "url")); |
| ly_ctx_destroy(ctx_test); |
| |
| /* test loading module with feature if they are present */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf_features, LYD_XML, 0, &ctx_test)); |
| assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01")); |
| assert_non_null(ly_ctx_get_module(ctx_test, "ietf-netconf-acm", "2018-02-14")); |
| assert_int_equal(LY_SUCCESS, lys_feature_value(ly_ctx_get_module(ctx_test, "ietf-netconf", "2011-06-01"), "url")); |
| ly_ctx_destroy(ctx_test); |
| |
| /* test with not matching revision */ |
| assert_int_equal(LY_EINVAL, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", garbage_revision, LYD_XML, 0, &ctx_test)); |
| |
| /* test data containing ietf-yang-library which conflicts with the option */ |
| assert_int_equal(LY_EINVAL, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", with_netconf_features, LYD_XML, LY_CTX_NO_YANGLIBRARY, &ctx_test)); |
| |
| /* test creating without ietf-yang-library */ |
| assert_int_equal(LY_SUCCESS, ly_ctx_new_ylmem(TESTS_SRC "/modules/yang/", no_yanglibrary, LYD_XML, LY_CTX_NO_YANGLIBRARY, &ctx_test)); |
| assert_int_equal(NULL, ly_ctx_get_module(ctx_test, "ietf-yang-library", "2019-01-04")); |
| ly_ctx_destroy(ctx_test); |
| free(with_netconf_features); |
| } |
| |
| static LY_ERR |
| check_node_priv_parsed_is_set(struct lysc_node *node, void *data, ly_bool *UNUSED(dfs_continue)) |
| { |
| const struct lysp_node *pnode; |
| const char ***iter; |
| |
| pnode = (const struct lysp_node *)node->priv; |
| CHECK_POINTER(pnode, 1); |
| iter = (const char ***)data; |
| CHECK_POINTER(**iter, 1); |
| CHECK_STRING(pnode->name, **iter); |
| (*iter)++; |
| |
| return LY_SUCCESS; |
| } |
| |
| static LY_ERR |
| check_node_priv_parsed_not_set(struct lysc_node *node, void *UNUSED(data), ly_bool *UNUSED(dfs_continue)) |
| { |
| CHECK_POINTER(node->priv, 0); |
| return LY_SUCCESS; |
| } |
| |
| static void |
| check_ext_instance_priv_parsed_is_set(struct lysc_ext_instance *ext) |
| { |
| LY_ARRAY_COUNT_TYPE u, v; |
| struct lysc_ext_substmt *substmts; |
| struct lysc_node *cnode; |
| const char **iter; |
| const char *check[] = { |
| "tmp_cont", "lf", NULL |
| }; |
| |
| LY_ARRAY_FOR(ext, u) { |
| substmts = ext[u].substmts; |
| LY_ARRAY_FOR(substmts, v) { |
| if (substmts && substmts[v].storage && LY_STMT_IS_NODE(substmts[v].stmt)) { |
| cnode = *(struct lysc_node **)substmts[v].storage; |
| iter = check; |
| assert_int_equal(LY_SUCCESS, lysc_tree_dfs_full(cnode, check_node_priv_parsed_is_set, &iter)); |
| } |
| } |
| } |
| } |
| |
| static void |
| check_ext_instance_priv_parsed_not_set(struct lysc_ext_instance *ext) |
| { |
| LY_ARRAY_COUNT_TYPE u, v; |
| struct lysc_ext_substmt *substmts; |
| struct lysc_node *cnode; |
| |
| LY_ARRAY_FOR(ext, u) { |
| substmts = ext[u].substmts; |
| LY_ARRAY_FOR(substmts, v) { |
| if (substmts && substmts[v].storage && LY_STMT_IS_NODE(substmts[v].stmt)) { |
| cnode = *(struct lysc_node **)substmts[v].storage; |
| if (cnode) { |
| CHECK_POINTER((struct lysp_node *)cnode->priv, 0); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * @brief Testing of LY_CTX_SET_PRIV_PARSED. |
| */ |
| static void |
| test_set_priv_parsed(void **state) |
| { |
| struct lys_module *mod; |
| const char *schema_a; |
| const char **iter; |
| const char *check[] = { |
| "cont", "contnotif", "augleaf", "contx", "grpleaf", "l1", |
| "l1a", "l1b", "l1c", "foo1", "ll", "any", "l2", |
| "l2c", "l2cx", "ch", "cas", "casx", "oper", |
| "input", "inparam", "output", "outparam", "n1", NULL |
| }; |
| |
| /* each node must have a unique name. */ |
| schema_a = "module a {\n" |
| " namespace urn:tests:a;\n" |
| " prefix a;yang-version 1.1;\n" |
| "\n" |
| " import ietf-restconf {\n" |
| " prefix rc;\n" |
| " revision-date 2017-01-26;\n" |
| " }\n" |
| "\n" |
| " rc:yang-data \"tmp\" {\n" |
| " container tmp_cont {\n" |
| " leaf lf {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| " }\n" |
| " container cont {\n" |
| " notification contnotif;\n" |
| " leaf-list contx {\n" |
| " type string;\n" |
| " }\n" |
| " uses grp;\n" |
| " }\n" |
| " list l1 {\n" |
| " key \"l1a l1b\";\n" |
| " leaf l1a {\n" |
| " type string;\n" |
| " }\n" |
| " leaf l1b {\n" |
| " type string;\n" |
| " }\n" |
| " leaf l1c {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| " feature f1;\n" |
| " feature f2;\n" |
| " leaf foo1 {\n" |
| " type uint16;\n" |
| " if-feature f1;\n" |
| " }\n" |
| " leaf foo2 {\n" |
| " type uint16;\n" |
| " }\n" |
| " leaf foo3 {\n" |
| " type uint16;\n" |
| " if-feature f2;\n" |
| " }\n" |
| " leaf-list ll {\n" |
| " type string;\n" |
| " }\n" |
| " anydata any {\n" |
| " config false;\n" |
| " }\n" |
| " list l2 {\n" |
| " config false;\n" |
| " container l2c {\n" |
| " leaf l2cx {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| " }\n" |
| " choice ch {\n" |
| " case cas {\n" |
| " leaf casx {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| " }\n" |
| " rpc oper {\n" |
| " input {\n" |
| " leaf inparam {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| " output {\n" |
| " leaf outparam {\n" |
| " type int8;\n" |
| " }\n" |
| " }\n" |
| " }\n" |
| " notification n1;\n" |
| " grouping grp {\n" |
| " leaf grpleaf {\n" |
| " type uint16;\n" |
| " }\n" |
| " }\n" |
| " augment /cont {\n" |
| " leaf augleaf {\n" |
| " type uint16;\n" |
| " }\n" |
| " }\n" |
| " deviation /a:foo2 {\n" |
| " deviate not-supported;\n" |
| " }\n" |
| "}\n"; |
| |
| /* use own context with extra flags */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| const char *feats[] = {"f1", NULL}; |
| |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_SET_PRIV_PARSED, &UTEST_LYCTX)); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_DIR_MODULES_YANG)); |
| assert_non_null(ly_ctx_load_module(UTEST_LYCTX, "ietf-restconf", "2017-01-26", NULL)); |
| UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, feats, NULL); |
| |
| print_message("[ ] create context\n"); |
| mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL); |
| iter = check; |
| assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_is_set, &iter)); |
| check_ext_instance_priv_parsed_is_set(mod->compiled->exts); |
| |
| print_message("[ ] unset option\n"); |
| assert_int_equal(LY_SUCCESS, ly_ctx_unset_options(UTEST_LYCTX, LY_CTX_SET_PRIV_PARSED)); |
| mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL); |
| iter = check; |
| assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_not_set, &iter)); |
| check_ext_instance_priv_parsed_not_set(mod->compiled->exts); |
| |
| print_message("[ ] set option\n"); |
| assert_int_equal(LY_SUCCESS, ly_ctx_set_options(UTEST_LYCTX, LY_CTX_SET_PRIV_PARSED)); |
| mod = ly_ctx_get_module(UTEST_LYCTX, "a", NULL); |
| iter = check; |
| assert_int_equal(LY_SUCCESS, lysc_module_dfs_full(mod, check_node_priv_parsed_is_set, &iter)); |
| check_ext_instance_priv_parsed_is_set(mod->compiled->exts); |
| } |
| |
| static void |
| test_explicit_compile(void **state) |
| { |
| uint32_t i; |
| struct lys_module *mod; |
| const char *schema_a = "module a {\n" |
| " namespace urn:tests:a;\n" |
| " prefix a;yang-version 1.1;\n" |
| " feature f1;\n" |
| " feature f2;\n" |
| " leaf foo1 {\n" |
| " type uint16;\n" |
| " if-feature f1;\n" |
| " }\n" |
| " leaf foo2 {\n" |
| " type uint16;\n" |
| " }\n" |
| " container cont {\n" |
| " leaf foo3 {\n" |
| " type string;\n" |
| " }\n" |
| " }\n" |
| "}\n"; |
| const char *schema_b = "module b {\n" |
| " namespace urn:tests:b;\n" |
| " prefix b;yang-version 1.1;\n" |
| " import a {\n" |
| " prefix a;\n" |
| " }\n" |
| " augment /a:cont {\n" |
| " leaf augleaf {\n" |
| " type uint16;\n" |
| " }\n" |
| " }\n" |
| "}\n"; |
| const char *schema_c = "module c {\n" |
| " namespace urn:tests:c;\n" |
| " prefix c;yang-version 1.1;\n" |
| " import a {\n" |
| " prefix a;\n" |
| " }\n" |
| " deviation /a:foo2 {\n" |
| " deviate not-supported;\n" |
| " }\n" |
| "}\n"; |
| |
| /* use own context with extra flags */ |
| ly_ctx_destroy(UTEST_LYCTX); |
| const char *feats[] = {"f1", NULL}; |
| |
| assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_EXPLICIT_COMPILE, &UTEST_LYCTX)); |
| UTEST_ADD_MODULE(schema_a, LYS_IN_YANG, NULL, &mod); |
| UTEST_ADD_MODULE(schema_b, LYS_IN_YANG, NULL, NULL); |
| UTEST_ADD_MODULE(schema_c, LYS_IN_YANG, NULL, NULL); |
| assert_int_equal(LY_SUCCESS, lys_set_implemented((struct lys_module *)mod, feats)); |
| |
| /* none of the modules should be compiled */ |
| i = 0; |
| while ((mod = ly_ctx_get_module_iter(UTEST_LYCTX, &i))) { |
| assert_null(mod->compiled); |
| } |
| |
| assert_int_equal(LY_SUCCESS, ly_ctx_compile(UTEST_LYCTX)); |
| |
| /* check internal modules */ |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "yang"); |
| assert_non_null(mod); |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-datastores"); |
| assert_non_null(mod); |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "ietf-yang-library"); |
| assert_non_null(mod); |
| |
| /* check test modules */ |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "a"); |
| assert_non_null(mod); |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "b"); |
| assert_non_null(mod); |
| mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "c"); |
| assert_non_null(mod); |
| } |
| |
| int |
| main(void) |
| { |
| const struct CMUnitTest tests[] = { |
| UTEST(test_searchdirs), |
| UTEST(test_options), |
| UTEST(test_models), |
| UTEST(test_imports), |
| UTEST(test_get_models), |
| UTEST(test_ylmem), |
| UTEST(test_set_priv_parsed), |
| UTEST(test_explicit_compile), |
| }; |
| |
| return cmocka_run_group_tests(tests, NULL, NULL); |
| } |