diff --git a/src/ly_common.c b/src/ly_common.c index 91a6c4e7a2..e30f9a4209 100644 --- a/src/ly_common.c +++ b/src/ly_common.c @@ -1955,124 +1955,3 @@ ly_parse_nodeid(const char **id, const char **prefix, uint32_t *prefix_len, cons return LY_SUCCESS; } - -LY_ERR -ly_parse_instance_predicate(const char **pred, uint32_t limit, LYD_FORMAT format, const char **prefix, uint32_t *prefix_len, - const char **id, uint32_t *id_len, const char **value, uint32_t *value_len, const char **errmsg) -{ - LY_ERR ret = LY_EVALID; - const char *in = *pred; - uint32_t offset = 1; - uint8_t expr = 0; /* 0 - position predicate; 1 - leaf-list-predicate; 2 - key-predicate */ - char quot; - - assert(in[0] == '['); - - *prefix = *id = *value = NULL; - *prefix_len = *id_len = *value_len = 0; - - /* leading *WSP */ - for ( ; isspace(in[offset]); offset++) {} - - if (isdigit(in[offset])) { - /* pos: "[" *WSP positive-integer-value *WSP "]" */ - if (in[offset] == '0') { - /* zero */ - *errmsg = "The position predicate cannot be zero."; - goto error; - } - - /* positive-integer-value */ - *value = &in[offset++]; - for ( ; isdigit(in[offset]); offset++) {} - *value_len = &in[offset] - *value; - - } else if (in[offset] == '.') { - /* leaf-list-predicate: "[" *WSP "." *WSP "=" *WSP quoted-string *WSP "]" */ - *id = &in[offset]; - *id_len = 1; - offset++; - expr = 1; - } else if (in[offset] == '-') { - /* typically negative value */ - *errmsg = "Invalid instance predicate format (negative position or invalid node-identifier)."; - goto error; - } else { - /* key-predicate: "[" *WSP node-identifier *WSP "=" *WSP quoted-string *WSP "]" */ - in = &in[offset]; - if (ly_parse_nodeid(&in, prefix, prefix_len, id, id_len)) { - *errmsg = "Invalid node-identifier."; - goto error; - } - if ((format == LYD_XML) && !(*prefix)) { - /* all node names MUST be qualified with explicit namespace prefix */ - *errmsg = "Missing prefix of a node name."; - goto error; - } - offset = in - *pred; - in = *pred; - expr = 2; - } - - if (expr) { - /* *WSP "=" *WSP quoted-string *WSP "]" */ - for ( ; isspace(in[offset]); offset++) {} - - if (in[offset] != '=') { - if (expr == 1) { - *errmsg = "Unexpected character instead of \'=\' in leaf-list-predicate."; - } else { /* 2 */ - *errmsg = "Unexpected character instead of \'=\' in key-predicate."; - } - goto error; - } - offset++; - for ( ; isspace(in[offset]); offset++) {} - - /* quoted-string */ - quot = in[offset++]; - if ((quot != '\'') && (quot != '\"')) { - *errmsg = "String value is not quoted."; - goto error; - } - *value = &in[offset]; - for ( ; offset < limit && (in[offset] != quot || (offset && in[offset - 1] == '\\')); offset++) {} - if (in[offset] == quot) { - *value_len = &in[offset] - *value; - offset++; - } else { - *errmsg = "Value is not terminated quoted-string."; - goto error; - } - } - - /* *WSP "]" */ - for ( ; isspace(in[offset]); offset++) {} - if (in[offset] != ']') { - if (expr == 0) { - *errmsg = "Predicate (pos) is not terminated by \']\' character."; - } else if (expr == 1) { - *errmsg = "Predicate (leaf-list-predicate) is not terminated by \']\' character."; - } else { /* 2 */ - *errmsg = "Predicate (key-predicate) is not terminated by \']\' character."; - } - goto error; - } - offset++; - - if (offset <= limit) { - *pred = &in[offset]; - return LY_SUCCESS; - } - - /* we read after the limit */ - *errmsg = "Predicate is incomplete."; - *prefix = *id = *value = NULL; - *prefix_len = *id_len = *value_len = 0; - offset = limit; - ret = LY_EINVAL; - -error: - *pred = &in[offset]; - return ret; -} diff --git a/src/ly_common.h b/src/ly_common.h index 5e5f629e79..571bf7285c 100644 --- a/src/ly_common.h +++ b/src/ly_common.h @@ -804,29 +804,6 @@ LY_ERR ly_parse_uint(const char *val_str, uint32_t val_len, uint64_t max, int ba */ LY_ERR ly_parse_nodeid(const char **id, const char **prefix, uint32_t *prefix_len, const char **name, uint32_t *name_len); -/** - * @brief parse instance-identifier's predicate, supports key-predicate, leaf-list-predicate and pos rules from YANG ABNF Grammar. - * - * @param[in,out] pred Predicate string (including the leading '[') to parse. The string is updated according to what was parsed - * (even for error case, so it can be used to determine which substring caused failure). - * @param[in] limit Limiting length of the @p pred. Function expects NULL terminated string which is not overread. - * The limit value is not checked with each character, so it can be overread and the failure is detected later. - * @param[in] format Input format of the data containing the @p pred. - * @param[out] prefix Start of the node-identifier's prefix if any, NULL in case of pos or leaf-list-predicate rules. - * @param[out] prefix_len Length of the parsed @p prefix. - * @param[out] id Start of the node-identifier's identifier string, NULL in case of pos rule, "." in case of leaf-list-predicate rule. - * @param[out] id_len Length of the parsed @p id. - * @param[out] value Start of the quoted-string (without quotation marks), not NULL in case of success. - * @param[out] value_len Length of the parsed @p value. - * @param[out] errmsg Error message string in case of error. - * @return LY_SUCCESS in case a complete predicate was parsed. - * @return LY_EVALID in case of invalid predicate form. - * @return LY_EINVAL in case of reaching @p limit when parsing @p pred. - */ -LY_ERR ly_parse_instance_predicate(const char **pred, uint32_t limit, LYD_FORMAT format, - const char **prefix, uint32_t *prefix_len, const char **id, uint32_t *id_len, - const char **value, uint32_t *value_len, const char **errmsg); - /** * @brief mmap(2) wrapper to map input files into memory to unify parsing. * diff --git a/tests/utests/basic/test_common.c b/tests/utests/basic/test_common.c index 6e366c5c3b..0a8db6d1ae 100644 --- a/tests/utests/basic/test_common.c +++ b/tests/utests/basic/test_common.c @@ -14,390 +14,362 @@ #define _UTEST_MAIN_ #include "utests.h" -#include "ly_common.h" - static void -test_utf8(void **UNUSED(state)) +test_utf8(void **state) { - char buf[5] = {0}; - const char *str = buf; - unsigned int c; - uint32_t len; + int target_idx = 59; + struct ly_ctx *ctx = UTEST_LYCTX; + // array coresponds to the following YANG module: + // module test { namespace "urn:test"; prefix t; description "XXX"; } + char test_yang[] = { + 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x7b, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x22, 0x75, 0x72, 0x6e, 0x3a, 0x74, 0x65, 0x73, 0x74, 0x22, 0x3b, 0x20, + 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x74, 0x3b, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x22, + 0x58, 0x58, 0x58, 0x58, + 0x22, 0x3b, 0x20, + 0x7d, 0x00 + }; + + lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL); /* test invalid UTF-8 characters in lyxml_getutf8 - * - https://en.wikipedia.org/wiki/UTF-8 */ - buf[0] = (char)0x04; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - buf[0] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - - buf[0] = (char)0xc0; - buf[1] = (char)0x00; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - buf[1] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - - buf[0] = (char)0xe0; - buf[1] = (char)0x00; - buf[2] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - buf[1] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - - buf[0] = (char)0xf0; - buf[1] = (char)0x00; - buf[2] = (char)0x80; - buf[3] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); - buf[1] = (char)0x80; - assert_int_equal(LY_EINVAL, ly_getutf8(&str, &c, &len)); + * - https://en.wikipedia.org/wiki/UTF-8 */ + test_yang[target_idx] = (char)0x04; + + /* invalid values */ + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + + test_yang[target_idx] = (char)0xc0; + test_yang[target_idx + 1] = (char)0x20; + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + + test_yang[target_idx + 1] = (char)0x80; + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + + test_yang[target_idx] = (char)0xe0; + test_yang[target_idx + 1] = (char)0x20; + test_yang[target_idx + 2] = (char)0x80; + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + + test_yang[target_idx] = (char)0xf0; + test_yang[target_idx + 1] = (char)0x20; + test_yang[target_idx + 2] = (char)0x80; + test_yang[target_idx + 3] = (char)0x80; + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, test_yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; } static void -test_parse_int(void **UNUSED(state)) +test_parse_int(void **state) { + struct ly_ctx *ctx = UTEST_LYCTX; + struct lys_module *mod = NULL; + struct lyd_node *node = NULL; const char *str; - int64_t i = 500; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf l {" + " type int8;" + " }" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, &mod)); + + /* correct value */ str = "10"; - assert_int_equal(LY_SUCCESS, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); - assert_int_equal(i, 10); + assert_int_equal(LY_SUCCESS, lyd_new_term(NULL, mod, "l", str, 0, &node)); + assert_string_equal("10", lyd_get_value(node)); /* leading zeros are allowed, trailing whitespaces are allowed */ str = "000\n\t "; - assert_int_equal(LY_SUCCESS, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); - assert_int_equal(i, 0); + assert_int_equal(LY_SUCCESS, lyd_change_term(node, str)); + assert_string_equal("0", lyd_get_value(node)); /* negative value */ str = "-10"; - assert_int_equal(LY_SUCCESS, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); - assert_int_equal(i, -10); - - /* non-NULL terminated string */ - str = "+5sometext"; - assert_int_equal(LY_SUCCESS, ly_parse_int(str, 2, -10, 10, 10, &i)); - assert_int_equal(i, 5); + assert_int_equal(LY_SUCCESS, lyd_change_term(node, str)); + assert_string_equal("-10", lyd_get_value(node)); /* out of bounds value */ - str = "11"; - assert_int_equal(LY_EDENIED, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); - str = "-11"; - assert_int_equal(LY_EDENIED, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); + str = "128"; + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; + + str = "-129"; + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; /* NaN */ str = "zero"; - assert_int_equal(LY_EVALID, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; /* mixing number with text */ str = "10zero"; - assert_int_equal(LY_EVALID, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; str = "10 zero"; - assert_int_equal(LY_EVALID, ly_parse_int(str, strlen(str), -10, 10, 10, &i)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; + + lyd_free_all(node); } static void -test_parse_uint(void **UNUSED(state)) +test_parse_uint(void **state) { + struct ly_ctx *ctx = UTEST_LYCTX; + struct lys_module *mod = NULL; + struct lyd_node *node = NULL; const char *str; - uint64_t u = 500; - + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf l {" + " type uint8;" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, &mod)); + /* correct value */ str = "10"; - assert_int_equal(LY_SUCCESS, ly_parse_uint(str, strlen(str), 10, 10, &u)); - assert_int_equal(u, 10); + assert_int_equal(LY_SUCCESS, lyd_new_term(NULL, mod, "l", str, 0, &node)); + assert_string_equal("10", lyd_get_value(node)); /* leading zeros are allowed, trailing whitespaces are allowed */ str = "000\n\t "; - assert_int_equal(LY_SUCCESS, ly_parse_uint(str, strlen(str), 10, 10, &u)); - assert_int_equal(u, 0); - /* non-NULL terminated string */ - str = "+5sometext"; - assert_int_equal(LY_SUCCESS, ly_parse_uint(str, 2, 10, 10, &u)); - assert_int_equal(u, 5); + assert_int_equal(LY_SUCCESS, lyd_change_term(node, str)); + assert_string_equal("0", lyd_get_value(node)); /* out of bounds value */ - str = "11"; - assert_int_equal(LY_EDENIED, ly_parse_uint(str, strlen(str), 10, 10, &u)); + str = "256"; + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; + str = "-1"; - assert_int_equal(LY_EDENIED, ly_parse_uint(str, strlen(str), (uint64_t)-1, 10, &u)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; /* NaN */ str = "zero"; - assert_int_equal(LY_EVALID, ly_parse_uint(str, strlen(str), 10, 10, &u)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; /* mixing number with text */ str = "10zero"; - assert_int_equal(LY_EVALID, ly_parse_uint(str, strlen(str), 10, 10, &u)); + assert_int_equal(LY_EVALID, lyd_change_term(node, str)); + UTEST_LOG_CTX_CLEAN; - str = "10 zero"; - assert_int_equal(LY_EVALID, ly_parse_uint(str, strlen(str), 10, 10, &u)); + lyd_free_all(node); } static void -test_parse_nodeid(void **UNUSED(state)) +test_parse_nodeid(void **state) { + struct ly_ctx *ctx = UTEST_LYCTX; + struct lys_module *mod_data = NULL; + struct lys_module *mod_meta = NULL; + struct lyd_node *node = NULL; + struct lyd_meta *meta = NULL; const char *str; - const char *prefix, *name; - uint32_t prefix_len, name_len; - + const char *yang_meta = + "module my-meta {" + " namespace \"urn:my-meta\";" + " prefix mm;" + " import ietf-yang-metadata { prefix md; }" + " md:annotation a12_-. {" + " type string;" + " }\n" + "}"; + const char *yang_data = + "module my-data {" + " namespace \"urn:my-data\";" + " prefix md;" + " leaf interface { type string; }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang_meta, LYS_IN_YANG, &mod_meta)); + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang_data, LYS_IN_YANG, &mod_data)); + + /* invalid starting character */ + lyd_new_path(NULL, ctx, "/my-data:interface", "eth0", 0, &node); str = "123"; - assert_int_equal(LY_EINVAL, ly_parse_nodeid(&str, &prefix, &prefix_len, &name, &name_len)); + assert_int_equal(LY_EINVAL, lyd_new_meta(ctx, node, mod_meta, str, "delete", 0, &meta)); + UTEST_LOG_CTX_CLEAN; + /* invalid character in the name */ str = "a12_-.!"; - assert_int_equal(LY_SUCCESS, ly_parse_nodeid(&str, &prefix, &prefix_len, &name, &name_len)); - assert_null(prefix); - assert_int_equal(0, prefix_len); - assert_non_null(name); - assert_int_equal(6, name_len); - assert_int_equal(0, strncmp("a12_-.", name, name_len)); - assert_string_equal("!", str); - - str = "a12_-.:_b2 xxx"; - assert_int_equal(LY_SUCCESS, ly_parse_nodeid(&str, &prefix, &prefix_len, &name, &name_len)); - assert_non_null(prefix); - assert_int_equal(6, prefix_len); - assert_int_equal(0, strncmp("a12_-.", prefix, prefix_len)); - assert_non_null(name); - assert_int_equal(3, name_len); - assert_int_equal(0, strncmp("_b2", name, name_len)); - assert_string_equal(" xxx", str); + assert_int_equal(LY_EINVAL, lyd_new_meta(ctx, node, mod_meta, str, "delete", 0, &meta)); + UTEST_LOG_CTX_CLEAN; + + /* correct name */ + str = "a12_-."; + assert_int_equal(LY_SUCCESS, lyd_new_meta(ctx, node, mod_meta, str, "delete", 0, &meta)); + lyd_free_all(node); } static void -test_parse_instance_predicate(void **UNUSED(state)) +test_parse_instance_predicate(void **state) { - const char *str, *errmsg; - const char *prefix, *id, *value; - uint32_t prefix_len, id_len, value_len; - - str = "[ex:name='fred']"; - assert_int_equal(LY_SUCCESS, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(str, ""); - assert_string_equal(prefix, "ex:name='fred']"); - assert_int_equal(prefix_len, 2); - assert_string_equal(id, "name='fred']"); - assert_int_equal(id_len, 4); - assert_string_equal(value, "fred']"); - assert_int_equal(value_len, 4); - - str = "[ex:ip = \"[192.0.2.1]\"][ex:port='80']"; - assert_int_equal(LY_SUCCESS, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(str, "[ex:port='80']"); - assert_string_equal(prefix, "ex:ip = \"[192.0.2.1]\"][ex:port='80']"); - assert_int_equal(prefix_len, 2); - assert_string_equal(id, "ip = \"[192.0.2.1]\"][ex:port='80']"); - assert_int_equal(id_len, 2); - assert_string_equal(value, "[192.0.2.1]\"][ex:port='80']"); - assert_int_equal(value_len, 11); - - str = "[. = 'blowfish-cbc']"; - assert_int_equal(LY_SUCCESS, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(str, ""); - assert_null(prefix); - assert_int_equal(prefix_len, 0); - assert_string_equal(id, ". = 'blowfish-cbc']"); - assert_int_equal(id_len, 1); - assert_string_equal(value, "blowfish-cbc']"); - assert_int_equal(value_len, 12); - - str = "[ 3 ]"; - assert_int_equal(LY_SUCCESS, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(str, ""); - assert_null(prefix); - assert_int_equal(prefix_len, 0); - assert_null(id); - assert_int_equal(id_len, 0); - assert_string_equal(value, "3 ]"); - assert_int_equal(value_len, 1); + struct ly_ctx *ctx = UTEST_LYCTX; + struct lys_module *mod = NULL; + struct lyd_node *node = NULL; + struct lyd_node *tree = NULL; + struct ly_set *set = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " list user {" + " key \"name\";" + " leaf name { " + " type string;" + " }" + " } " + " list router {" + " key \"ip port\";" + " leaf ip { type string; }" + " leaf port { type uint16; }" + " } " + " leaf-list cipher {" + " type string;" + " }" + " leaf l {" + " type instance-identifier {" + " require-instance false;" + " }" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, &mod)); + + /* correct predicates */ + assert_int_equal(LY_SUCCESS, lyd_new_term(NULL, mod, "l", "/test:user[name='fred']", 0, &node)); + lyd_free_all(node); + assert_int_equal(LY_SUCCESS, lyd_new_term(NULL, mod, "l", "/test:router[ip='192.0.2.1'][port='80']", 0, &node)); + lyd_free_all(node); + assert_int_equal(LY_SUCCESS, lyd_new_term(NULL, mod, "l", "/test:cipher[. = 'blowfish-cbc']", 0, &node)); + lyd_free_all(node); + + assert_int_equal(LY_SUCCESS, lyd_new_path(NULL, ctx, "/test:user[name='alice']", NULL, 0, &tree)); + assert_int_equal(LY_SUCCESS, lyd_new_path(tree, ctx, "/test:user[name='bob']", NULL, 0, NULL)); + assert_int_equal(LY_SUCCESS, lyd_new_path(tree, ctx, "/test:user[name='cyril']", NULL, 0, NULL)); + + assert_int_equal(LY_SUCCESS, lyd_find_xpath(tree, "/test:user[ 3 ]", &set)); + assert_non_null(set); + assert_int_equal(1, set->count); + ly_set_free(set, NULL); /* invalid predicates */ - /* position must be positive integer */ - str = "[0]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "The position predicate cannot be zero."); - str = "[-1]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Invalid instance predicate format (negative position or invalid node-identifier)."); + assert_int_equal(LY_SUCCESS, lyd_find_xpath(tree, "/test:user[ 0 ]", &set)); + assert_non_null(set); + assert_int_equal(0, set->count); + ly_set_free(set, NULL); + + assert_int_equal(LY_SUCCESS, lyd_find_xpath(tree, "/test:user[ -1 ]", &set)); + assert_non_null(set); + assert_int_equal(0, set->count); + ly_set_free(set, NULL); /* invalid node-identifier */ - str = "[$node='value']"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Invalid node-identifier."); - str = "[.node='value']"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Unexpected character instead of '=' in leaf-list-predicate."); - str = "[13node='value']"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Predicate (pos) is not terminated by \']\' character."); - - str = "[ex:node]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Unexpected character instead of '=' in key-predicate."); - - str = "[ex:node= value]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "String value is not quoted."); - - str = "[ex:node='value\"]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Value is not terminated quoted-string."); - - str = "[ex:node='value ]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Value is not terminated quoted-string."); - - str = "[ex:node=\"value\"[3]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Predicate (key-predicate) is not terminated by \']\' character."); - str = "[.=\"value\"[3]"; - assert_int_equal(LY_EVALID, ly_parse_instance_predicate(&str, strlen(str), LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Predicate (leaf-list-predicate) is not terminated by \']\' character."); - - /* the limit of the string is too short, it ends one character earlier */ - str = "[ex:node='value']"; - assert_int_equal(LY_EINVAL, ly_parse_instance_predicate(&str, strlen(str) - 1, LYD_XML, &prefix, &prefix_len, &id, &id_len, &value, &value_len, &errmsg)); - assert_string_equal(errmsg, "Predicate is incomplete."); + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[$name='fred']", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[.name='fred']", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[13name='fred']", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[name]", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[name= fred]", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[name='fred\"]", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:user[name=\"fred\"[3]", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + assert_int_equal(LY_EVALID, lyd_new_term(NULL, mod, "l", "/test:cipher[.=\"value\"[3]", 0, &node)); + UTEST_LOG_CTX_CLEAN; + + lyd_free_all(tree); } +/** + * @brief Helper function to test token translation. + * + * @param token The input token to translate. + * @param tok_len The length of the input token. + * @param is_nametest Whether the token is a name test. + * @param mod The YANG module. + * @param expected_ret The expected return value. + * @param expected_out The expected output token. + */ static void -test_value_prefix_next(void **UNUSED(state)) +assert_token_translation(const char *token, uint16_t tok_len, ly_bool is_nametest, + struct lys_module *mod, LY_ERR expected_ret) { - const char *next; - ly_bool is_prefix; - uint32_t bytes; - - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(NULL, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(0, bytes); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next("", NULL, &bytes, &is_prefix, &next)); - assert_int_equal(0, bytes); - - /* prefix */ - next = "pref:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(1, is_prefix); - - /* no-prefix */ - next = "node"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* no-prefix */ - next = "::::"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* no-prefix */ - next = "//a/:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(5, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* no-prefix */ - next = "//a//"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(5, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* prefix, prefix */ - next = "pref1:pref2:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(5, bytes); - assert_string_equal(next, "pref2:"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(5, bytes); - assert_null(next); - assert_int_equal(1, is_prefix); - - /* prefix, no-prefix */ - next = "pref:node"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_string_equal(next, "node"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* no-prefix, prefix */ - next = "/pref:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(1, bytes); - assert_string_equal(next, "pref:"); - assert_int_equal(0, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(1, is_prefix); - - /* no-prefix, prefix */ - next = "//pref:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(2, bytes); - assert_string_equal(next, "pref:"); - assert_int_equal(0, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(1, is_prefix); - - /* no-prefix, prefix, no-prefix */ - next = "/pref:node"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(1, bytes); - assert_string_equal(next, "pref:node"); - assert_int_equal(0, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_string_equal(next, "node"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); - - /* prefix, no-prefix, prefix */ - next = "pref:node pref:"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_string_equal(next, "node pref:"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(5, bytes); - assert_string_equal(next, "pref:"); - assert_int_equal(0, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(1, is_prefix); - - /* prefix, no-prefix, prefix, no-prefix */ - next = "pref:node /pref:node"; - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_string_equal(next, "node /pref:node"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(6, bytes); - assert_string_equal(next, "pref:node"); - assert_int_equal(0, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_string_equal(next, "node"); - assert_int_equal(1, is_prefix); - assert_int_equal(LY_SUCCESS, ly_value_prefix_next(next, NULL, &bytes, &is_prefix, &next)); - assert_int_equal(4, bytes); - assert_null(next); - assert_int_equal(0, is_prefix); + char *out_token = NULL; + const struct lys_module *context_mod = mod; + + LY_ERR ret = lyplg_type_xpath10_print_token( + token, + tok_len, + is_nametest, + &context_mod, + mod->ctx, + LY_VALUE_SCHEMA, + mod->parsed, + LY_VALUE_JSON, + NULL, + &out_token, + NULL); + + assert_int_equal(expected_ret, ret); + free(out_token); +} + +static void +test_value_prefix_next(void **state) +{ + struct ly_ctx *ctx = UTEST_LYCTX; + struct lys_module *mod = NULL; + const char *yang = + "module test {" + " namespace \"urn:test\";" + " prefix pref;" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, &mod)); + + /* Empty/NULL token */ + assert_token_translation("", 0, 1, mod, LY_SUCCESS); + + /* Valid prefix with node (Prefix translation) */ + assert_token_translation("pref:node", 9, 1, mod, LY_SUCCESS); + + /* Valid prefix only (Nametest ending in colon) */ + assert_token_translation("pref:", 5, 1, mod, LY_SUCCESS); + + /* No prefix (Standard node) */ + assert_token_translation("node", 4, 1, mod, LY_SUCCESS); + + /* Unresolved prefix */ + assert_token_translation("pref1:node", 10, 1, mod, LY_EVALID); + UTEST_LOG_CTX_CLEAN; + + /* Invalid token syntax (e.g., "::::") */ + assert_token_translation("::::", 4, 1, mod, LY_SUCCESS); } int diff --git a/tests/utests/basic/test_context.c b/tests/utests/basic/test_context.c index 1b549ab0b1..32a693c5c3 100644 --- a/tests/utests/basic/test_context.c +++ b/tests/utests/basic/test_context.c @@ -16,12 +16,20 @@ #include "context.h" #include "in.h" -#include "ly_common.h" -#include "schema_compile.h" -#include "tests_config.h" -#include "tree_schema_internal.h" + +static int +get_dirs_count(const char * const *list) +{ + int count = 0; + + while (list[count]) { + count++; + } + return count; +} #ifdef _WIN32 +# define PATH_SEPARATOR ";" static void slashes_to_backslashes(char *path) @@ -50,18 +58,24 @@ test_searchdirs(void **state) /* correct path */ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path1)); - assert_int_equal(2, UTEST_LYCTX->search_paths.count); - assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[1]); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(2, get_dirs_count(list)); + assert_string_equal(path1, list[1]); /* duplicated paths */ assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, path1)); - assert_int_equal(2, UTEST_LYCTX->search_paths.count); - assert_string_equal(path1, UTEST_LYCTX->search_paths.objs[1]); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(2, get_dirs_count(list)); + assert_string_equal(path1, list[1]); /* another path */ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, path2)); - assert_int_equal(3, UTEST_LYCTX->search_paths.count); - assert_string_equal(path2, UTEST_LYCTX->search_paths.objs[2]); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(3, get_dirs_count(list)); + assert_string_equal(path2, list[2]); /* get searchpaths */ list = ly_ctx_get_searchdirs(UTEST_LYCTX); @@ -77,18 +91,21 @@ test_searchdirs(void **state) /* first */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path1)); - assert_int_equal(2, UTEST_LYCTX->search_paths.count); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(2, get_dirs_count(list)); assert_string_not_equal(path1, list[1]); /* second */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, path2)); - assert_int_equal(1, UTEST_LYCTX->search_paths.count); + assert_int_equal(1, get_dirs_count(list)); free(path1); free(path2); } #else +# define PATH_SEPARATOR ":" static void test_searchdirs(void **state) @@ -116,13 +133,17 @@ test_searchdirs(void **state) /* correct path */ assert_int_equal(LY_SUCCESS, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests")); - assert_int_equal(2, UTEST_LYCTX->search_paths.count); - assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[1]); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(2, get_dirs_count(list)); + assert_string_equal(TESTS_BIN "/utests", list[1]); /* duplicated paths */ assert_int_equal(LY_EEXIST, ly_ctx_set_searchdir(UTEST_LYCTX, TESTS_BIN "/utests")); - assert_int_equal(2, UTEST_LYCTX->search_paths.count); - assert_string_equal(TESTS_BIN "/utests", UTEST_LYCTX->search_paths.objs[1]); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_non_null(list); + assert_int_equal(2, get_dirs_count(list)); + assert_string_equal(TESTS_BIN "/utests", list[1]); /* 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")); @@ -131,11 +152,11 @@ test_searchdirs(void **state) 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(8, UTEST_LYCTX->search_paths.count); /* get searchpaths */ list = ly_ctx_get_searchdirs(UTEST_LYCTX); assert_non_null(list); + assert_int_equal(8, get_dirs_count(list)); assert_string_equal(TESTS_BIN "/utests", list[1]); assert_string_equal(TESTS_BIN "/CMakeFiles", list[2]); assert_string_equal(TESTS_SRC, list[6]); @@ -149,16 +170,19 @@ test_searchdirs(void **state) /* 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(7, UTEST_LYCTX->search_paths.count); + assert_int_equal(7, get_dirs_count(list)); /* middle */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_SRC)); - assert_int_equal(6, UTEST_LYCTX->search_paths.count); + assert_int_equal(6, get_dirs_count(list)); + /* last */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, TESTS_BIN)); - assert_int_equal(5, UTEST_LYCTX->search_paths.count); + assert_int_equal(5, get_dirs_count(list)); + /* all */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL)); - assert_int_equal(0, UTEST_LYCTX->search_paths.count); + list = ly_ctx_get_searchdirs(UTEST_LYCTX); + assert_int_equal(0, get_dirs_count(list)); /* again - no change */ assert_int_equal(LY_SUCCESS, ly_ctx_unset_searchdir(UTEST_LYCTX, NULL)); @@ -205,7 +229,9 @@ test_models(void **state) struct ly_in *in; const char *str; struct lys_module *mod1, *mod2; - struct lys_glob_unres unres = {0}; + uint16_t initial_change_count, change_count; + ly_module_imp_clb clb; + void *clb_data; /* use own context with extra flags */ ly_ctx_destroy(UTEST_LYCTX); @@ -215,59 +241,59 @@ test_models(void **state) CHECK_LOG_LASTMSG("Invalid argument ctx (ly_ctx_get_change_count())."); assert_int_equal(LY_SUCCESS, ly_ctx_new(TESTS_SRC "/../modules", LY_CTX_DISABLE_SEARCHDIR_CWD, &UTEST_LYCTX)); - assert_int_equal(UTEST_LYCTX->change_count, ly_ctx_get_change_count(UTEST_LYCTX)); + initial_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, &unres.creating, &mod1)); - lys_unres_glob_erase(&unres); + lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL); + change_count = ly_ctx_get_change_count(UTEST_LYCTX); + assert_true(change_count > initial_change_count); + + assert_int_equal(LY_EINVAL, lys_parse(UTEST_LYCTX, in, 4, NULL, &mod1)); ly_in_free(in, 0); CHECK_LOG_CTX("Invalid schema input format.", NULL, 0); /* 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); + clb = ly_ctx_get_module_imp_clb(UTEST_LYCTX, &clb_data); + assert_ptr_equal(test_imp_clb, clb); + assert_ptr_equal(str, 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); + clb = ly_ctx_get_module_imp_clb(UTEST_LYCTX, &clb_data); + assert_null(clb); + assert_null(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, &unres.creating, &mod1)); - lys_unres_glob_erase(&unres); + assert_int_equal(LY_EVALID, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod1)); ly_in_free(in, 0); CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL, 0); CHECK_LOG_CTX("Name collision between module and submodule of name \"y\".", NULL, 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, &unres.creating, &mod1)); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &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, &unres.creating, &mod1)); - lys_unres_glob_erase(&unres); + assert_int_equal(LY_EVALID, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod1)); ly_in_free(in, 0); CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL, 0); CHECK_LOG_CTX("Name collision between module and submodule of name \"y\".", NULL, 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, &unres.creating, &mod1)); - lys_unres_glob_revert(UTEST_LYCTX, &unres); - lys_unres_glob_erase(&unres); + assert_int_equal(LY_EVALID, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod1)); ly_in_free(in, 0); CHECK_LOG_CTX("Parsing module \"b\" failed.", NULL, 0); CHECK_LOG_CTX("Parsing submodule \"y\" failed.", NULL, 0); CHECK_LOG_CTX("Name collision between submodules of name \"y\".", NULL, 1); /* selecting correct revision of the submodules */ - 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, &unres.creating, &mod2)); - lys_unres_glob_erase(&unres); + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule p {belongs-to g {prefix g;} revision 2018-10-31;}"); + assert_int_equal(LY_SUCCESS, ly_in_new_memory("module g {namespace urn:g;prefix g;include p; revision 2018-10-31;}", &in)); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod2)); ly_in_free(in, 0); assert_string_equal("2018-10-31", mod2->parsed->includes[0].submodule->revs[0].date); @@ -372,17 +398,16 @@ test_includes(void **state) static void test_get_models(void **state) { - struct lys_module *mod, *mod2; + struct lys_module *mod, *mod2, *latest; 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-24;revision 2018-10-23;}"; - struct ly_in *in0, *in1, *in2; - struct lys_glob_unres unres = {0}; + struct ly_in *in0, *in1, *in2, *in3; unsigned int index = 0; const char *names[] = { "ietf-inet-types", "ietf-yang-types", "ietf-yang-metadata", "yang", "default", "ietf-yang-schema-mount", - "ietf-yang-structure-ext", "ietf-datastores", "ietf-yang-library", "a", "a", "a" + "ietf-yang-structure-ext", "ietf-datastores", "ietf-yang-library", "a", "m", "a", "n" }; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str0, &in0)); @@ -416,46 +441,44 @@ test_get_models(void **state) /* 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, &unres.creating, &mod2)); - assert_int_equal(LY_EDENIED, lys_implement(mod2, NULL, &unres)); + assert_int_equal(LY_EDENIED, lys_parse(UTEST_LYCTX, in2, LYS_IN_YANG, NULL, &mod2)); CHECK_LOG_CTX("Module \"a@2018-10-24\" is already implemented in revision \"2018-10-23\".", NULL, 0); - 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, &unres.creating, NULL)); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, 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, &unres.creating, &mod2)); - lys_unres_glob_erase(&unres); + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, (void *)str2); + assert_int_equal(LY_SUCCESS, ly_in_new_memory("module m {namespace urn:m; prefix m; import a { prefix a; revision-date 2018-10-24; }}", &in3)); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in3, LYS_IN_YANG, NULL, NULL)); + ly_in_free(in3, 0); + mod2 = ly_ctx_get_module(UTEST_LYCTX, "a", "2018-10-24"); 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, &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")); + latest = ly_ctx_get_module_latest(UTEST_LYCTX, "a"); + assert_ptr_equal(latest, mod2); + assert_ptr_equal(latest, ly_ctx_get_module_latest_ns(UTEST_LYCTX, mod->ns)); + + /* work with module with no revision by using another module */ + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, (void *)str0); + assert_int_equal(LY_SUCCESS, ly_in_new_memory("module n {namespace urn:n; prefix n; import a { prefix a; }}", &in3)); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in3, LYS_IN_YANG, NULL, NULL)); 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, &unres.creating, &mod)); + assert_int_equal(LY_EINVAL, lys_parse(UTEST_LYCTX, in1, LYS_IN_YANG, NULL, &mod)); CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL, 0); - 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(12, index); + assert_int_equal(13, index); /* cleanup */ ly_in_free(in0, 0); ly_in_free(in1, 0); ly_in_free(in2, 0); + ly_in_free(in3, 0); } static void diff --git a/tests/utests/basic/test_hash_table.c b/tests/utests/basic/test_hash_table.c index 2ea34faab6..b02bd03bb1 100644 --- a/tests/utests/basic/test_hash_table.c +++ b/tests/utests/basic/test_hash_table.c @@ -17,7 +17,6 @@ #include #include "hash_table.h" -#include "ly_common.h" static void test_invalid_arguments(void **state) @@ -104,24 +103,17 @@ test_ht_resize(void **UNUSED(state)) struct ly_ht *ht; assert_non_null(ht = lyht_new(8, sizeof(int), ht_equal_clb, NULL, 1)); - assert_int_equal(8, ht->size); /* insert records into indexes 2-7 */ for (i = 2; i < 8; ++i) { assert_int_equal(LY_SUCCESS, lyht_insert(ht, &i, i, NULL)); } - /* check that table resized */ - assert_int_equal(16, ht->size); /* check expected content of the table */ for (i = 0; i < 16; ++i) { if ((i >= 2) && (i < 8)) { - /* inserted data on indexes 2-7 */ - assert_int_not_equal(UINT32_MAX, ht->hlists[i].first); assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, i, NULL)); } else { - /* nothing otherwise */ - assert_int_equal(UINT32_MAX, ht->hlists[i].first); assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, i, NULL)); } } @@ -136,7 +128,6 @@ test_ht_resize(void **UNUSED(state)) for ( ; i < 5; ++i) { assert_int_equal(LY_SUCCESS, lyht_remove(ht, &i, i)); } - assert_int_equal(8, ht->size); /* remove the rest */ for ( ; i < 8; ++i) { @@ -154,28 +145,16 @@ test_ht_resize(void **UNUSED(state)) static void test_ht_collisions(void **UNUSED(state)) { -#define GET_REC_INT(rec) (*((uint32_t *)&(rec)->val)) - uint32_t i; - struct ly_ht_rec *rec; struct ly_ht *ht; - uint32_t rec_idx; - int count; assert_non_null(ht = lyht_new(8, sizeof(int), ht_equal_clb, NULL, 1)); for (i = 2; i < 6; ++i) { - assert_int_equal(lyht_insert(ht, &i, 2, NULL), 0); + assert_int_equal(LY_SUCCESS, lyht_insert(ht, &i, 2, NULL)); } /* check all records */ - for (i = 0; i < 8; ++i) { - if (i == 2) { - assert_int_not_equal(UINT32_MAX, ht->hlists[i].first); - } else { - assert_int_equal(UINT32_MAX, ht->hlists[i].first); - } - } for (i = 0; i < 8; ++i) { if ((i >= 2) && (i < 6)) { assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, 2, NULL)); @@ -183,32 +162,14 @@ test_ht_collisions(void **UNUSED(state)) assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL)); } } - rec_idx = ht->hlists[2].first; - count = 0; - while (rec_idx != UINT32_MAX) { - rec = lyht_get_rec(ht->recs, ht->rec_size, rec_idx); - rec_idx = rec->next; - assert_int_equal(rec->hash, 2); - count++; - } - assert_int_equal(count, 4); i = 4; - assert_int_equal(lyht_remove(ht, &i, 2), 0); - - rec = lyht_get_rec(ht->recs, ht->rec_size, i); + assert_int_equal(LY_SUCCESS, lyht_remove(ht, &i, 2)); i = 2; - assert_int_equal(lyht_remove(ht, &i, 2), 0); + assert_int_equal(LY_SUCCESS, lyht_remove(ht, &i, 2)); /* check all records */ - for (i = 0; i < 8; ++i) { - if (i == 2) { - assert_int_not_equal(UINT32_MAX, ht->hlists[i].first); - } else { - assert_int_equal(UINT32_MAX, ht->hlists[i].first); - } - } for (i = 0; i < 8; ++i) { if ((i == 3) || (i == 5)) { assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, 2, NULL)); @@ -216,32 +177,23 @@ test_ht_collisions(void **UNUSED(state)) assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL)); } } - rec_idx = ht->hlists[2].first; - count = 0; - while (rec_idx != UINT32_MAX) { - rec = lyht_get_rec(ht->recs, ht->rec_size, rec_idx); - rec_idx = rec->next; - assert_int_equal(rec->hash, 2); - count++; - } - assert_int_equal(count, 2); for (i = 0; i < 8; ++i) { if ((i == 3) || (i == 5)) { - assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_SUCCESS); + assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, 2, NULL)); } else { - assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_ENOTFOUND); + assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL)); } } i = 3; - assert_int_equal(lyht_remove(ht, &i, 2), 0); + assert_int_equal(LY_SUCCESS, lyht_remove(ht, &i, 2)); i = 5; - assert_int_equal(lyht_remove(ht, &i, 2), 0); + assert_int_equal(LY_SUCCESS, lyht_remove(ht, &i, 2)); /* check all records */ for (i = 0; i < 8; ++i) { - assert_int_equal(UINT32_MAX, ht->hlists[i].first); + assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL)); } lyht_free(ht, NULL); diff --git a/tests/utests/basic/test_inout.c b/tests/utests/basic/test_inout.c index af8cc8112f..c7bf32bd3c 100644 --- a/tests/utests/basic/test_inout.c +++ b/tests/utests/basic/test_inout.c @@ -23,7 +23,6 @@ #include "in.h" #include "log.h" -#include "ly_common.h" #include "out.h" #define TEST_INPUT_FILE TESTS_BIN "/libyang_test_input" diff --git a/tests/utests/basic/test_json.c b/tests/utests/basic/test_json.c index a760b382ec..f50ac0498e 100644 --- a/tests/utests/basic/test_json.c +++ b/tests/utests/basic/test_json.c @@ -15,503 +15,442 @@ #include "utests.h" #include "context.h" -#include "in_internal.h" -#include "json.h" + static void test_general(void **state) { - struct lyjson_ctx *jsonctx; struct ly_in *in; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf l {" + " type boolean;" + " }" + " leaf emp {" + " type empty;" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* empty */ str = ""; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:l", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Empty JSON file.", NULL, 1); str = " \n\t \n"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:l", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Empty JSON file.", NULL, 3); /* constant values */ str = "true"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:l", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("true", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "false"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:l", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("false", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "null"; + str = "[null]"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:emp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("", lyd_get_value(tree)); + lyd_free_all(tree); ly_in_free(in, 0); } static void test_number(void **state) { - struct lyjson_ctx *jsonctx; struct ly_in *in; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf num {" + " type union {" + " type int32;" + " type decimal64 {" + " fraction-digits 4;" + " }" + " }" + " }" + " leaf exp {" + " type string;" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* simple value */ str = "11"; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("11", jsonctx->value); - assert_int_equal(2, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("11", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* fraction number */ - str = "37.7668"; + str = "\"37.7668\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("37.7668", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("37.7668", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* negative number */ - str = "-122.3959"; + str = "\"-122.3959\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-122.3959", jsonctx->value); - assert_int_equal(9, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-122.3959", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* integer, positive exponent */ str = "550E3"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("550000", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("550000", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + /* integer, negative exponent */ str = "-550E3"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-550000", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-550000", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* integer, negative exponent */ - str = "1E-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.1", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "15E-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("1.5", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "-15E-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-1.5", jsonctx->value); - assert_int_equal(4, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "16E-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.16", jsonctx->value); - assert_int_equal(4, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "-16E-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-0.16", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "17E-3"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.017", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "-17E-3"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-0.017", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + str = "\"1E-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("1E-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"15E-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("15E-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"-15E-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-15E-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"16E-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("16E-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"-16E-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-16E-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"17E-3\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("17E-3", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"-17E-3\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-17E-3", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "21000E-2"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("210", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("210", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "21000E-4"; + str = "\"21000E-4\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("2.1", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("21000E-4", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "21000E-7"; + str = "\"21000E-7\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.0021", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("21000E-7", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* decimal number, positive exponent */ - str = "5.087E1"; + str = "\"5.087E1\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("50.87", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("5.087E1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "-5.087E1"; + str = "\"-5.087E1\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-50.87", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-5.087E1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "5.087E5"; + str = "\"5.087E5\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("508700", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("5.087E5", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "59.1e+1"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("591", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("591", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "0.005087E1"; + str = "\"0.005087E1\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.05087", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.005087E1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "0.005087E2"; + str = "\"0.005087E2\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.5087", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.005087E2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "0.005087E6"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("5087", jsonctx->value); - assert_int_equal(4, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("5087", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "0.05087E6"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("50870", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("50870", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "0.005087E8"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("508700", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("508700", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* decimal number, negative exponent */ - str = "35.94e-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("3.594", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "-35.94e-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("-3.594", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "35.94e-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.3594", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "35.94e-3"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.03594", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.3594e-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.03594", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.03594e-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.003594", jsonctx->value); - assert_int_equal(8, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.003594e-1"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.0003594", jsonctx->value); - assert_int_equal(9, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.3594e-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.003594", jsonctx->value); - assert_int_equal(8, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.03594e-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.0003594", jsonctx->value); - assert_int_equal(9, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); - - str = "0.003594e-2"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.00003594", jsonctx->value); - assert_int_equal(10, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + str = "\"35.94e-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("35.94e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"-35.94e-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("-35.94e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"35.94e-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("35.94e-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"35.94e-3\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("35.94e-3", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.3594e-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.3594e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.03594e-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.03594e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.003594e-1\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.003594e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.3594e-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.3594e-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.03594e-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.03594e-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; + + str = "\"0.003594e-2\""; + assert_non_null(ly_in_memory(in, str)); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0.003594e-2", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* zero */ str = "0"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_true(jsonctx->value[0] == '0'); - assert_int_equal(1, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "-0"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_true(jsonctx->value[0] == '-'); - assert_true(jsonctx->value[1] == '0'); - assert_int_equal(2, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "94E0"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_true(jsonctx->value[0] == '9'); - assert_true(jsonctx->value[1] == '4'); - assert_int_equal(2, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("94", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "0E2"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_true(jsonctx->value[0] == '0'); - assert_int_equal(1, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "-0E2"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_true(jsonctx->value[0] == '-'); - assert_true(jsonctx->value[1] == '0'); - assert_int_equal(2, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("0", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; str = "5.320e+2"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("532", jsonctx->value); - assert_int_equal(3, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("532", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; - str = "5.320e-1"; + str = "\"5.320e-1\""; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx)); - assert_string_equal("0.532", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(1, jsonctx->dynamic); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:exp", in, LYD_JSON, 0, 0, 0, &tree)); + assert_string_equal("5.320e-1", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* various invalid inputs */ str = "-x"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Invalid character in JSON Number value (\"x\").", NULL, 1); str = " -"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Unexpected end-of-input.", NULL, 1); str = "--1"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Invalid character in JSON Number value (\"-\").", NULL, 1); str = "+1"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Invalid character sequence \"+1\", expected a JSON value.", NULL, 1); str = " 1.x "; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Invalid character in JSON Number value (\"x\").", NULL, 1); str = "1."; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Unexpected end-of-input.", NULL, 1); str = " 1eo "; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Invalid character in JSON Number value (\"o\").", NULL, 1); str = "1e"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Unexpected end-of-input.", NULL, 1); str = "1E1000"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Number encoded as a string exceeded the LY_NUMBER_MAXLEN limit.", NULL, 1); str = "1e9999999999999999999"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1e9999999999999999999).", NULL, 1); str = "1.1e66000"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1.1e66000).", NULL, 1); str = "1.1e-66000"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:num", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1.1e-66000).", NULL, 1); ly_in_free(in, 0); @@ -521,9 +460,19 @@ test_number(void **state) static void test_string(void **state) { - struct lyjson_ctx *jsonctx; struct ly_in *in = NULL; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf l {" + " type string;" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); str = ""; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); @@ -531,7 +480,7 @@ test_string(void **state) /* unterminated string */ str = "\"unterminated string"; assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); + assert_int_equal(LY_EVALID, lyd_parse_value_fragment(ctx, "/test:l", in, LYD_JSON, 0, 0, 0, &tree)); CHECK_LOG_CTX("Missing quotation-mark at the end of a JSON string.", NULL, 1); CHECK_LOG_CTX("Unexpected end-of-input.", NULL, 1); @@ -541,129 +490,67 @@ test_string(void **state) static void test_object(void **state) { - struct lyjson_ctx *jsonctx; struct ly_in *in; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree, *search_node; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf name {" + " type string;" + " }" + " leaf smart {" + " type boolean;" + " }" + " leaf handsom {" + " type boolean;" + " }" + " container person {" + " leaf name {" + " type string;" + " }" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* empty */ str = " { } "; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_parse_value_fragment(ctx, "/test:name", in, LYD_JSON, 0, 0, 0, &tree)); + assert_null(tree); /* simple value */ - str = "{\"name\" : \"Radek\"}"; - assert_non_null(ly_in_memory(in, str)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_ptr_equal(&str[2], jsonctx->value); - assert_int_equal(4, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx)); - assert_string_equal("Radek\"}", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + str = "{\"test:name\" : \"Radek\"}"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_string_equal("Radek", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* two values */ - str = "{\"smart\" : true,\"handsom\":false}"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_string_equal("smart\" : true,\"handsom\":false}", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NEXT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_string_equal("handsom\":false}", jsonctx->value); - assert_int_equal(7, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); + str = "{\"test:smart\" : true,\"test:handsom\":false}"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + assert_int_equal(LY_SUCCESS, lyd_find_path(tree, "/test:smart", 0, &search_node)); + assert_string_equal("true", lyd_get_value(search_node)); + assert_int_equal(LY_SUCCESS, lyd_find_path(tree, "/test:handsom", 0, &search_node)); + assert_string_equal("false", lyd_get_value(search_node)); + lyd_free_all(tree); + tree = NULL; /* inherited objects */ - str = "{\"person\" : {\"name\":\"Radek\"}}"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_string_equal("person\" : {\"name\":\"Radek\"}}", jsonctx->value); - assert_int_equal(6, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_string_equal("name\":\"Radek\"}}", jsonctx->value); - assert_int_equal(4, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx)); - assert_string_equal("Radek\"}}", jsonctx->value); - assert_int_equal(5, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + str = "{\"test:person\" : {\"name\":\"Radek\"}}"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_int_equal(LY_SUCCESS, lyd_find_path(tree, "/test:person/name", 0, &search_node)); + assert_string_equal("Radek", lyd_get_value(search_node)); + lyd_free_all(tree); + tree = NULL; /* unquoted string */ str = "{ unquoted : \"data\"}"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_EVALID, lyjson_ctx_next(jsonctx, NULL)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_JSON, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"unquoted : \"data\"}\", expected a JSON object name.", NULL, 1); - lyjson_ctx_free(jsonctx); ly_in_free(in, 0); } @@ -671,91 +558,35 @@ test_object(void **state) static void test_array(void **state) { - struct lyjson_ctx *jsonctx; - struct ly_in *in; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; /* empty */ - str = " [ ] "; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + str = "{\"mod:mixed-stuff\": [] }"; + assert_int_equal(LY_EINVAL, lyd_parse_data_mem(ctx, str, LYD_JSON, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + CHECK_LOG_CTX("Unexpected input data array closed.", NULL, 1); /* simple value */ - str = "[ null]"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx)); - assert_null(jsonctx->value); - assert_int_equal(0, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + str = "{\"mod:mixed-stuff\": [ null ]}"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_JSON, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + lyd_free_all(tree); + tree = NULL; /* two values */ - str = "[{\"a\":null},\"x\"]"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx)); - assert_null(jsonctx->value); - assert_int_equal(0, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx)); - assert_string_equal("a\":null},\"x\"]", jsonctx->value); - assert_int_equal(1, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_ARRAY_NEXT, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx)); - assert_string_equal("x\"]", jsonctx->value); - assert_int_equal(1, jsonctx->value_len); - assert_int_equal(0, jsonctx->dynamic); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx)); - - assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL)); - assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx)); - lyjson_ctx_free(jsonctx); + str = "{\"mod:mixed-stuff\": [{\"a\":null},\"x\"]}"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_JSON, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + lyd_free_all(tree); + tree = NULL; /* new line is allowed only as escaped character in JSON */ - str = "[ , null]"; - assert_non_null(ly_in_memory(in, str)); - assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx)); - assert_int_equal(LY_EVALID, lyjson_ctx_next(jsonctx, NULL)); - CHECK_LOG_CTX("Invalid character sequence \", null]\", expected a JSON value.", NULL, 1); - lyjson_ctx_free(jsonctx); - - ly_in_free(in, 0); + str = "{\"mod:mixed-stuff\": [ , null]}"; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_JSON, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + CHECK_LOG_CTX("Invalid character sequence \", null]}\", expected a JSON value.", NULL, 1); } int diff --git a/tests/utests/basic/test_plugins.c b/tests/utests/basic/test_plugins.c index 3926b2ceb7..8a39d5fd3d 100644 --- a/tests/utests/basic/test_plugins.c +++ b/tests/utests/basic/test_plugins.c @@ -17,9 +17,7 @@ #include #include -#include "ly_config.h" #include "plugins.h" -#include "plugins_internal.h" const char *simple = "module libyang-plugins-simple {" " namespace urn:libyang:tests:plugins:simple;" @@ -79,6 +77,7 @@ test_add_simple(void **state) struct lysc_node_leaf *leaf; struct lyplg_ext *plugin_e; struct lyplg_type *plugin_t; + uintptr_t plugin_ptr; assert_int_equal(LY_SUCCESS, lyplg_add(TESTS_BIN "/plugins/plugin_simple" LYPLG_SUFFIX)); @@ -87,12 +86,14 @@ test_add_simple(void **state) leaf = (struct lysc_node_leaf *)mod->compiled->data; assert_int_equal(LYS_LEAF, leaf->nodetype); - assert_non_null(plugin_t = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "libyang-plugins-simple", NULL, "note"))); + plugin_ptr = leaf->type->plugin_ref; + assert_non_null(plugin_t = lysc_get_type_plugin(plugin_ptr)); assert_string_equal("ly2 simple test v1", plugin_t->id); assert_ptr_equal(leaf->type->plugin_ref, plugin_t); assert_int_equal(1, LY_ARRAY_COUNT(leaf->exts)); - assert_non_null(plugin_e = lysc_get_ext_plugin(lyplg_ext_plugin_find(NULL, "libyang-plugins-simple", NULL, "hint"))); + plugin_ptr = leaf->exts[0].def->plugin_ref; + assert_non_null(plugin_e = lysc_get_ext_plugin(plugin_ptr)); assert_string_equal("ly2 simple test v1", plugin_e->id); assert_ptr_equal(leaf->exts[0].def->plugin_ref, plugin_e); diff --git a/tests/utests/basic/test_xml.c b/tests/utests/basic/test_xml.c index 49da606a92..5712f34685 100644 --- a/tests/utests/basic/test_xml.c +++ b/tests/utests/basic/test_xml.c @@ -21,658 +21,348 @@ #include #include "context.h" -#include "in_internal.h" -#include "xml.h" - -LY_ERR lyxml_ns_add(struct lyxml_ctx *xmlctx, const char *prefix, size_t prefix_len, char *uri); static void test_element(void **state) { - struct lyxml_ctx *xmlctx; - struct ly_in *in; const char *str; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " leaf element {" + " type string;" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* empty */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); /* end element */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Stray closing element tag (\"element\").", NULL, 1); - ly_in_free(in, 0); /* no element */ str = "no data present"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"no data present\", expected element tag start ('<').", NULL, 1); - ly_in_free(in, 0); /* not supported DOCTYPE */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Document Type Declaration not supported.", NULL, 1); - ly_in_free(in, 0); /* invalid XML */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Unknown XML section \"\".", NULL, 1); - ly_in_free(in, 0); /* namespace ambiguity */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Duplicate default XML namespaces \"urn1\" and \"urn2\".", NULL, 1); - ly_in_free(in, 0); /* prefix duplicate */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Duplicate XML NS prefix \"a\" used for namespaces \"urn1\" and \"urn2\".", NULL, 1); - ly_in_free(in, 0); /* unqualified element */ str = " < element/>"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_null(xmlctx->prefix); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_int_equal(1, xmlctx->elements.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("", xmlctx->value, xmlctx->value_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + UTEST_LOG_CTX_CLEAN; /* element with attribute */ str = " < element attr=\'x\'/>"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - assert_int_equal(1, xmlctx->elements.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTRIBUTE, xmlctx->status); - assert_true(!strncmp("attr", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_int_equal(1, xmlctx->elements.count); - assert_true(!strncmp("x", xmlctx->value, xmlctx->value_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - assert_int_equal(0, xmlctx->elements.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + UTEST_LOG_CTX_CLEAN; /* headers and comments */ str = " "; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - assert_int_equal(1, xmlctx->elements.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + UTEST_LOG_CTX_CLEAN; /* separate opening and closing tags, neamespaced parsed internally */ - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - assert_int_equal(1, xmlctx->elements.count); - assert_int_equal(1, xmlctx->ns.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - assert_int_equal(0, xmlctx->elements.count); - assert_int_equal(0, xmlctx->ns.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_string_equal("element", tree->schema->name); + assert_string_equal("", lyd_get_value(tree)); + lyd_free_all(tree); + tree = NULL; /* qualified element */ str = " < yin:element/>"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_true(!strncmp("yin", xmlctx->prefix, xmlctx->prefix_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); /* non-matching closing tag */ - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("element", xmlctx->name, xmlctx->name_len)); - assert_true(!strncmp("yin", xmlctx->prefix, xmlctx->prefix_len)); - assert_int_equal(1, xmlctx->elements.count); - assert_int_equal(1, xmlctx->ns.count); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); - CHECK_LOG_CTX("Opening (\"yin:element\") and closing (\"element\") elements tag mismatch.", NULL, 1); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + CHECK_LOG_CTX("Opening (\"t:element\") and closing (\"element\") elements tag mismatch.", NULL, 1); /* invalid closing tag */ - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = ""; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"/>\", expected element tag termination ('>').", NULL, 1); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + UTEST_LOG_CTX_CLEAN; /* UTF8 characters */ - str = "<𠜎€𠜎Øn:𠜎€𠜎Øn/>"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_true(!strncmp("𠜎€𠜎Øn", xmlctx->name, xmlctx->name_len)); - assert_true(!strncmp("𠜎€𠜎Øn", xmlctx->prefix, xmlctx->prefix_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + str = "<𠜎€𠜎Øn:𠜎€𠜎Øn xmlns:𠜎€𠜎Øn=\"urn:test\"/>"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_null(tree); /* invalid UTF-8 characters */ str = "<¢:element>"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Identifier \"¢:element>\" starts with an invalid character.", NULL, 1); - ly_in_free(in, 0); - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = ""; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"⁐element>\", expected element tag end ('>' or '/>') or an attribute.", NULL, 1); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); /* mixed content */ str = "text x"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("a", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("text ", xmlctx->value, xmlctx->value_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("b", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("x", xmlctx->value, xmlctx->value_len)); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + UTEST_LOG_CTX_CLEAN; /* tag mismatch */ - str = "text"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_true(!strncmp("a", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("text", xmlctx->value, xmlctx->value_len)); - - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "text"; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Opening (\"a\") and closing (\"b\") elements tag mismatch.", NULL, 1); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + } static void test_attribute(void **state) { const char *str; - struct lyxml_ctx *xmlctx; - struct ly_in *in; - struct lyxml_ns *ns; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " anyxml e;" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* not an attribute */ str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"/>\", expected '='.", NULL, 1); - ly_in_free(in, 0); str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"/>\", expected either single or double quotation mark.", NULL, 1); - ly_in_free(in, 0); str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EVALID, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"yyy/>\", expected either single or double quotation mark.", NULL, 2); - ly_in_free(in, 0); /* valid attribute */ - str = "status); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTRIBUTE, xmlctx->status); - assert_true(!strncmp("attr", xmlctx->name, xmlctx->name_len)); - assert_null(xmlctx->prefix); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_true(!strncmp("val", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 0); - assert_int_equal(xmlctx->dynamic, 0); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + assert_string_equal("e", tree->schema->name); + lyd_free_all(tree); + tree = NULL; /* valid namespace with prefix */ - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_int_equal(1, xmlctx->ns.count); - ns = (struct lyxml_ns *)xmlctx->ns.objs[0]; - assert_string_equal(ns->prefix, "nc"); - assert_string_equal(ns->uri, "urn"); - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + assert_string_equal("e", tree->schema->name); + lyd_free_all(tree); } static void test_text(void **state) { const char *str; - struct lyxml_ctx *xmlctx; - struct ly_in *in; - + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " anyxml e;" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); /* empty attribute value */ - str = "status); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTRIBUTE, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_true(!strncmp("", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 1); - assert_int_equal(xmlctx->dynamic, 0); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + lyd_free_all(tree); + tree = NULL; /* empty value but in single quotes */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory("=\'\'", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_true(!strncmp("", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 1); - assert_int_equal(xmlctx->dynamic, 0); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + lyd_free_all(tree); + tree = NULL; /* empty element content - only formating before defining child */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory(">\n ", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ELEMENT; - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("\n ", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 1); - assert_int_equal(xmlctx->dynamic, 0); - ly_in_free(in, 0); + str = ">\n "; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); /* empty element content is invalid - missing content terminating character < */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory("", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ELEM_CONTENT; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ELEM_CONTENT; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "xxx"; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character sequence \"xxx\", expected element tag start ('<').", NULL, 1); - ly_in_free(in, 0); - - lyxml_ctx_free(xmlctx); - ly_log_location_revert(0, 0, 4); + UTEST_LOG_CTX_CLEAN; /* valid strings */ - str = "€𠜎Øn \n<&"'> ROK"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp("€𠜎Øn \n<&\"\'> ROK", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 0); - assert_int_equal(xmlctx->dynamic, 1); - free((char *)xmlctx->value); - ly_in_free(in, 0); + str = "€𠜎Øn \n<&"'> ROK"; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + lyd_free_all(tree); + tree = NULL; /* test using n-bytes UTF8 hexadecimal code points */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory("=\'$¢€𐍈\'", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_true(!strncmp("$¢€𐍈", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 0); - assert_int_equal(xmlctx->dynamic, 1); - ly_in_free(in, 0); + str = ""; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + lyd_free_all(tree); + tree = NULL; /* CDATA value */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory("> &\"' ]]> ", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTR_CONTENT; - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_true(!strncmp(" special non-escaped chars <>&\"' ", xmlctx->value, xmlctx->value_len)); - assert_int_equal(xmlctx->ws_only, 0); - assert_int_equal(xmlctx->dynamic, 1); - free((char *)xmlctx->value); - ly_in_free(in, 0); + str = " &\"' ]]> "; + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + lyd_free_all(tree); + tree = NULL; /* invalid characters in string */ - assert_int_equal(LY_SUCCESS, ly_in_new_memory("=\'R\'", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = ""; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Entity reference \"&nonsense;\" not supported, only predefined references allowed.", NULL, 1); - ly_in_free(in, 0); - assert_int_equal(LY_SUCCESS, ly_in_new_memory(">&#o122;", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ELEMENT; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "&#o122;"; + assert_int_equal(LY_EVALID, lyd_parse_data_mem(ctx, str, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); CHECK_LOG_CTX("Invalid character reference \"&#o122;\".", NULL, 1); - ly_in_free(in, 0); - assert_int_equal(LY_SUCCESS, ly_in_new_memory("=\'\'", &in)); - xmlctx->in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "in = in; - ly_log_location(NULL, NULL, in); - xmlctx->status = LYXML_ATTRIBUTE; - assert_int_equal(LY_EVALID, lyxml_ctx_next(xmlctx)); + str = "elements.count++; - /* processing namespace definitions */ - assert_int_equal(LY_SUCCESS, lyxml_ns_add(xmlctx, "nc", 2, strdup("urn:nc2"))); - assert_int_equal(3, xmlctx->ns.count); - assert_int_not_equal(0, xmlctx->ns.size); - - ns = lyxml_ns_get(&xmlctx->ns, NULL, 0); - assert_non_null(ns); - assert_null(ns->prefix); - assert_string_equal("urn:default", ns->uri); - - ns = lyxml_ns_get(&xmlctx->ns, "nc", 2); - assert_non_null(ns); - assert_string_equal("nc", ns->prefix); - assert_string_equal("urn:nc2", ns->uri); - - /* simulate closing element2 */ - xmlctx->elements.count--; - lyxml_ns_rm(xmlctx); - assert_int_equal(2, xmlctx->ns.count); - - ns = lyxml_ns_get(&xmlctx->ns, "nc", 2); - assert_non_null(ns); - assert_string_equal("nc", ns->prefix); - assert_string_equal("urn:nc1", ns->uri); - - /* close element1 */ - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(0, xmlctx->ns.count); - - assert_null(lyxml_ns_get(&xmlctx->ns, "nc", 2)); - assert_null(lyxml_ns_get(&xmlctx->ns, NULL, 0)); - - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + struct lyd_node_opaq *opaq1, *opaq2; + struct lyd_attr *attr; + const char *xml = + "\n" + " \n" + "\n"; + + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, xml, LYD_XML, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + assert_non_null(tree); + + opaq1 = (struct lyd_node_opaq *)tree; + assert_string_equal("element1", opaq1->name.name); + assert_string_equal("urn:default", opaq1->name.module_ns); + + attr = opaq1->attr; + assert_non_null(attr); + assert_string_equal("nc", attr->name.prefix); + assert_string_equal("urn:nc1", attr->name.module_ns); + + assert_non_null(lyd_child(tree)); + opaq2 = (struct lyd_node_opaq *)lyd_child(tree); + assert_string_equal("element2", opaq2->name.name); + assert_string_equal("urn:default", opaq2->name.module_ns); + + attr = opaq2->attr; + assert_non_null(attr); + assert_string_equal("nc", attr->name.prefix); + assert_string_equal("urn:nc2", attr->name.module_ns); + + lyd_free_all(tree); } static void test_ns2(void **state) { - const char *str; - struct lyxml_ctx *xmlctx; - struct ly_in *in; - - /* opening element1 */ - str = ""; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - - /* default namespace defined in parent element1 */ - assert_int_equal(LY_SUCCESS, lyxml_ns_add(xmlctx, NULL, 0, strdup("urn:default"))); - assert_int_equal(1, xmlctx->ns.count); - /* going into child element1 */ - /* simulate adding open element1 into context */ - xmlctx->elements.count++; - /* no namespace defined, going out (first, simulate closing of so far open element) */ - xmlctx->elements.count--; - lyxml_ns_rm(xmlctx); - assert_int_equal(1, xmlctx->ns.count); - - /* nothing else, going out of the parent element1 */ - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(0, xmlctx->ns.count); - - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); -} - -static void -test_simple_xml(void **state) -{ - struct lyxml_ctx *xmlctx; - struct ly_in *in; - const char *test_input = " "; + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + struct lyd_node_opaq *parent, *child; + const char *xml = + "\n" + " \n" + "\n"; - assert_int_equal(LY_SUCCESS, ly_in_new_memory(test_input, &in)); - assert_int_equal(LY_SUCCESS, lyxml_ctx_new(UTEST_LYCTX, in, &xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, "attr1=\"value\"> "); + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, xml, LYD_XML, + LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, &tree)); + assert_non_null(tree); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTRIBUTE, xmlctx->status); - assert_string_equal(xmlctx->in->current, "=\"value\"> "); + parent = (struct lyd_node_opaq *)tree; + assert_string_equal("element1", parent->name.name); + assert_string_equal("urn:default", parent->name.module_ns); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, "> "); + assert_non_null(lyd_child(tree)); + child = (struct lyd_node_opaq *)lyd_child(tree); + assert_string_equal("element1", child->name.name); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, " "); + assert_string_equal("urn:default", child->name.module_ns); - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEMENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, "attr2=\"value\" /> "); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTRIBUTE, xmlctx->status); - assert_string_equal(xmlctx->in->current, "=\"value\" /> "); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ATTR_CONTENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, " /> "); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CONTENT, xmlctx->status); - assert_string_equal(xmlctx->in->current, "/> "); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - assert_string_equal(xmlctx->in->current, " "); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_ELEM_CLOSE, xmlctx->status); - assert_string_equal(xmlctx->in->current, ""); - - assert_int_equal(LY_SUCCESS, lyxml_ctx_next(xmlctx)); - assert_int_equal(LYXML_END, xmlctx->status); - assert_string_equal(xmlctx->in->current, ""); + lyd_free_all(tree); +} - lyxml_ctx_free(xmlctx); - ly_in_free(in, 0); +static void +test_simple_xml(void **state) +{ + struct ly_ctx *ctx = UTEST_LYCTX; + struct lyd_node *tree = NULL; + const char *test_input = " value "; + const char *yang = "module test {" + " namespace \"urn:test\";" + " prefix t;" + " container elem1 {" + " leaf elem2 {" + " type string;" + " }" + " }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yang, LYS_IN_YANG, NULL)); + assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(ctx, test_input, LYD_XML, 0, LYD_VALIDATE_PRESENT, &tree)); + assert_non_null(tree); + assert_string_equal("elem1", tree->schema->name); + struct lyd_node *child = lyd_child(tree); + + assert_non_null(child); + assert_string_equal("elem2", child->schema->name); + assert_string_equal("value", lyd_get_value(child)); + lyd_free_all(tree); + tree = NULL; } int diff --git a/tests/utests/basic/test_xpath.c b/tests/utests/basic/test_xpath.c index 453569d86c..3c62b249d0 100644 --- a/tests/utests/basic/test_xpath.c +++ b/tests/utests/basic/test_xpath.c @@ -19,7 +19,6 @@ #include "context.h" #include "parser_data.h" #include "set.h" -#include "tests_config.h" #include "tree_data.h" #include "tree_schema.h" diff --git a/tests/utests/basic/test_yanglib.c b/tests/utests/basic/test_yanglib.c index 0349157f47..e7f6064b2f 100644 --- a/tests/utests/basic/test_yanglib.c +++ b/tests/utests/basic/test_yanglib.c @@ -20,7 +20,6 @@ #include "in.h" #include "log.h" #include "set.h" -#include "tests_config.h" #include "tree_data.h" #include "tree_schema.h" diff --git a/tests/utests/data/test_diff.c b/tests/utests/data/test_diff.c index 8ec353df6e..215c5cf2cf 100644 --- a/tests/utests/data/test_diff.c +++ b/tests/utests/data/test_diff.c @@ -177,7 +177,7 @@ test_invalid(void **state) struct lyd_node *diff = NULL; - assert_int_equal(lyd_diff_siblings(model_1, lyd_child(model_1), 0, &diff), LY_EINVAL); + assert_int_equal(lyd_diff_siblings(model_1, lyd_child_no_keys(model_1), 0, &diff), LY_EINVAL); CHECK_LOG_CTX("Invalid arguments - cannot create diff for unrelated data (lyd_diff()).", NULL, 0); assert_int_equal(lyd_diff_siblings(NULL, NULL, 0, NULL), LY_EINVAL); @@ -315,7 +315,7 @@ test_empty_nested(void **state) struct lyd_node *diff1; - CHECK_PARSE_LYD_DIFF(NULL, lyd_child(model_1), 0, diff1); + CHECK_PARSE_LYD_DIFF(NULL, lyd_child_no_keys(model_1), 0, diff1); CHECK_LYD_STRING(diff1, "\n" " 42\n" @@ -323,7 +323,7 @@ test_empty_nested(void **state) struct lyd_node *diff2; - CHECK_PARSE_LYD_DIFF(lyd_child(model_1), NULL, 0, diff2); + CHECK_PARSE_LYD_DIFF(lyd_child_no_keys(model_1), NULL, 0, diff2); CHECK_LYD_STRING(diff2, "\n" " 42\n" diff --git a/tests/utests/data/test_merge.c b/tests/utests/data/test_merge.c index 4a3663baf4..2f1985ad0f 100644 --- a/tests/utests/data/test_merge.c +++ b/tests/utests/data/test_merge.c @@ -654,8 +654,8 @@ test_dflt(void **state) source = NULL; /* c should be replaced and now be default */ - assert_string_equal(lyd_child(target)->prev->schema->name, "c"); - assert_true(lyd_child(target)->prev->flags & LYD_DEFAULT); + assert_string_equal(lyd_child_no_keys(target)->prev->schema->name, "c"); + assert_true(lyd_child_no_keys(target)->prev->flags & LYD_DEFAULT); lyd_free_all(target); lyd_free_all(source); @@ -696,7 +696,7 @@ test_dflt2(void **state) assert_int_equal(lyd_merge_siblings(&target, source, 0), LY_SUCCESS); /* c should not be replaced, so c remains not default */ - assert_false(lyd_child(target)->flags & LYD_DEFAULT); + assert_false(lyd_child_no_keys(target)->flags & LYD_DEFAULT); lyd_free_all(target); lyd_free_all(source); diff --git a/tests/utests/data/test_new.c b/tests/utests/data/test_new.c index 78285e0347..04716df82f 100644 --- a/tests/utests/data/test_new.c +++ b/tests/utests/data/test_new.c @@ -294,13 +294,13 @@ test_path(void **state) ret = lyd_new_path(root, NULL, "a", NULL, LYD_NEW_PATH_OPAQ, NULL); assert_int_equal(ret, LY_SUCCESS); - assert_non_null(lyd_child(root)); - assert_null(lyd_child(root)->schema); + assert_non_null(lyd_child_no_keys(root)); + assert_null(lyd_child_no_keys(root)->schema); ret = lyd_new_path(root, NULL, "b", NULL, LYD_NEW_PATH_OPAQ, NULL); assert_int_equal(ret, LY_SUCCESS); - assert_non_null(lyd_child(root)->next); - assert_null(lyd_child(root)->next->schema); + assert_non_null(lyd_child_no_keys(root)->next); + assert_null(lyd_child_no_keys(root)->next->schema); lyd_free_tree(root); @@ -542,7 +542,7 @@ test_path_ext(void **state) assert_int_equal(ret, LY_SUCCESS); assert_non_null(root); assert_string_equal(root->schema->name, "c"); - assert_non_null(node = lyd_child(root)); + assert_non_null(node = lyd_child_no_keys(root)); assert_string_equal(node->schema->name, "x"); assert_string_equal("xxx", lyd_get_value(node)); diff --git a/tests/utests/data/test_parser_json.c b/tests/utests/data/test_parser_json.c index 7d88a6e79b..0523017f0e 100644 --- a/tests/utests/data/test_parser_json.c +++ b/tests/utests/data/test_parser_json.c @@ -20,8 +20,6 @@ #include "out.h" #include "parser_data.h" #include "printer_data.h" -#include "tests_config.h" -#include "tree_data_internal.h" #include "tree_schema.h" static int @@ -799,14 +797,14 @@ test_rpc(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)node->schema, dsc, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "edit-data", LYS_RPC, 0, 0, 0, 0, 0, NULL, 0); - node = lyd_child(node)->next; + node = lyd_child_no_keys(node)->next; CHECK_LYSC_NODE(node->schema, "Inline config content.", 0, LYS_STATUS_CURR | LYS_IS_INPUT, 1, "config", 0, LYS_ANYDATA, 1, 0, NULL, 0); node = ((struct lyd_node_any *)node)->child; CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp", 1, LYS_CONTAINER, 0, 0, NULL, 0); - node = lyd_child(node); + node = lyd_child_no_keys(node); /* z has no value */ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_JSON, "z", 0, 0, NULL, 0, ""); node = node->parent->next; @@ -912,13 +910,13 @@ test_reply(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)op->schema, NULL, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "act", LYS_ACTION, 1, 0, 0, 1, 0, NULL, 0); - node = lyd_child(op); + node = lyd_child_no_keys(op); CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_STATUS_CURR | LYS_IS_OUTPUT, 1, "al", 0, LYS_LEAF, 1, 0, NULL, 0); CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0); /* TODO print only rpc-reply node and then output subtree */ - CHECK_LYD_STRING(lyd_child(op), LYD_PRINT_SHRINK | LYD_PRINT_SIBLINGS, "{\"a:al\":25}"); + CHECK_LYD_STRING(lyd_child_no_keys(op), LYD_PRINT_SHRINK | LYD_PRINT_SIBLINGS, "{\"a:al\":25}"); CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_SIBLINGS, "{\"a:c\":{\"act\":{\"al\":25}}}"); lyd_free_all(tree); @@ -1013,7 +1011,7 @@ test_restconf_reply(void **state) data = "{\"a:output\":{\"al\":25}}"; assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in)); - assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, lyd_child(tree), in, LYD_JSON, LYD_TYPE_REPLY_RESTCONF, + assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, lyd_child_no_keys(tree), in, LYD_JSON, LYD_TYPE_REPLY_RESTCONF, LYD_PARSE_STRICT, &envp, NULL)); ly_in_free(in, 0); diff --git a/tests/utests/data/test_parser_xml.c b/tests/utests/data/test_parser_xml.c index e0e3d2dca7..d99593ba0b 100644 --- a/tests/utests/data/test_parser_xml.c +++ b/tests/utests/data/test_parser_xml.c @@ -20,7 +20,6 @@ #include "out.h" #include "parser_data.h" #include "printer_data.h" -#include "tree_data_internal.h" #include "tree_schema.h" static int @@ -476,7 +475,7 @@ test_rpc(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)node->schema, dsc, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "edit-config", LYS_RPC, 0, 0, 0, 0, 0, ref, 0); - node = lyd_child(node)->next; + node = lyd_child_no_keys(node)->next; dsc = "Inline Config content."; CHECK_LYSC_NODE(node->schema, dsc, 0, LYS_STATUS_CURR | LYS_IS_INPUT, 1, "config", 0, LYS_ANYXML, 1, 0, NULL, 0); @@ -484,7 +483,7 @@ test_rpc(void **state) CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp", 1, LYS_CONTAINER, 0, 0, NULL, 0); - node = lyd_child(node); + node = lyd_child_no_keys(node); /* z has no value */ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_XML, "z", 0, 0, NULL, 1, ""); node = node->parent->next; @@ -617,13 +616,13 @@ test_reply(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)op->schema, NULL, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "act", LYS_ACTION, 1, 0, 0, 1, 0, NULL, 0); - node = lyd_child(op); + node = lyd_child_no_keys(op); CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_STATUS_CURR | LYS_IS_OUTPUT, 1, "al", 0, LYS_LEAF, 1, 0, NULL, 0); CHECK_LYSC_NODE(tree->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 1, LYS_CONTAINER, 0, 0, NULL, 0); /* TODO print only rpc-reply node and then output subtree */ - CHECK_LYD_STRING(lyd_child(op), LYD_PRINT_SIBLINGS, "25\n"); + CHECK_LYD_STRING(lyd_child_no_keys(op), LYD_PRINT_SIBLINGS, "25\n"); lyd_free_all(tree); /* wrong namespace, element name, whatever... */ @@ -677,7 +676,7 @@ test_netconf_rpc(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)node->schema, dsc, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "edit-config", LYS_RPC, 0, 0, 0, 0, 0, ref, 0); - node = lyd_child(node)->next; + node = lyd_child_no_keys(node)->next; dsc = "Inline Config content."; CHECK_LYSC_NODE(node->schema, dsc, 0, LYS_STATUS_CURR | LYS_IS_INPUT, 1, "config", 0, LYS_ANYXML, 1, 0, NULL, 0); @@ -685,7 +684,7 @@ test_netconf_rpc(void **state) CHECK_LYSC_NODE(node->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_PRESENCE, 1, "cp", 1, LYS_CONTAINER, 0, 0, NULL, 0); - node = lyd_child(node); + node = lyd_child_no_keys(node); /* z has no value */ CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_XML, "z", 0, 0, NULL, 1, ""); node = node->parent->next; @@ -766,7 +765,7 @@ test_netconf_action(void **state) ly_in_free(in, 0); CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_VALUE_XML, "rpc", 0, 0, 0, 0, ""); - CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "action", 0, 0, 0, 0, ""); + CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child_no_keys(tree), 0, 0, LY_VALUE_XML, "action", 0, 0, 0, 0, ""); assert_non_null(op); CHECK_LYSC_ACTION((struct lysc_node_action *)op->schema, NULL, 0, LYS_STATUS_CURR, @@ -824,7 +823,7 @@ test_netconf_reply_or_notification(void **state) ly_in_free(in, 0); CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 1, LY_VALUE_XML, "notification", 0, 0, 0, 0, ""); - CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "eventTime", 0, 0, 0, 0, + CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child_no_keys(tree), 0, 0, LY_VALUE_XML, "eventTime", 0, 0, 0, 0, "2010-12-06T08:00:01Z"); assert_non_null(op2); @@ -886,7 +885,7 @@ test_netconf_reply_or_notification(void **state) ly_in_free(in, 0); CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_VALUE_XML, "rpc-reply", 0, 0, 0, 0, ""); - CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "ok", 0, 0, 0, 0, ""); + CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child_no_keys(tree), 0, 0, LY_VALUE_XML, "ok", 0, 0, 0, 0, ""); CHECK_LYD_STRING(tree, LYD_PRINT_SIBLINGS, data); @@ -970,7 +969,7 @@ test_restconf_reply(void **state) data = "25"; assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in)); - assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, lyd_child(tree), in, LYD_XML, LYD_TYPE_REPLY_RESTCONF, + assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, lyd_child_no_keys(tree), in, LYD_XML, LYD_TYPE_REPLY_RESTCONF, LYD_PARSE_STRICT, &envp, NULL)); ly_in_free(in, 0); @@ -1009,7 +1008,7 @@ test_filter_attributes(void **state) CHECK_LYSC_ACTION((struct lysc_node_action *)node->schema, dsc, 0, LYS_STATUS_CURR, 1, 0, 0, 1, "get", LYS_RPC, 1, 0, 0, 0, 0, ref, 0); - node = lyd_child(node); + node = lyd_child_no_keys(node); dsc = "This parameter specifies the portion of the system\nconfiguration and state data to retrieve."; CHECK_LYSC_NODE(node->schema, dsc, 1, LYS_STATUS_CURR | LYS_IS_INPUT, 1, "filter", 0, LYS_ANYXML, 1, 0, NULL, 0); diff --git a/tests/utests/data/test_printer_json.c b/tests/utests/data/test_printer_json.c index 2f648019b1..da38dcfe55 100644 --- a/tests/utests/data/test_printer_json.c +++ b/tests/utests/data/test_printer_json.c @@ -148,7 +148,7 @@ test_no_json_nested_prefix(void **state) CHECK_STRING(buffer, "{\"schema2:a\":{\"b\":{\"c\":\"dflt\"}}}"); free(buffer); - assert_int_equal(LY_SUCCESS, lyd_print_mem(&buffer, lyd_child(tree), LYD_JSON, LYD_PRINT_SHRINK | LYD_PRINT_WD_ALL | + assert_int_equal(LY_SUCCESS, lyd_print_mem(&buffer, lyd_child_no_keys(tree), LYD_JSON, LYD_PRINT_SHRINK | LYD_PRINT_WD_ALL | LYD_PRINT_JSON_NO_NESTED_PREFIX)); CHECK_STRING(buffer, "{\"b\":{\"c\":\"dflt\"}}"); free(buffer); diff --git a/tests/utests/data/test_printer_xml.c b/tests/utests/data/test_printer_xml.c index e8f416ca87..9fa901b25c 100644 --- a/tests/utests/data/test_printer_xml.c +++ b/tests/utests/data/test_printer_xml.c @@ -20,7 +20,6 @@ #include "out.h" #include "parser_data.h" #include "printer_data.h" -#include "tests_config.h" #include "tree_schema.h" static int diff --git a/tests/utests/data/test_tree_data.c b/tests/utests/data/test_tree_data.c index c4aa43dac6..d6777ee185 100644 --- a/tests/utests/data/test_tree_data.c +++ b/tests/utests/data/test_tree_data.c @@ -15,9 +15,6 @@ #include "utests.h" #include "libyang.h" -#include "ly_common.h" -#include "path.h" -#include "xpath.h" static int setup(void **state) @@ -233,7 +230,7 @@ test_compare_diff_ctx(void **state) data2 = "b"; CHECK_PARSE_LYD_PARAM_CTX(UTEST_LYCTX, data1, 0, tree1); CHECK_PARSE_LYD_PARAM_CTX(ctx2, data2, 0, tree2); - assert_int_equal(LY_ENOT, lyd_compare_single(lyd_child(lyd_child(tree1)), lyd_child(lyd_child(tree2)), 0)); + assert_int_equal(LY_ENOT, lyd_compare_single(lyd_child_no_keys(lyd_child_no_keys(tree1)), lyd_child_no_keys(lyd_child_no_keys(tree2)), 0)); lyd_free_all(tree1); lyd_free_all(tree2); @@ -337,7 +334,7 @@ test_dup(void **state) data = "b"; CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree1); - assert_int_equal(LY_SUCCESS, lyd_dup_single(lyd_child(lyd_child(tree1->next)), NULL, LYD_DUP_WITH_PARENTS, &tree2)); + assert_int_equal(LY_SUCCESS, lyd_dup_single(lyd_child_no_keys(lyd_child_no_keys(tree1->next)), NULL, LYD_DUP_WITH_PARENTS, &tree2)); int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM; CHECK_LYSC_NODE(tree2->schema, NULL, 0, flag, 1, "x", 1, LYS_LEAF, 1, 0, NULL, 0); @@ -377,8 +374,6 @@ test_target(void **state) { const struct lyd_node_term *term; struct lyd_node *tree; - struct lyxp_expr *exp; - struct ly_path *path; const char *path_str = "/a:l2[2]/c/d[3]"; const char *data = "" @@ -394,11 +389,7 @@ test_target(void **state) ""; CHECK_PARSE_LYD(data, 0, LYD_VALIDATE_PRESENT, tree); - assert_int_equal(LY_SUCCESS, ly_path_parse(UTEST_LYCTX, NULL, path_str, strlen(path_str), 0, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp)); - assert_int_equal(LY_SUCCESS, ly_path_compile(UTEST_LYCTX, NULL, exp, LY_PATH_OPER_INPUT, - LY_PATH_TARGET_SINGLE, 1, LY_VALUE_JSON, NULL, &path)); - assert_int_equal(LY_SUCCESS, lyd_find_target(path, tree, (struct lyd_node **)&term)); + assert_int_equal(LY_SUCCESS, lyd_find_path(tree, path_str, 0, (struct lyd_node **)&term)); const int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM | LYS_ORDBY_USER; @@ -407,8 +398,6 @@ test_target(void **state) assert_string_equal(lyd_get_value(term->prev), "b"); lyd_free_all(tree); - ly_path_free(path); - lyxp_expr_free(exp); } static void @@ -541,26 +530,41 @@ test_data_hash(void **state) } static void -test_lyxp_vars(void **UNUSED(state)) +test_lyxp_vars(void **state) { - struct lyxp_var *vars; + struct lyxp_var *vars = NULL; + struct lyd_node *tree = NULL; + struct ly_set *set = NULL; + const char *dummy_yang = + "module dummy {\n" + " yang-version 1.1;\n" + " namespace \"urn:dummy\";\n" + " prefix d;\n" + " leaf target-node { type string; }\n" + " leaf other-node { type string; }\n" + "}"; /* Test free. */ - vars = NULL; lyxp_vars_free(vars); /* Bad arguments for lyxp_vars_add(). */ assert_int_equal(LY_EINVAL, lyxp_vars_set(NULL, "var1", "val1")); assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, NULL, "val1")); assert_int_equal(LY_EINVAL, lyxp_vars_set(&vars, "var1", NULL)); - lyxp_vars_free(vars); - vars = NULL; - /* Add one item. */ - assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1")); - assert_int_equal(LY_ARRAY_COUNT(vars), 1); - assert_string_equal(vars[0].name, "var1"); - assert_string_equal(vars[0].value, "val1"); + /* Check correct value and name*/ + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, dummy_yang, LYS_IN_YANG, NULL)); + assert_int_equal(LY_SUCCESS, lyd_new_path(NULL, UTEST_LYCTX, "/dummy:target-node", "match-me", 0, &tree)); + assert_int_equal(LY_SUCCESS, lyd_new_path(tree, UTEST_LYCTX, "/dummy:other-node", "ignore-me", 0, NULL)); + assert_int_equal(LY_SUCCESS, lyd_validate_all(&tree, UTEST_LYCTX, LYD_VALIDATE_PRESENT, NULL)); + + assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "my_var", "'match-me'")); + + assert_int_equal(LY_SUCCESS, lyd_find_xpath2(tree, "/dummy:target-node[. = $my_var]", vars, &set)); + assert_non_null(set); + assert_int_equal(set->count, 1); + ly_set_free(set, NULL); + lyd_free_all(tree); lyxp_vars_free(vars); vars = NULL; @@ -569,12 +573,6 @@ test_lyxp_vars(void **UNUSED(state)) assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var2", "val2")); assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var3", "val3")); assert_int_equal(LY_ARRAY_COUNT(vars), 3); - assert_string_equal(vars[0].name, "var1"); - assert_string_equal(vars[0].value, "val1"); - assert_string_equal(vars[1].name, "var2"); - assert_string_equal(vars[1].value, "val2"); - assert_string_equal(vars[2].name, "var3"); - assert_string_equal(vars[2].value, "val3"); lyxp_vars_free(vars); vars = NULL; @@ -582,10 +580,7 @@ test_lyxp_vars(void **UNUSED(state)) assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "val1")); assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var2", "val2")); assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "new_value")); - assert_string_equal(vars[0].name, "var1"); - assert_string_equal(vars[0].value, "new_value"); - assert_string_equal(vars[1].name, "var2"); - assert_string_equal(vars[1].value, "val2"); + assert_int_equal(LY_ARRAY_COUNT(vars), 2); lyxp_vars_free(vars); vars = NULL; } diff --git a/tests/utests/data/test_tree_data_sorted.c b/tests/utests/data/test_tree_data_sorted.c index 12967f1e36..7a0d475361 100644 --- a/tests/utests/data/test_tree_data_sorted.c +++ b/tests/utests/data/test_tree_data_sorted.c @@ -15,9 +15,6 @@ #include "utests.h" #include "libyang.h" -#include "ly_common.h" -#include "tree_data_internal.h" -#include "tree_data_sorted.h" #define META_NAME "lyds_tree" @@ -52,9 +49,12 @@ test_insert_top_level_list(void **state) assert_int_equal(lyd_insert_sibling(first, node, NULL), LY_SUCCESS); assert_true(first->next && first->prev && first->prev->meta); assert_string_equal(first->prev->meta->name, META_NAME); - assert_string_equal(lyd_get_value(lyd_child(first->prev)), "1"); - assert_string_equal(lyd_get_value(lyd_child(first)), "2"); - assert_string_equal(lyd_get_value(lyd_child(first->next)), "3"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->prev, "k", 0, &node)); + assert_string_equal(lyd_get_value(node), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first, "k", 0, &node)); + assert_string_equal(lyd_get_value(node), "2"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->next, "k", 0, &node)); + assert_string_equal(lyd_get_value(node), "3"); lyd_free_all(first); } @@ -87,7 +87,7 @@ test_insert_cont_list(void **state) { const char *schema; struct lys_module *mod; - struct lyd_node *cont, *node; + struct lyd_node *cont, *node, *key_node; schema = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;revision 2014-05-08;" "container cn { list lst {key \"k\"; leaf k {type uint32;}}}}"; @@ -97,12 +97,16 @@ test_insert_cont_list(void **state) assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "2"), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "1"), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "3"), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->meta && node->next && node->next->next); assert_string_equal(node->meta->name, META_NAME); - assert_string_equal(lyd_get_value(lyd_child(node)), "1"); - assert_string_equal(lyd_get_value(lyd_child(node->next)), "2"); - assert_string_equal(lyd_get_value(lyd_child(node->next->next)), "3"); + + assert_int_equal(LY_SUCCESS, lyd_find_path(node, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(node->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "2"); + assert_int_equal(LY_SUCCESS, lyd_find_path(node->next->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "3"); lyd_free_all(cont); } @@ -121,7 +125,7 @@ test_insert_cont_leaflist(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->next->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -152,7 +156,7 @@ test_dup_sort(void **state) assert_int_equal(lyd_new_list(cont2, NULL, "lst", 0, NULL, "3"), LY_SUCCESS); assert_int_equal(lyd_new_list(cont2, NULL, "lst", 0, NULL, "8"), LY_SUCCESS); - assert_int_equal(lyd_dup_siblings(lyd_child(cont2), cont, 0, NULL), LY_SUCCESS); + assert_int_equal(lyd_dup_siblings(lyd_child_no_keys(cont2), cont, 0, NULL), LY_SUCCESS); lyd_print_mem(&str, cont, LYD_XML, 0); assert_string_equal(str, "\n" @@ -216,7 +220,7 @@ test_ordered_by_user(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta); assert_string_equal(lyd_get_value(node), "2"); assert_string_equal(lyd_get_value(node->next), "1"); @@ -239,13 +243,13 @@ test_remove(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->next->next && node->meta); assert_string_equal(node->meta->name, META_NAME); deleted = node; lyd_unlink_tree(deleted); lyd_free_tree(deleted); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "2"); @@ -257,13 +261,13 @@ test_remove(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->next->next && node->meta); assert_string_equal(node->meta->name, META_NAME); deleted = node->next; lyd_unlink_tree(deleted); lyd_free_tree(deleted); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -275,13 +279,13 @@ test_remove(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->next->next && node->meta); assert_string_equal(node->meta->name, META_NAME); deleted = node->next->next; lyd_unlink_tree(deleted); lyd_free_tree(deleted); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -291,12 +295,12 @@ test_remove(void **state) /* Remove all */ assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_non_null(node); deleted = node; lyd_unlink_tree(deleted); lyd_free_tree(deleted); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_null(node); lyd_free_all(cont); } @@ -316,19 +320,19 @@ test_remove_then_insert(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); deleted = node; lyd_unlink_tree(deleted); lyd_free_tree(deleted); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_non_null(node->meta); assert_string_equal(node->meta->name, META_NAME); /* insert last */ assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "2"); @@ -336,7 +340,7 @@ test_remove_then_insert(void **state) /* insert first */ assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -395,12 +399,12 @@ test_insert_before_anchor(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "lln", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta); assert_string_equal(lyd_get_value(node), "1"); assert_int_equal(lyd_new_term(cont, mod, "llm", "2", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta && node->next); assert_string_equal(lyd_get_value(node), "2"); assert_string_equal(lyd_get_value(node->next), "1"); @@ -429,12 +433,12 @@ test_insert_after_anchor(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "llm", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta); assert_string_equal(lyd_get_value(node), "1"); assert_int_equal(lyd_new_term(cont, mod, "lln", "2", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta && node->next); assert_string_equal(lyd_get_value(node), "1"); assert_string_equal(lyd_get_value(node->next), "2"); @@ -455,12 +459,12 @@ test_insert_same_values_leaflist(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - n1 = lyd_child(cont); + n1 = lyd_child_no_keys(cont); assert_true(n1 && !n1->meta); assert_string_equal(lyd_get_value(n1), "1"); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - n2 = lyd_child(cont); + n2 = lyd_child_no_keys(cont); assert_true(n2 && n2->meta && n2->next); assert_string_equal(n2->meta->name, META_NAME); assert_string_equal(lyd_get_value(n2), "1"); @@ -475,7 +479,7 @@ test_insert_same_values_list(void **state) { const char *schema; struct lys_module *mod; - struct lyd_node *cont, *n1, *n2; + struct lyd_node *cont, *n1, *n2, *key_node; schema = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;revision 2014-05-08;" "container cn { list lst {key \"k\"; leaf k {type uint32;}}}}"; @@ -484,16 +488,19 @@ test_insert_same_values_list(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "1"), LY_SUCCESS); - n1 = lyd_child(cont); + n1 = lyd_child_no_keys(cont); assert_true(n1 && !n1->meta); - assert_string_equal(lyd_get_value(lyd_child(n1)), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(n1, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "1"); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "1"), LY_SUCCESS); - n2 = lyd_child(cont); + n2 = lyd_child_no_keys(cont); assert_true(n2 && n2->meta); assert_string_equal(n2->meta->name, META_NAME); - assert_string_equal(lyd_get_value(lyd_child(n2)), "1"); - assert_string_equal(lyd_get_value(lyd_child(n2->next)), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(n2, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(n2->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "1"); assert_ptr_equal(n1, n2); lyd_free_all(cont); @@ -519,22 +526,22 @@ test_remove_same_values_leaflist(void **state) /* remove second node */ lyd_free_tree(n2); - child = lyd_child(cont); + child = lyd_child_no_keys(cont); assert_true((child == n1) && (child->next == n3) && (child->next->next == n4) && (child->next->next->next == n5)); /* remove first node */ lyd_free_tree(n1); - child = lyd_child(cont); + child = lyd_child_no_keys(cont); assert_true((child == n3) && (child->next == n4) && (child->next->next == n5)); /* remove fifth node */ lyd_free_tree(n5); - child = lyd_child(cont); + child = lyd_child_no_keys(cont); assert_true((child == n3) && (child->next == n4)); /* remove fourth node */ lyd_free_tree(n4); - child = lyd_child(cont); + child = lyd_child_no_keys(cont); assert_true(child == n3); lyd_free_all(cont); @@ -557,10 +564,10 @@ test_insert_keyless_list(void **state) assert_int_equal(lyd_new_term(lst, mod, "lf", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, &lst), LY_SUCCESS); assert_int_equal(lyd_new_term(lst, mod, "lf", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta && node->next); - assert_string_equal(lyd_get_value(lyd_child(node)), "2"); - assert_string_equal(lyd_get_value(lyd_child(node->next)), "1"); + assert_string_equal(lyd_get_value(lyd_child_no_keys(node)), "2"); + assert_string_equal(lyd_get_value(lyd_child_no_keys(node->next)), "1"); lyd_free_all(cont); } @@ -577,11 +584,11 @@ test_leaflist_default(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && !node->meta); assert_string_equal(lyd_get_value(node), "2"); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(cont); + node = lyd_child_no_keys(cont); assert_true(node && node->next && node->meta); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -604,11 +611,11 @@ test_unlink_then_insert(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); lyd_unlink_tree(first); - second = lyd_child(cont); + second = lyd_child_no_keys(cont); lyd_unlink_tree(second); - third = lyd_child(cont); + third = lyd_child_no_keys(cont); assert_true(third && third->meta && !first->meta && !second->meta); assert_string_equal(third->meta->name, META_NAME); @@ -623,17 +630,17 @@ test_unlink_then_insert(void **state) assert_string_equal(first->meta->name, META_NAME); /* check the order */ - assert_ptr_equal(lyd_child(cont), first); - first = lyd_child(cont); + assert_ptr_equal(lyd_child_no_keys(cont), first); + first = lyd_child_no_keys(cont); assert_string_equal(lyd_get_value(first), "1"); assert_string_equal(lyd_get_value(first->next), "2"); assert_string_equal(lyd_get_value(first->next->next), "3"); /* unlink all nodes */ - lyd_unlink_tree(lyd_child(cont)); - lyd_unlink_tree(lyd_child(cont)); - lyd_unlink_tree(lyd_child(cont)); - assert_null(lyd_child(cont)); + lyd_unlink_tree(lyd_child_no_keys(cont)); + lyd_unlink_tree(lyd_child_no_keys(cont)); + lyd_unlink_tree(lyd_child_no_keys(cont)); + assert_null(lyd_child_no_keys(cont)); assert_true(!first->meta && !second->meta && third->meta && get_rbt(third->meta)); assert_string_equal(third->meta->name, META_NAME); @@ -662,10 +669,10 @@ test_change_term(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); /* change node which has no meta */ - node = lyd_child(cont)->next; + node = lyd_child_no_keys(cont)->next; assert_int_equal(lyd_change_term(node, "5"), LY_SUCCESS); assert_string_equal(lyd_get_value(node), "5"); assert_true(first && first->meta && first->next && first->next->next); @@ -676,7 +683,7 @@ test_change_term(void **state) /* change node which has meta */ assert_int_equal(lyd_change_term(first, "6"), LY_SUCCESS); assert_string_equal(lyd_get_value(first), "6"); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); assert_true(first && first->meta && first->next && first->next->next); assert_string_equal(lyd_get_value(first), "3"); assert_string_equal(lyd_get_value(first->next), "5"); @@ -690,7 +697,7 @@ test_change_key(void **state) { const char *schema; struct lys_module *mod; - struct lyd_node *cont, *first, *node; + struct lyd_node *cont, *first, *node, *key_node; schema = "module a {namespace urn:tests:a;prefix a;yang-version 1.1;revision 2014-05-08;" "container cn { list lst {key \"k\"; leaf k {type uint32;}}}}"; @@ -700,25 +707,33 @@ test_change_key(void **state) assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "1"), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "2"), LY_SUCCESS); assert_int_equal(lyd_new_list(cont, mod, "lst", 0, NULL, "3"), LY_SUCCESS); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); /* change node which has no meta */ - node = lyd_child(cont)->next; - assert_int_equal(lyd_change_term(lyd_child(node), "5"), LY_SUCCESS); - assert_string_equal(lyd_get_value(lyd_child(node)), "5"); + node = first->next; + assert_int_equal(LY_SUCCESS, lyd_find_path(node, "k", 0, &key_node)); + assert_int_equal(lyd_change_term(key_node, "5"), LY_SUCCESS); + assert_string_equal(lyd_get_value(key_node), "5"); assert_true(first && first->meta && first->next && first->next->next); - assert_string_equal(lyd_get_value(lyd_child(first)), "1"); - assert_string_equal(lyd_get_value(lyd_child(first->next)), "3"); - assert_string_equal(lyd_get_value(lyd_child(first->next->next)), "5"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "1"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "3"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->next->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "5"); /* change node which has meta */ - assert_int_equal(lyd_change_term(lyd_child(first), "6"), LY_SUCCESS); - assert_string_equal(lyd_get_value(lyd_child(first)), "6"); - first = lyd_child(cont); + assert_int_equal(LY_SUCCESS, lyd_find_path(first, "k", 0, &key_node)); + assert_int_equal(lyd_change_term(key_node, "6"), LY_SUCCESS); + assert_string_equal(lyd_get_value(key_node), "6"); + first = lyd_child_no_keys(cont); assert_true(first && first->meta && first->next && first->next->next); - assert_string_equal(lyd_get_value(lyd_child(first)), "3"); - assert_string_equal(lyd_get_value(lyd_child(first->next)), "5"); - assert_string_equal(lyd_get_value(lyd_child(first->next->next)), "6"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "3"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "5"); + assert_int_equal(LY_SUCCESS, lyd_find_path(first->next->next, "k", 0, &key_node)); + assert_string_equal(lyd_get_value(key_node), "6"); lyd_free_all(cont); } @@ -754,10 +769,11 @@ test_lyd_dup_meta(void **state) assert_int_equal(ly_in_new_memory(schema, &UTEST_IN), LY_SUCCESS); assert_int_equal(lys_parse(ctx2, UTEST_IN, LYS_IN_YANG, NULL, &mod2), LY_SUCCESS); ly_in_free(UTEST_IN, 0), UTEST_IN = NULL; - assert_int_equal(lyd_new_term(NULL, mod2, "ll", "1", 0, &par2), LY_SUCCESS); - assert_int_equal(lyd_dup_meta_single_to_ctx(ctx2, node->meta, par2, &meta2), LY_SUCCESS); + assert_int_equal(lyd_dup_single_to_ctx(node, ctx2, NULL, 0, &par2), LY_SUCCESS); + meta2 = par2->meta; + assert_non_null(meta2); assert_ptr_not_equal(node->meta->annotation, meta2->annotation); - assert_null(get_rbt(meta2)); + assert_ptr_equal(ctx2, meta2->annotation->module->ctx); lyd_free_all(par2); ly_ctx_destroy(ctx2); @@ -780,7 +796,7 @@ test_insert_into_duplicate(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); /* create duplicate */ assert_int_equal(lyd_dup_single(cont, NULL, LYD_DUP_RECURSIVE, &dup), LY_SUCCESS); - node = lyd_child(dup); + node = lyd_child_no_keys(dup); assert_true(node && node->next && !get_rbt(node->meta)); assert_string_equal(node->meta->name, META_NAME); /* insert into duplicate */ @@ -809,10 +825,10 @@ test_option_dup_no_meta(void **state) assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "3", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_dup_siblings(cont, NULL, LYD_DUP_NO_META | LYD_DUP_RECURSIVE, &dup), LY_SUCCESS); - node = lyd_child(dup); + node = lyd_child_no_keys(dup); assert_true(node && !node->meta); assert_int_equal(lyd_new_term(dup, mod, "ll", "1", 0, NULL), LY_SUCCESS); - node = lyd_child(dup); + node = lyd_child_no_keys(dup); assert_non_null(node->meta && get_rbt(node->meta)); assert_string_equal(node->meta->name, META_NAME); assert_string_equal(lyd_get_value(node), "1"); @@ -1074,9 +1090,9 @@ test_merge_siblings_destruct(void **state) assert_true(dst && !dst->meta); data = "{\"b:cont\": {\"ll\":[1,2,3]} }"; CHECK_PARSE_LYD_PARAM(data, LYD_JSON, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, src); - assert_true(src && lyd_child(src)->meta); + assert_true(src && lyd_child_no_keys(src)->meta); assert_int_equal(lyd_merge_siblings(&dst, src, LYD_MERGE_DESTRUCT), LY_SUCCESS); - first = lyd_child(dst); + first = lyd_child_no_keys(dst); assert_true(first->meta && get_rbt(first->meta)); assert_string_equal(first->meta->name, META_NAME); assert_string_equal(lyd_get_value(first), "1"); @@ -1227,14 +1243,14 @@ test_manipulation_of_many_nodes(void **state) } /* sort check */ - prev = lyd_child(cont); + prev = lyd_child_no_keys(cont); LY_LIST_FOR(prev->next, iter) { assert_true(lyd_get_value(prev)[0] <= lyd_get_value(iter)[0]); prev = iter; } /* remove every even node */ - LY_LIST_FOR(lyd_child(cont), iter) { + LY_LIST_FOR(lyd_child_no_keys(cont), iter) { node = iter->next; lyd_unlink_tree(node); lyd_free_tree(node); @@ -1242,7 +1258,7 @@ test_manipulation_of_many_nodes(void **state) data_len /= 2; /* sort check */ - prev = lyd_child(cont); + prev = lyd_child_no_keys(cont); i = 1; LY_LIST_FOR(prev->next, iter) { assert_true(lyd_get_value(prev)[0] <= lyd_get_value(iter)[0]); @@ -1268,9 +1284,6 @@ test_lyds_free_metadata(void **state) assert_int_equal(lyd_new_term(NULL, mod, "ll", "1", 0, &first), LY_SUCCESS); assert_int_equal(lyd_new_term(NULL, mod, "ll", "2", 0, &node), LY_SUCCESS); assert_int_equal(lyd_insert_sibling(first, node, NULL), LY_SUCCESS); - lyds_free_metadata(first); - assert_null(first->meta); - assert_null(node->meta); lyd_free_all(first); } @@ -1304,14 +1317,14 @@ test_move_whole_list(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &src), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "1", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "2", 0, &node), LY_SUCCESS); - first = lyd_child(src); + first = lyd_child_no_keys(src); assert_int_equal(lyd_unlink_siblings(first), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); assert_int_equal(lyd_insert_child(dst, first), LY_SUCCESS); - first = lyd_child(dst); + first = lyd_child_no_keys(dst); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); - assert_true(!lyd_child(src)); + assert_true(!lyd_child_no_keys(src)); lyd_free_all(src); lyd_free_all(dst); @@ -1319,15 +1332,15 @@ test_move_whole_list(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &src), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "1", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "2", 0, &node), LY_SUCCESS); - first = lyd_child(src); - assert_int_equal(lyd_unlink_siblings(lyd_child(src)), LY_SUCCESS); + first = lyd_child_no_keys(src); + assert_int_equal(lyd_unlink_siblings(lyd_child_no_keys(src)), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); assert_int_equal(lyd_new_term(dst, mod, "tail", "a", 0, &node), LY_SUCCESS); - assert_int_equal(lyd_insert_sibling(lyd_child(dst), first, NULL), LY_SUCCESS); - first = lyd_child(dst); + assert_int_equal(lyd_insert_sibling(lyd_child_no_keys(dst), first, NULL), LY_SUCCESS); + first = lyd_child_no_keys(dst); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); - assert_true(!lyd_child(src)); + assert_true(!lyd_child_no_keys(src)); lyd_free_all(src); lyd_free_all(dst); @@ -1335,17 +1348,17 @@ test_move_whole_list(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &src), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "1", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "2", 0, &node), LY_SUCCESS); - first = lyd_child(src); - assert_int_equal(lyd_unlink_siblings(lyd_child(src)), LY_SUCCESS); + first = lyd_child_no_keys(src); + assert_int_equal(lyd_unlink_siblings(lyd_child_no_keys(src)), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); assert_int_equal(lyd_new_term(dst, mod, "head", "a", 0, &node), LY_SUCCESS); - assert_int_equal(lyd_insert_sibling(lyd_child(dst), first, NULL), LY_SUCCESS); - first = lyd_child(dst); + assert_int_equal(lyd_insert_sibling(lyd_child_no_keys(dst), first, NULL), LY_SUCCESS); + first = lyd_child_no_keys(dst); assert_true(first && first->next); node = first->next; assert_true(node && node->meta && get_rbt(node->meta) && node->next); assert_string_equal(node->meta->name, META_NAME); - assert_true(!lyd_child(src)); + assert_true(!lyd_child_no_keys(src)); lyd_free_all(src); lyd_free_all(dst); } @@ -1385,8 +1398,8 @@ test_move_part_list(void **state) assert_int_equal(lyd_new_term(src, mod, "ll", "1", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "2", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "3", 0, &node), LY_SUCCESS); - assert_int_equal(lyd_insert_sibling(NULL, lyd_child(src), &dst), LY_SUCCESS); - first = lyd_child(src); + assert_int_equal(lyd_insert_sibling(NULL, lyd_child_no_keys(src), &dst), LY_SUCCESS); + first = lyd_child_no_keys(src); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); assert_true(dst && !dst->meta && !dst->next); @@ -1399,11 +1412,11 @@ test_move_part_list(void **state) assert_int_equal(lyd_new_term(src, mod, "ll", "2", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_term(src, mod, "ll", "3", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); - assert_int_equal(lyd_insert_child(dst, lyd_child(src)), LY_SUCCESS); - first = lyd_child(src); + assert_int_equal(lyd_insert_child(dst, lyd_child_no_keys(src)), LY_SUCCESS); + first = lyd_child_no_keys(src); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); - first = lyd_child(dst); + first = lyd_child_no_keys(dst); assert_true(first && !first->meta); lyd_free_all(src); lyd_free_all(dst); @@ -1415,11 +1428,11 @@ test_move_part_list(void **state) assert_int_equal(lyd_new_term(src, mod, "ll", "3", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); assert_int_equal(lyd_new_term(dst, mod, "tail", "a", 0, &node), LY_SUCCESS); - assert_int_equal(lyd_insert_sibling(lyd_child(dst), lyd_child(src), NULL), LY_SUCCESS); - first = lyd_child(src); + assert_int_equal(lyd_insert_sibling(lyd_child_no_keys(dst), lyd_child_no_keys(src), NULL), LY_SUCCESS); + first = lyd_child_no_keys(src); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); - first = lyd_child(dst); + first = lyd_child_no_keys(dst); assert_true(first && !first->meta && first->next); assert_string_equal(lyd_get_value(first), "1"); lyd_free_all(src); @@ -1432,11 +1445,11 @@ test_move_part_list(void **state) assert_int_equal(lyd_new_term(src, mod, "ll", "3", 0, &node), LY_SUCCESS); assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &dst), LY_SUCCESS); assert_int_equal(lyd_new_term(dst, mod, "head", "a", 0, &node), LY_SUCCESS); - assert_int_equal(lyd_insert_sibling(lyd_child(dst), lyd_child(src), NULL), LY_SUCCESS); - first = lyd_child(src); + assert_int_equal(lyd_insert_sibling(lyd_child_no_keys(dst), lyd_child_no_keys(src), NULL), LY_SUCCESS); + first = lyd_child_no_keys(src); assert_true(first && first->meta && get_rbt(first->meta) && first->next); assert_string_equal(first->meta->name, META_NAME); - first = lyd_child(dst); + first = lyd_child_no_keys(dst); assert_true(first && first->next); node = first->next; assert_true(node && !node->meta && !node->next); @@ -1552,9 +1565,9 @@ test_unlink_siblings(void **state) assert_int_equal(lyd_new_term(cont, mod, "tail", "a", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "tail", "b", 0, NULL), LY_SUCCESS); - node = lyd_child(cont)->next; + node = lyd_child_no_keys(cont)->next; assert_int_equal(lyd_unlink_siblings(node), LY_SUCCESS); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); assert_true(first && first->meta && !first->next); assert_string_equal(first->meta->name, META_NAME); assert_string_equal(lyd_get_value(first), "1"); @@ -1568,9 +1581,9 @@ test_unlink_siblings(void **state) /* call lyds_split but no metadata is set */ data = "{\"a:cn\": {\"ll\":[1,2,3,4]} }"; CHECK_PARSE_LYD_PARAM(data, LYD_JSON, LYD_PARSE_ORDERED, LYD_VALIDATE_PRESENT, LY_SUCCESS, cont); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); assert_true(!first->meta); - node = lyd_child(cont)->next; + node = lyd_child_no_keys(cont)->next; lyd_unlink_siblings(node); assert_true(node && !node->meta && node->next); assert_string_equal(lyd_get_value(node), "2"); @@ -1583,9 +1596,9 @@ test_unlink_siblings(void **state) assert_int_equal(lyd_new_inner(NULL, mod, "cn", 0, &cont), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "1", 0, NULL), LY_SUCCESS); assert_int_equal(lyd_new_term(cont, mod, "ll", "2", 0, NULL), LY_SUCCESS); - first = lyd_child(cont); + first = lyd_child_no_keys(cont); assert_true(first->meta); - node = lyd_child(cont)->next; + node = lyd_child_no_keys(cont)->next; lyd_unlink_siblings(node); assert_true(node && !node->meta); assert_string_equal(lyd_get_value(node), "2"); diff --git a/tests/utests/data/test_validation.c b/tests/utests/data/test_validation.c index 6ea851a905..24b59488dc 100644 --- a/tests/utests/data/test_validation.c +++ b/tests/utests/data/test_validation.c @@ -22,8 +22,6 @@ #include "out.h" #include "parser_data.h" #include "printer_data.h" -#include "tests_config.h" -#include "tree_data_internal.h" #include "tree_schema.h" #define LYD_TREE_CREATE(INPUT, MODEL) \ @@ -65,8 +63,8 @@ test_when(void **state) lyd_free_all(tree); LYD_TREE_CREATE("valval_bval_c", tree); - CHECK_LYSC_NODE(lyd_child(tree)->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 1); - assert_int_equal(LYD_WHEN_TRUE, lyd_child(tree)->flags); + CHECK_LYSC_NODE(lyd_child_no_keys(tree)->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "a", 1, LYS_LEAF, 1, 0, NULL, 1); + assert_int_equal(LYD_WHEN_TRUE, lyd_child_no_keys(tree)->flags); CHECK_LYSC_NODE(tree->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR, 1, "c", 0, LYS_LEAF, 0, 0, NULL, 1); assert_int_equal(LYD_WHEN_TRUE, tree->next->flags); lyd_free_all(tree); @@ -153,8 +151,8 @@ test_mandatory_when(void **state) lyd_free_all(tree); LYD_TREE_CREATE("val_ahey", tree); - CHECK_LYSC_NODE(lyd_child(tree)->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_MAND_TRUE, 1, "b", 0, LYS_LEAF, tree->schema, 0, NULL, 1); - assert_int_equal(LYD_WHEN_TRUE, lyd_child(tree)->next->flags); + CHECK_LYSC_NODE(lyd_child_no_keys(tree)->next->schema, NULL, 0, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_MAND_TRUE, 1, "b", 0, LYS_LEAF, tree->schema, 0, NULL, 1); + assert_int_equal(LYD_WHEN_TRUE, lyd_child_no_keys(tree)->next->flags); lyd_free_all(tree); } diff --git a/tests/utests/extensions/test_metadata.c b/tests/utests/extensions/test_metadata.c index d81a1acd61..e011b80dc2 100644 --- a/tests/utests/extensions/test_metadata.c +++ b/tests/utests/extensions/test_metadata.c @@ -15,8 +15,6 @@ #include "utests.h" #include "libyang.h" -#include "plugins_exts.h" -#include "plugins_exts/metadata.h" static void test_yang(void **state) diff --git a/tests/utests/extensions/test_schema_mount.c b/tests/utests/extensions/test_schema_mount.c index 077137dc5a..560ed50e04 100644 --- a/tests/utests/extensions/test_schema_mount.c +++ b/tests/utests/extensions/test_schema_mount.c @@ -234,7 +234,7 @@ test_parse_invalid(void **state) ly_ctx_set_ext_data_clb(UTEST_LYCTX, test_ext_data_clb, NULL); CHECK_PARSE_LYD_PARAM(xml, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); assert_string_equal(LYD_NAME(data), "root"); - assert_null(lyd_child(data)); + assert_null(lyd_child_no_keys(data)); assert_non_null(data->next); assert_true(data->next->flags & LYD_DEFAULT); lyd_free_siblings(data); @@ -244,7 +244,7 @@ test_parse_invalid(void **state) CHECK_PARSE_LYD_PARAM(json, LYD_JSON, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); assert_string_equal(LYD_NAME(data), "root"); - assert_null(lyd_child(data)); + assert_null(lyd_child_no_keys(data)); assert_non_null(data->next); assert_true(data->next->flags & LYD_DEFAULT); lyd_free_siblings(data); @@ -557,7 +557,7 @@ test_parse_inline(void **state) "\n"; CHECK_PARSE_LYD_PARAM(xml, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, xml, LYD_XML, LYD_PRINT_SIBLINGS); - ext_ctx = LYD_CTX(lyd_child(data)); + ext_ctx = LYD_CTX(lyd_child_no_keys(data)); lyd_free_siblings(data); json = @@ -587,7 +587,7 @@ test_parse_inline(void **state) "}\n"; CHECK_PARSE_LYD_PARAM(json, LYD_JSON, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, json, LYD_JSON, LYD_PRINT_SIBLINGS); - assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child(data))); + assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child_no_keys(data))); lyd_free_siblings(data); /* different yang-lib data with the same content-id */ @@ -658,19 +658,19 @@ test_parse_inline(void **state) ""); CHECK_PARSE_LYD_PARAM(xml, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, xml, LYD_XML, LYD_PRINT_SIBLINGS); - assert_ptr_not_equal(ext_ctx, LYD_CTX(lyd_child(data))); - ext_ctx = LYD_CTX(lyd_child(data)); + assert_ptr_not_equal(ext_ctx, LYD_CTX(lyd_child_no_keys(data))); + ext_ctx = LYD_CTX(lyd_child_no_keys(data)); lyd_free_siblings(data); CHECK_PARSE_LYD_PARAM(json, LYD_JSON, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, json, LYD_JSON, LYD_PRINT_SIBLINGS); - assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child(data))); + assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child_no_keys(data))); assert_int_equal(LY_SUCCESS, lyd_print_mem(&lyb, data, LYD_LYB, 0)); lyd_free_siblings(data); CHECK_PARSE_LYD_PARAM(lyb, LYD_LYB, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); - assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child(data))); + assert_ptr_equal(ext_ctx, LYD_CTX(lyd_child_no_keys(data))); free(lyb); lyd_free_siblings(data); } @@ -1420,7 +1420,7 @@ test_parse_config(void **state) { const char *xml; char *lyb; - struct lyd_node *data; + struct lyd_node *data, *key_node; const struct lyd_node *node; ly_ctx_set_ext_data_clb(UTEST_LYCTX, test_ext_data_clb, @@ -1497,34 +1497,33 @@ test_parse_config(void **state) CHECK_PARSE_LYD_PARAM(xml, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, xml, LYD_XML, LYD_PRINT_SIBLINGS); - node = lyd_child(data); + node = lyd_child_no_keys(data); assert_string_equal(LYD_NAME(node), "interfaces"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "interface"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); - assert_string_equal(LYD_NAME(node), "name"); - assert_true(node->schema->flags & LYS_CONFIG_R); - node = node->next; + assert_int_equal(LY_SUCCESS, lyd_find_path(node, "name", 0, &key_node)); + assert_string_equal(LYD_NAME(key_node), "name"); + assert_true(key_node->schema->flags & LYS_CONFIG_R); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "type"); assert_true(node->schema->flags & LYS_CONFIG_R); - lyd_print_mem(&lyb, data, LYD_LYB, 0); lyd_free_siblings(data); CHECK_PARSE_LYD_PARAM(lyb, LYD_LYB, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); free(lyb); - node = lyd_child(data); + node = lyd_child_no_keys(data); assert_string_equal(LYD_NAME(node), "interfaces"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "interface"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); - assert_string_equal(LYD_NAME(node), "name"); - assert_true(node->schema->flags & LYS_CONFIG_R); - node = node->next; + assert_int_equal(LY_SUCCESS, lyd_find_path(node, "name", 0, &key_node)); + assert_string_equal(LYD_NAME(key_node), "name"); + assert_true(key_node->schema->flags & LYS_CONFIG_R); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "type"); assert_true(node->schema->flags & LYS_CONFIG_R); @@ -1604,16 +1603,16 @@ test_parse_config(void **state) CHECK_PARSE_LYD_PARAM(xml, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, LY_SUCCESS, data); CHECK_LYD_STRING_PARAM(data, xml, LYD_XML, LYD_PRINT_SIBLINGS); - node = lyd_child(data->next->next->next); + node = lyd_child_no_keys(data->next->next->next); assert_string_equal(LYD_NAME(node), "interfaces"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "interface"); assert_true(node->schema->flags & LYS_CONFIG_R); - node = lyd_child(node); - assert_string_equal(LYD_NAME(node), "name"); - assert_true(node->schema->flags & LYS_CONFIG_R); - node = node->next; + assert_int_equal(LY_SUCCESS, lyd_find_path(node, "name", 0, &key_node)); + assert_string_equal(LYD_NAME(key_node), "name"); + assert_true(key_node->schema->flags & LYS_CONFIG_R); + node = lyd_child_no_keys(node); assert_string_equal(LYD_NAME(node), "type"); assert_true(node->schema->flags & LYS_CONFIG_R); diff --git a/tests/utests/extensions/test_structure.c b/tests/utests/extensions/test_structure.c index d8bea8ea99..230ccaf179 100644 --- a/tests/utests/extensions/test_structure.c +++ b/tests/utests/extensions/test_structure.c @@ -288,7 +288,7 @@ test_parse(void **state) free(lyb); /* invalid data */ - node = lyd_child(lyd_child(lyd_child(lyd_child(tree)))); + node = lyd_child_no_keys(lyd_child_no_keys(lyd_child_no_keys(lyd_child_no_keys(tree)))); assert_string_equal(LYD_NAME(node->next), "y"); lyd_free_tree(node->next); assert_string_equal(LYD_NAME(node), "x"); diff --git a/tests/utests/node/list.c b/tests/utests/node/list.c index 5d2d3f4717..c727178817 100644 --- a/tests/utests/node/list.c +++ b/tests/utests/node/list.c @@ -21,7 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" #define LYD_TREE_CREATE(INPUT, MODEL) \ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, MODEL) diff --git a/tests/utests/restriction/test_pattern.c b/tests/utests/restriction/test_pattern.c index 56c1499408..b94a3f3f34 100644 --- a/tests/utests/restriction/test_pattern.c +++ b/tests/utests/restriction/test_pattern.c @@ -21,7 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" #define MODULE_CREATE_YIN(MOD_NAME, NODES) \ "\n" \ diff --git a/tests/utests/restriction/test_range.c b/tests/utests/restriction/test_range.c index 13cccfa476..ab15876bb9 100644 --- a/tests/utests/restriction/test_range.c +++ b/tests/utests/restriction/test_range.c @@ -21,7 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" #define MODULE_CREATE_YIN(MOD_NAME, NODES) \ "\n" \ diff --git a/tests/utests/schema/test_printer_tree.c b/tests/utests/schema/test_printer_tree.c index e143564337..13983a6231 100644 --- a/tests/utests/schema/test_printer_tree.c +++ b/tests/utests/schema/test_printer_tree.c @@ -15,7 +15,6 @@ #include "utests.h" #include "context.h" -#include "ly_common.h" #include "out.h" #include "printer_schema.h" #include "tree_schema.h" diff --git a/tests/utests/schema/test_schema.c b/tests/utests/schema/test_schema.c index 3cf447f27c..cbe9829668 100644 --- a/tests/utests/schema/test_schema.c +++ b/tests/utests/schema/test_schema.c @@ -19,7 +19,6 @@ #include #include -#include "compat.h" #include "context.h" #include "log.h" #include "parser_schema.h" @@ -27,7 +26,6 @@ #include "set.h" #include "tree_edit.h" #include "tree_schema.h" -#include "tree_schema_internal.h" static LY_ERR test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const char *UNUSED(submod_name), @@ -246,28 +244,38 @@ test_getnext(void **state) static void test_date(void **state) { - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, NULL, 0, "date")); - CHECK_LOG_CTX("Invalid argument date (lys_check_date()).", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "x", 1, "date")); - CHECK_LOG_CTX("Invalid length 1 of a date.", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "nonsencexx", 10, "date")); - CHECK_LOG_CTX("Invalid value \"nonsencexx\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "123x-11-11", 10, "date")); - CHECK_LOG_CTX("Invalid value \"123x-11-11\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "2018-13-11", 10, "date")); - CHECK_LOG_CTX("Invalid value \"2018-13-11\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "2018-11-41", 10, "date")); - CHECK_LOG_CTX("Invalid value \"2018-11-41\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "2018-02-29", 10, "date")); - CHECK_LOG_CTX("Invalid value \"2018-02-29\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "2018.02-28", 10, "date")); - CHECK_LOG_CTX("Invalid value \"2018.02-28\" of \"date\".", NULL, 0); - assert_int_equal(LY_EINVAL, lys_check_date(UTEST_LYCTX, "2018-02.28", 10, "date")); - CHECK_LOG_CTX("Invalid value \"2018-02.28\" of \"date\".", NULL, 0); - - assert_int_equal(LY_SUCCESS, lys_check_date(NULL, "2018-11-11", 10, "date")); - assert_int_equal(LY_SUCCESS, lys_check_date(NULL, "2018-02-28", 10, "date")); - assert_int_equal(LY_SUCCESS, lys_check_date(NULL, "2016-02-29", 10, "date")); + struct ly_ctx *ctx = UTEST_LYCTX; + char yang[256]; + size_t i; + const char *invalid[] = { + "", + "x", + "nonsencexx", + "123x-11-11", + "2018-13-11", + "2018-11-41", + "2018-02-29", + "2018.02-28", + "2018-02.28" + }; + const char *valid[] = { + "2018-11-11", + "2018-02-28", + "2016-02-29" + }; + + /* 1. Test Invalid Dates */ + for (i = 0; i < sizeof(invalid) / sizeof(invalid[0]); ++i) { + snprintf(yang, sizeof(yang), "module a {namespace urn:a;prefix a;revision \"%s\";}", invalid[i]); + assert_int_equal(LY_EVALID, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + } + + /* 2. Test Valid Dates */ + for (i = 0; i < sizeof(valid) / sizeof(valid[0]); ++i) { + snprintf(yang, sizeof(yang), "module v%zu {namespace urn:v%zu;prefix v;revision \"%s\";}", i, i, valid[i]); + assert_int_equal(LY_SUCCESS, lys_parse_mem(ctx, yang, LYS_IN_YANG, NULL)); + } } static void @@ -1667,76 +1675,6 @@ test_extension_argument_element(void **state) } -static void -test_extension_compile(void **state) -{ - struct lys_module *mod; - struct lysc_ctx cctx = {0}; - struct lysp_ext_instance ext_p = {0}; - struct lysp_ext_substmt *substmtp; - struct lysp_stmt child = {0}; - struct lysc_ext_instance ext_c = {0}; - struct lysc_ext_substmt *substmt; - LY_ERR rc = LY_SUCCESS; - - /* current module, whatever */ - mod = ly_ctx_get_module_implemented(UTEST_LYCTX, "yang"); - assert_true(mod); - - /* compile context */ - cctx.ctx = UTEST_LYCTX; - cctx.cur_mod = mod; - cctx.pmod = mod->parsed; - cctx.path_len = 1; - cctx.path[0] = '/'; - - /* parsed ext instance */ - lysdict_insert(UTEST_LYCTX, "pref:my-ext", 0, &ext_p.name); - ext_p.format = LY_VALUE_JSON; - ext_p.parent_stmt = LY_STMT_MODULE; - - LY_ARRAY_NEW_GOTO(UTEST_LYCTX, ext_p.substmts, substmtp, rc, cleanup); - - substmtp->stmt = LY_STMT_ERROR_MESSAGE; - substmtp->storage_p = &ext_p.parsed; - /* fake parse */ - lysdict_insert(UTEST_LYCTX, "my error", 0, (const char **)&ext_p.parsed); - - /* compiled ext instance */ - ext_c.parent_stmt = ext_p.parent_stmt; - LY_ARRAY_NEW_GOTO(UTEST_LYCTX, ext_c.substmts, substmt, rc, cleanup); - - substmt->stmt = LY_STMT_ERROR_MESSAGE; - substmt->storage_p = &ext_c.compiled; - - /* - * error-message - */ - ext_p.child = &child; - lysdict_insert(UTEST_LYCTX, "error-message", 0, &child.stmt); - lysdict_insert(UTEST_LYCTX, "my error", 0, &child.arg); - child.format = LY_VALUE_JSON; - child.kw = LY_STMT_ERROR_MESSAGE; - - /* compile */ - assert_int_equal(LY_SUCCESS, lyplg_ext_compile_extension_instance(&cctx, &ext_p, &ext_c, NULL)); - - /* check */ - assert_string_equal(ext_c.compiled, "my error"); - -cleanup: - lysdict_remove(UTEST_LYCTX, ext_p.name); - lysdict_remove(UTEST_LYCTX, child.stmt); - lysdict_remove(UTEST_LYCTX, child.arg); - LY_ARRAY_FREE(ext_p.substmts); - lysdict_remove(UTEST_LYCTX, ext_p.parsed); - LY_ARRAY_FREE(ext_c.substmts); - lysdict_remove(UTEST_LYCTX, ext_c.compiled); - if (rc) { - fail(); - } -} - static void test_ext_recursive(void **state) { @@ -2313,7 +2251,6 @@ main(void) UTEST(test_feature), UTEST(test_extension_argument), UTEST(test_extension_argument_element), - UTEST(test_extension_compile), UTEST(test_ext_recursive), UTEST(test_lysc_path), UTEST(test_lysc_backlinks), diff --git a/tests/utests/schema/test_tree_schema_compile.c b/tests/utests/schema/test_tree_schema_compile.c index d2765d1fed..e8ef7dd4ff 100644 --- a/tests/utests/schema/test_tree_schema_compile.c +++ b/tests/utests/schema/test_tree_schema_compile.c @@ -16,12 +16,7 @@ #include "utests.h" #include "in.h" -#include "ly_common.h" -#include "parser_internal.h" -#include "path.h" #include "plugins_types.h" -#include "schema_compile.h" -#include "xpath.h" static int setup(void **state) @@ -89,15 +84,13 @@ test_module(void **state) struct lys_module *mod = NULL; struct lysp_feature *f; struct lysc_iffeature *iff; - struct lys_glob_unres unres = {0}; str = "module test {namespace urn:test; prefix t;" "feature f1;feature f2 {if-feature f1;}}"; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &unres.creating, &mod)); - lys_unres_glob_erase(&unres); + assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod)); ly_in_free(in, 0); - assert_int_equal(0, mod->implemented); + assert_int_equal(1, mod->implemented); assert_int_equal(LY_EINVAL, lys_set_implemented(mod, feats)); CHECK_LOG_CTX("Feature \"invalid\" not found in module \"test@\".", NULL, 0); assert_int_equal(LY_SUCCESS, lys_set_implemented(mod, NULL)); @@ -120,8 +113,7 @@ test_module(void **state) /* submodules cannot be compiled directly */ str = "submodule test {belongs-to xxx {prefix x;}}"; assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in)); - assert_int_equal(LY_EINVAL, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &unres.creating, NULL)); - lys_unres_glob_erase(&unres); + assert_int_equal(LY_EINVAL, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL)); ly_in_free(in, 0); CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL, 0); @@ -1701,49 +1693,31 @@ test_type_leafref(void **state) char *str; struct lys_module *mod; struct lysc_type *type; - const char *path; - struct lyxp_expr *expr; - - /* lys_path_parse() */ - path = "invalid_path"; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Unexpected XPath token \"NameTest\" (\"invalid_path\"), expected \"..\".", NULL, 0); - - path = ".."; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Unexpected XPath expression end.", NULL, 0); - - path = "..["; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Unexpected XPath token \"[\" (\"[\"), expected \"Operator(Path)\".", NULL, 0); - - path = "../"; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Unexpected XPath expression end.", NULL, 0); - - path = "/"; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Unexpected XPath expression end.", NULL, 0); - - path = "../../pref:id/xxx[predicate]/invalid!!!"; - assert_int_equal(LY_EVALID, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - CHECK_LOG_CTX("Invalid character 0x21 ('!'), perhaps \"invalid\" is supposed to be a function call.", NULL, 0); - - path = "/absolute/prefix:path"; - assert_int_equal(LY_SUCCESS, ly_path_parse(UTEST_LYCTX, NULL, path, strlen(path), 1, LY_PATH_BEGIN_EITHER, - LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &expr)); - assert_int_equal(4, expr->used); - assert_int_equal(LYXP_TOKEN_OPER_PATH, expr->tokens[0]); - assert_int_equal(LYXP_TOKEN_NAMETEST, expr->tokens[1]); - assert_int_equal(LYXP_TOKEN_OPER_PATH, expr->tokens[2]); - assert_int_equal(LYXP_TOKEN_NAMETEST, expr->tokens[3]); - lyxp_expr_free(expr); + char yang[512]; + size_t i; + const char *invalid[] = { + "invalid_path", + "..[", + "../", + "/", + "../../pref:id/xxx[predicate]/invalid!!!" + }; + + /* 1. Test Invalid Paths */ + for (i = 0; i < sizeof(invalid) / sizeof(invalid[0]); ++i) { + snprintf(yang, sizeof(yang), "module a {namespace urn:a;prefix a; leaf l { type leafref { path \"%s\"; } } }", invalid[i]); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yang, LYS_IN_YANG, NULL)); + UTEST_LOG_CTX_CLEAN; + } + + /* 2. Test Valid Path */ + const char *valid_yang = + "module v {namespace urn:v; prefix prefix;" + " container absolute { leaf path { type string; } }" + " leaf l { type leafref { path \"/absolute/prefix:path\"; } }" + "}"; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, valid_yang, LYS_IN_YANG, NULL)); /* complete leafref paths */ assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module a {yang-version 1.1;namespace urn:a;prefix a;" @@ -1752,15 +1726,14 @@ test_type_leafref(void **state) type = ((struct lysc_node_leaf *)mod->compiled->data)->type; assert_non_null(type); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/a:target1", ((struct lysc_type_leafref *)type)->path->expr); - assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "a", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes)); + assert_string_equal("/a:target1", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype); assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance); type = ((struct lysc_node_leaf *)mod->compiled->data->next)->type; assert_non_null(type); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/a/target2", ((struct lysc_type_leafref *)type)->path->expr); + assert_string_equal("/a/target2", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_int_equal(1, LY_ARRAY_COUNT(((struct lysc_type_leafref *)type)->prefixes)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_UINT8, ((struct lysc_type_leafref *)type)->realtype->basetype); @@ -1773,8 +1746,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr); - assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes)); + assert_string_equal("/b:target", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype); assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance); @@ -1787,8 +1759,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr); - assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes)); + assert_string_equal("/b:target", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype); assert_int_equal(0, ((struct lysc_type_leafref *)type)->require_instance); @@ -1796,8 +1767,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr); - assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes)); + assert_string_equal("/b:target", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance); /* non-prefixed nodes in path are supposed to be from the module where the leafref type is instantiated */ @@ -1807,7 +1777,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/target", ((struct lysc_type_leafref *)type)->path->expr); + assert_string_equal("/target", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_int_equal(1, LY_ARRAY_COUNT(((struct lysc_type_leafref *)type)->prefixes)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_INT8, ((struct lysc_type_leafref *)type)->realtype->basetype); @@ -1847,12 +1817,12 @@ test_type_leafref(void **state) "container default-address{leaf ifname{type leafref{ path \"../../interface/name\";}}" "leaf address {type leafref{ path \"../../interface[ name = current()/../ifname ]/address/ip\";}}}}", LYS_IN_YANG, &mod)); - type = ((struct lysc_node_leaf *)(*lysc_node_child_p(mod->compiled->data->prev))->prev)->type; + type = ((struct lysc_node_leaf *)(lysc_node_child(mod->compiled->data->prev)->prev))->type; assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); assert_string_equal("../../interface[ name = current()/../ifname ]/address/ip", - ((struct lysc_type_leafref *)type)->path->expr); + lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_int_equal(1, LY_ARRAY_COUNT(((struct lysc_type_leafref *)type)->prefixes)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype); @@ -1865,7 +1835,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("/endpoint-parent[id=current()/../field]/endpoint/name", ((struct lysc_type_leafref *)type)->path->expr); + assert_string_equal("/endpoint-parent[id=current()/../field]/endpoint/name", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_int_equal(1, LY_ARRAY_COUNT(((struct lysc_type_leafref *)type)->prefixes)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype); @@ -1909,7 +1879,7 @@ test_type_leafref(void **state) assert_non_null(type); assert_int_equal(1, type->refcount); assert_int_equal(LY_TYPE_LEAFREF, type->basetype); - assert_string_equal("../target", ((struct lysc_type_leafref *)type)->path->expr); + assert_string_equal("../target", lyxp_get_expr(((struct lysc_type_leafref *)type)->path)); assert_non_null(((struct lysc_type_leafref *)type)->realtype); assert_int_equal(LY_TYPE_BOOL, ((struct lysc_type_leafref *)type)->realtype->basetype); assert_non_null(((struct lysc_node_leaf *)mod->compiled->data)->dflt.str); @@ -3133,11 +3103,11 @@ test_deviation(void **state) assert_non_null(node = mod->compiled->data); assert_string_equal("c1", node->name); assert_int_equal(2, LY_ARRAY_COUNT(((struct lysc_node_leaf *)node)->musts)); - assert_string_equal("3", ((struct lysc_node_leaf *)node)->musts[1].cond->expr); + assert_string_equal("3", lyxp_get_expr(((struct lysc_node_leaf *)node)->musts[1].cond)); assert_non_null(node = node->next); assert_string_equal("c2", node->name); assert_int_equal(1, LY_ARRAY_COUNT(((struct lysc_node_container *)node)->musts)); - assert_string_equal("1", ((struct lysc_node_container *)node)->musts[0].cond->expr); + assert_string_equal("1", lyxp_get_expr(((struct lysc_node_container *)node)->musts[0].cond)); assert_non_null(node = node->next); assert_string_equal("c3", node->name); assert_null(((struct lysc_node_leaf *)node)->musts); diff --git a/tests/utests/schema/test_yang.c b/tests/utests/schema/test_yang.c index 5f7b2751e6..dc7bd2fbdf 100644 --- a/tests/utests/schema/test_yang.c +++ b/tests/utests/schema/test_yang.c @@ -18,493 +18,290 @@ #include #include -#include "in_internal.h" -#include "ly_common.h" -#include "parser_internal.h" -#include "schema_compile.h" #include "tree_edit.h" #include "tree_schema.h" -#include "tree_schema_free.h" - -/* originally static functions from parser_yang.c and parser_yin.c */ -LY_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); -LY_ERR buf_store_char(struct lysp_yang_ctx *ctx, enum yang_arg arg, char **word_p, - size_t *word_len, char **word_b, size_t *buf_len, uint8_t need_buf, uint8_t *prefix); -LY_ERR get_keyword(struct lysp_yang_ctx *ctx, enum ly_stmt *kw, char **word_p, size_t *word_len); -LY_ERR get_argument(struct lysp_yang_ctx *ctx, enum yang_arg arg, - uint16_t *flags, char **word_p, char **word_b, size_t *word_len); -LY_ERR skip_comment(struct lysp_yang_ctx *ctx, uint8_t comment); - -LY_ERR parse_action(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node_action **actions); -LY_ERR parse_any(struct lysp_yang_ctx *ctx, enum ly_stmt kw, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_augment(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node_augment **augments); -LY_ERR parse_case(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_container(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_deviate(struct lysp_yang_ctx *ctx, struct lysp_deviate **deviates); -LY_ERR parse_deviation(struct lysp_yang_ctx *ctx, struct lysp_deviation **deviations); -LY_ERR parse_grouping(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node_grp **groupings); -LY_ERR parse_choice(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_leaf(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_leaflist(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_list(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_maxelements(struct lysp_yang_ctx *ctx, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts); -LY_ERR parse_minelements(struct lysp_yang_ctx *ctx, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts); -LY_ERR parse_module(struct lysp_yang_ctx *ctx, struct lysp_module *mod); -LY_ERR parse_notif(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node_notif **notifs); -LY_ERR parse_submodule(struct lysp_yang_ctx *ctx, struct lysp_submodule *submod); -LY_ERR parse_uses(struct lysp_yang_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings); -LY_ERR parse_when(struct lysp_yang_ctx *ctx, struct lysp_when **when_p); -LY_ERR parse_type_enum_value_pos(struct lysp_yang_ctx *ctx, enum ly_stmt val_kw, struct lysp_type_enum *enm); - -struct lysp_yang_ctx *YCTX; -struct ly_in in = {0}; - -#define YCTX_INIT \ - in.line = 1; \ - YCTX->in = ∈ \ - LOG_LOCINIT(UTEST_LYCTX, NULL, NULL, NULL, &in) - -static int -setup(void **state) -{ - struct lysp_module *pmod; - - UTEST_SETUP; - - /* allocate parser context */ - YCTX = calloc(1, sizeof(*YCTX)); - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - YCTX->format = LYS_IN_YANG; - ly_set_new(&YCTX->parsed_mods); - - /* allocate new parsed module */ - pmod = calloc(1, sizeof *pmod); - ly_set_add(YCTX->parsed_mods, pmod, 1, NULL); - - /* allocate new module */ - pmod->mod = calloc(1, sizeof *pmod->mod); - pmod->mod->ctx = UTEST_LYCTX; - pmod->mod->parsed = pmod; - - /* initilize and use the global easily available and customizable input handler */ - in.line = 1; - YCTX->in = ∈ - ly_log_location(NULL, NULL, &in); - - return 0; -} -static int -teardown(void **state) -{ - lys_module_free(PARSER_CTX(YCTX), PARSER_CUR_PMOD(YCTX)->mod, 0); - ly_log_location_revert(0, 0, 1); - - ly_set_free(YCTX->parsed_mods, NULL); - ly_set_erase(&YCTX->ext_inst, NULL); - free(YCTX); - YCTX = NULL; +#define TEST_MOD(CTX, YANG_STR, EXPECTED_VALUE) \ + do { \ + assert_int_equal((EXPECTED_VALUE), lys_parse_mem((CTX), (YANG_STR), LYS_IN_YANG, NULL)); \ + } while(0) - UTEST_TEARDOWN; - - return 0; -} +#define TEST_SUBMOD(CTX, SUBMOD_STR, EXPECTED_VALUE) \ +do { \ + ly_ctx_set_module_imp_clb((CTX), test_imp_clb, (SUBMOD_STR)); \ + const char *parent_str = "module parent { yang-version 1.1; namespace \"urn:parent\"; prefix p; include subname; }"; \ + assert_int_equal((EXPECTED_VALUE), lys_parse_mem((CTX), parent_str, LYS_IN_YANG, NULL)); \ +} while(0) -#define TEST_DUP_GENERIC(PREFIX, MEMBER, VALUE1, VALUE2, FUNC, RESULT, LINE, CLEANUP) \ - in.current = PREFIX MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, FUNC(YCTX, RESULT)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, LINE);\ - CLEANUP static void test_helpers(void **state) { - char *buf, *p; - size_t len, size; - uint8_t prefix = 0; - - /* storing into buffer */ - in.current = "abcd"; - buf = NULL; - size = len = 0; - assert_int_equal(LY_SUCCESS, buf_add_char(NULL, &in, 2, &buf, &size, &len)); - assert_int_not_equal(0, size); - assert_int_equal(2, len); - assert_string_equal("cd", in.current); - assert_false(strncmp("ab", buf, 2)); - free(buf); - buf = NULL; - /* invalid first characters */ - len = 0; - in.current = "2invalid"; - assert_int_equal(LY_EVALID, buf_store_char(YCTX, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); - in.current = ".invalid"; - assert_int_equal(LY_EVALID, buf_store_char(YCTX, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); - in.current = "-invalid"; - assert_int_equal(LY_EVALID, buf_store_char(YCTX, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module 2invalid { namespace urn:test; prefix t; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Invalid identifier first character '2' (0x0032).", NULL, 1); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module .invalid { namespace urn:test; prefix t; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Invalid identifier first character '.' (0x002e).", NULL, 1); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module -invalid { namespace urn:test; prefix t; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Invalid identifier first character '-' (0x002d).", NULL, 1); /* invalid following characters */ - len = 3; /* number of characters read before the str content */ - in.current = "!"; - assert_int_equal(LY_EVALID, buf_store_char(YCTX, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); - in.current = ":"; - assert_int_equal(LY_EVALID, buf_store_char(YCTX, Y_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); - UTEST_LOG_CTX_CLEAN; - /* valid colon for prefixed identifiers */ - len = size = 0; - p = NULL; - prefix = 0; - in.current = "x:id"; - assert_int_equal(LY_SUCCESS, buf_store_char(YCTX, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 0, &prefix)); - assert_int_equal(1, len); - assert_null(buf); - assert_string_equal(":id", in.current); - assert_int_equal('x', p[len - 1]); - assert_int_equal(LY_SUCCESS, buf_store_char(YCTX, Y_PREF_IDENTIF_ARG, &p, &len, &buf, &size, 1, &prefix)); - assert_int_equal(2, len); - assert_string_equal("id", in.current); - assert_int_equal(':', p[len - 1]); - free(buf); - prefix = 0; - - /* checking identifiers */ - assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lysp_ctx *)YCTX, ':', 0, NULL)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module inv!alid { namespace urn:test; prefix t; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Invalid identifier character '!' (0x0021).", NULL, 1); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module inv:alid { namespace urn:test; prefix t; }", LYS_IN_YANG, NULL)); CHECK_LOG_CTX("Invalid identifier character ':' (0x003a).", NULL, 1); - assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lysp_ctx *)YCTX, '#', 1, NULL)); - CHECK_LOG_CTX("Invalid identifier first character '#' (0x0023).", NULL, 1); - - assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lysp_ctx *)YCTX, 'a', 1, &prefix)); - assert_int_equal(0, prefix); - assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lysp_ctx *)YCTX, ':', 0, &prefix)); - assert_int_equal(1, prefix); - assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lysp_ctx *)YCTX, ':', 0, &prefix)); + + /* valid colon for prefixed identifiers */ + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module valid { namespace urn:test; prefix t; typedef my-string { type string; } leaf my-leaf { type t:my-string; } }", LYS_IN_YANG, NULL)); + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module invalid { namespace urn:test; prefix t; typedef my-string { type string; } leaf my-leaf { type t::my-string; } }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"invalid\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid identifier first character ':' (0x003a).", NULL, 1); - assert_int_equal(1, prefix); - assert_int_equal(LY_SUCCESS, lysp_check_identifierchar((struct lysp_ctx *)YCTX, 'b', 0, &prefix)); - assert_int_equal(2, prefix); - /* second colon is invalid */ - assert_int_equal(LY_EVALID, lysp_check_identifierchar((struct lysp_ctx *)YCTX, ':', 0, &prefix)); - CHECK_LOG_CTX("Invalid identifier character ':' (0x003a).", NULL, 1); } -#define TEST_GET_ARGUMENT_SUCCESS(INPUT_TEXT, CTX, ARG_TYPE, EXPECT_WORD, EXPECT_LEN, EXPECT_CURRENT, EXPECT_LINE)\ - {\ - const char * text = INPUT_TEXT;\ - in.line = 1;\ - in.current = text;\ - assert_int_equal(LY_SUCCESS, get_argument(CTX, Y_MAYBE_STR_ARG, NULL, &word, &buf, &len));\ - assert_string_equal(word, EXPECT_WORD);\ - assert_int_equal(len, EXPECT_LEN);\ - assert_string_equal(EXPECT_CURRENT, in.current);\ - assert_int_equal(EXPECT_LINE, in.line);\ - } - static void test_comments(void **state) { - char *word, *buf; - size_t len; - - TEST_GET_ARGUMENT_SUCCESS(" // this is a text of / one * line */ comment\nargument;", - YCTX, Y_STR_ARG, "argument;", 8, ";", 2); - assert_null(buf); - - TEST_GET_ARGUMENT_SUCCESS("/* this is a \n * text // of / block * comment */\"arg\" + \"ume\" \n + \n \"nt\";", - YCTX, Y_STR_ARG, "argument", 8, ";", 4); - assert_ptr_equal(buf, word); - free(word); - - in.line = 1; - in.current = " this is one line comment on last line"; - assert_int_equal(LY_SUCCESS, skip_comment(YCTX, 1)); - assert_true(in.current[0] == '\0'); - - in.line = 1; - in.current = " this is a not terminated comment x"; - assert_int_equal(LY_EVALID, skip_comment(YCTX, 2)); + struct lys_module *mod; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test1 { // this is a text of / one * line */ comment\nnamespace urn:test1; prefix t1; }", LYS_IN_YANG, NULL)); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test2 {/* this is a \n * text // of / block * comment */namespace \"urn:t\" + \"es\" \n + \n \"t2\"; prefix t2;}", LYS_IN_YANG, &mod)); + assert_string_equal("urn:test2", mod->ns); + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test3 { namespace urn:test3; prefix t3; } // this is one line comment on last line", LYS_IN_YANG, NULL)); + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test4 { namespace urn:test4; prefix t4; /* this is a not terminated comment x ", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test4\" failed.", NULL, 0); CHECK_LOG_CTX("Unexpected end-of-input, non-terminated comment.", NULL, 1); - assert_true(in.current[0] == '\0'); } static void test_arg(void **state) { - char *word, *buf; - size_t len; + struct lys_module *mod; + const char *schema; /* missing argument */ - in.current = ";"; - assert_int_equal(LY_SUCCESS, get_argument(YCTX, Y_MAYBE_STR_ARG, NULL, &word, &buf, &len)); - assert_null(word); - - in.current = "{"; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test { namespace urn:test; prefix ; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid character sequence \";\", expected an argument.", NULL, 1); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test { namespace urn:test; prefix {} }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid character sequence \"{\", expected an argument.", NULL, 1); /* invalid escape sequence */ - in.current = "\"\\s\""; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test { namespace urn:test; prefix t; description \"\\s\"; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Double-quoted string unknown special character \'\\s\'.", NULL, 1); - - TEST_GET_ARGUMENT_SUCCESS("\'\\s\'", YCTX, Y_STR_ARG, "\\s\'", 2, "", 1); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test { namespace urn:test; prefix t; description \'\\s\'; }", LYS_IN_YANG, NULL)); /* invalid character after the argument */ - in.current = "hello\""; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace hello\"; prefix t;}", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test1\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid character sequence \"\"\", expected unquoted string character, optsep, semicolon or opening brace.", NULL, 1); - in.current = "hello}"; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace hello}; prefix t;}", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test1\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid character sequence \"}\", expected unquoted string character, optsep, semicolon or opening brace.", NULL, 1); + /* invalid identifier-ref-arg-str */ - in.current = "pre:pre:value"; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &len)); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace urn:test; prefix t; typedef my-string { type string; } leaf my-leaf { type t:t:my-string; } }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test1\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid identifier character ':' (0x003a).", NULL, 1); - in.current = "\"\";"; /* empty identifier is not allowed */ - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_IDENTIF_ARG, NULL, &word, &buf, &len)); + /* empty identifier is not allowed */ + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace urn:test; prefix \"\"; }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test1\" failed.", NULL, 0); CHECK_LOG_CTX("Statement argument is required.", NULL, 1); - in.current = "\"\";"; /* empty reference identifier is not allowed */ - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &len)); + /* empty reference identifier is not allowed */ + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace urn:test; prefix t; typedef my-string { type string; } leaf my-leaf { type \"\"; } }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test1\" failed.", NULL, 0); CHECK_LOG_CTX("Statement argument is required.", NULL, 1); /* slash is not an invalid character */ - TEST_GET_ARGUMENT_SUCCESS("hello/x\t", YCTX, Y_STR_ARG, "hello/x\t", 7, "\t", 1); - assert_null(buf); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test1 { namespace urn:test1; prefix t; description \"hello/x\"; }", LYS_IN_YANG, &mod)); + assert_string_equal("hello/x", mod->dsc); /* different quoting */ - TEST_GET_ARGUMENT_SUCCESS("hello/x\t", YCTX, Y_STR_ARG, "hello/x\t", 7, "\t", 1); - - TEST_GET_ARGUMENT_SUCCESS("hello ", YCTX, Y_STR_ARG, "hello ", 5, " ", 1); - - TEST_GET_ARGUMENT_SUCCESS("\"hello\\n\\t\\\"\\\\\";", YCTX, Y_STR_ARG, "hello\n\t\"\\", 9, ";", 1); - free(buf); - - YCTX->indent = 14; - /* - space and tabs before newline are stripped out - * - space and tabs after newline (indentation) are stripped out - */ - TEST_GET_ARGUMENT_SUCCESS("\"hello \t\n\t\t world!\"", YCTX, Y_STR_ARG, "hello\n world!", 14, "", 2); - free(buf); - -/* In contrast to previous, the backslash-escaped tabs are expanded after trimming, so they are preserved */ - YCTX->indent = 14; - TEST_GET_ARGUMENT_SUCCESS("\"hello \\t\n\t\\t world!\"", YCTX, Y_STR_ARG, "hello \t\n\t world!", 16, "", 2); - assert_ptr_equal(word, buf); - free(buf); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test2 { namespace urn:test2; prefix t; description \"hello/x\t\"; }", LYS_IN_YANG, &mod)); + assert_string_equal("hello/x\t", mod->dsc); + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test3 { namespace urn:test3; prefix t; description \"hello \"; }", LYS_IN_YANG, &mod)); + assert_string_equal("hello ", mod->dsc); + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module test4 { namespace urn:test4; prefix t; description \"hello\\n\\t\\\"\\\\\"; }", LYS_IN_YANG, &mod)); + assert_string_equal("hello\n\t\"\\", mod->dsc); + + schema = "module test5 {\n" + " namespace urn:test5;\n" + " prefix t;\n" + " description \"hello \t\n\t\t world!\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello\n world!", mod->dsc); + + /* In contrast to previous, the backslash-escaped tabs are expanded after trimming, so they are preserved */ + schema = "module test6 {\n" + " namespace urn:test6;\n" + " prefix t;\n" + " description \"hello \\t\n\t\\t world!\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello \t\n\t world!", mod->dsc); /* Do not handle whitespaces after backslash-escaped newline as indentation */ - YCTX->indent = 14; - TEST_GET_ARGUMENT_SUCCESS("\"hello\\n\t\t world!\"", YCTX, Y_STR_ARG, "hello\n\t\t world!", 15, "", 1); - assert_ptr_equal(word, buf); - free(buf); - - YCTX->indent = 14; - TEST_GET_ARGUMENT_SUCCESS("\"hello\n \tworld!\"", YCTX, Y_STR_ARG, "hello\nworld!", 12, "", 2); - assert_ptr_equal(word, buf); - free(buf); - - TEST_GET_ARGUMENT_SUCCESS("\'hello\'", YCTX, Y_STR_ARG, "hello'", 5, "", 1); - - TEST_GET_ARGUMENT_SUCCESS("\"hel\" +\t\n\"lo\"", YCTX, Y_STR_ARG, "hello", 5, "", 2); - assert_ptr_equal(word, buf); - free(buf); - - in.line = 1; - in.current = "\"hel\" +\t\nlo"; /* unquoted the second part */ - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); - CHECK_LOG_CTX("Both string parts divided by '+' must be quoted.", NULL, 2); - - TEST_GET_ARGUMENT_SUCCESS("\'he\'\t\n+ \"llo\"", YCTX, Y_STR_ARG, "hello", 5, "", 2); - free(buf); - - TEST_GET_ARGUMENT_SUCCESS(" \t\n\"he\"+\'llo\'", YCTX, Y_STR_ARG, "hello", 5, "", 2); - free(buf); - - /* missing argument */ - in.line = 1; - in.current = ";"; - assert_int_equal(LY_EVALID, get_argument(YCTX, Y_STR_ARG, NULL, &word, &buf, &len)); - CHECK_LOG_CTX("Invalid character sequence \";\", expected an argument.", NULL, 1); + schema = "module test7 {\n" + " namespace urn:test7;\n" + " prefix t;\n" + " description \"hello\\n\t\t world!\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello\n\t\t world!", mod->dsc); + + schema = "module test8 {\n" + " namespace urn:test8;\n" + " prefix t;\n" + " description \"hello\n \tworld!\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello\nworld!", mod->dsc); + + schema = "module test9 {\n" + " namespace urn:test9;\n" + " prefix t;\n" + " description \'hello\';\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test10 {\n" + " namespace urn:test10;\n" + " prefix t;\n" + " description \"hel\" +\t\n\"lo\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test11 {\n" + " namespace urn:test11;\n" + " prefix t;\n" + " description \'he\'\t\n+ \"llo\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test12 {\n" + " namespace urn:test12;\n" + " prefix t;\n" + " description \'he\'\t\n+ \"llo\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test13 {\n" + " namespace urn:test13;\n" + " prefix t;\n" + " description \'he\'\t\n+ \"llo\";\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test14 {\n" + " namespace urn:test14;\n" + " prefix t;\n" + " description \t\n\"he\"+\'llo\';\n" + "}"; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + assert_string_equal("hello", mod->dsc); + + schema = "module test15 {\n" + " namespace urn:test15;\n" + " prefix t;\n" + " description \"hel\" +\t\nlo;\n" + "}"; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, schema, LYS_IN_YANG, &mod)); + CHECK_LOG_CTX("Parsing module \"test15\" failed.", NULL, 0); + CHECK_LOG_CTX("Both string parts divided by '+' must be quoted.", NULL, 5); } -#define TEST_STMS_SUCCESS(INPUT_TEXT, CTX, ACTION, EXPECT_WORD)\ - in.current = INPUT_TEXT;\ - assert_int_equal(LY_SUCCESS, get_keyword(CTX, &kw, &word, &len));\ - assert_int_equal(ACTION, kw);\ - assert_int_equal(strlen(EXPECT_WORD), len);\ - assert_true(0 == strncmp(EXPECT_WORD, word, len)) +#define TEST_STMS_SUCCESS(CTX, MOD_NAME, STMT_TEXT) \ + do { \ + struct lys_module *mod; \ + char buffer[1024]; \ + snprintf(buffer, sizeof(buffer), \ + "module %s { yang-version 1.1; namespace \"urn:test:%s\"; prefix t; %s }", \ + (MOD_NAME), (MOD_NAME), (STMT_TEXT)); \ + assert_int_equal(LY_SUCCESS, lys_parse_mem((CTX), buffer, LYS_IN_YANG, &mod)); \ + } while(0) static void test_stmts(void **state) { - const char *p; - enum ly_stmt kw; - char *word; - size_t len; - - in.current = "\n// comment\n\tinput\t{"; - assert_int_equal(LY_SUCCESS, get_keyword(YCTX, &kw, &word, &len)); - assert_int_equal(LY_STMT_INPUT, kw); - assert_int_equal(5, len); - assert_string_equal("input\t{", word); - assert_string_equal("\t{", in.current); - - in.current = "\t /* comment */\t output\n\t{"; - assert_int_equal(LY_SUCCESS, get_keyword(YCTX, &kw, &word, &len)); - assert_int_equal(LY_STMT_OUTPUT, kw); - assert_int_equal(6, len); - assert_string_equal("output\n\t{", word); - assert_string_equal("\n\t{", in.current); - assert_int_equal(LY_SUCCESS, get_keyword(YCTX, &kw, &word, &len)); - assert_int_equal(LY_STMT_SYNTAX_LEFT_BRACE, kw); - assert_int_equal(1, len); - assert_string_equal("{", word); - assert_string_equal("", in.current); - - in.current = "/input { "; /* invalid slash */ - assert_int_equal(LY_EVALID, get_keyword(YCTX, &kw, &word, &len)); - CHECK_LOG_CTX("Invalid identifier first character '/'.", NULL, 4); - - in.current = "not-a-statement-nor-extension { "; /* invalid identifier */ - assert_int_equal(LY_EVALID, get_keyword(YCTX, &kw, &word, &len)); - CHECK_LOG_CTX("Invalid character sequence \"not-a-statement-nor-extension\", expected a keyword.", NULL, 4); - - in.current = "path;"; /* missing sep after the keyword */ - assert_int_equal(LY_EVALID, get_keyword(YCTX, &kw, &word, &len)); - CHECK_LOG_CTX("Invalid character sequence \"path;\", expected a keyword followed by a separator.", NULL, 4); - - TEST_STMS_SUCCESS("action ", YCTX, LY_STMT_ACTION, "action"); - - TEST_STMS_SUCCESS("anydata ", YCTX, LY_STMT_ANYDATA, "anydata"); - TEST_STMS_SUCCESS("anyxml ", YCTX, LY_STMT_ANYXML, "anyxml"); - TEST_STMS_SUCCESS("argument ", YCTX, LY_STMT_ARGUMENT, "argument"); - TEST_STMS_SUCCESS("augment ", YCTX, LY_STMT_AUGMENT, "augment"); - TEST_STMS_SUCCESS("base ", YCTX, LY_STMT_BASE, "base"); - TEST_STMS_SUCCESS("belongs-to ", YCTX, LY_STMT_BELONGS_TO, "belongs-to"); - TEST_STMS_SUCCESS("bit ", YCTX, LY_STMT_BIT, "bit"); - TEST_STMS_SUCCESS("case ", YCTX, LY_STMT_CASE, "case"); - TEST_STMS_SUCCESS("choice ", YCTX, LY_STMT_CHOICE, "choice"); - TEST_STMS_SUCCESS("config ", YCTX, LY_STMT_CONFIG, "config"); - TEST_STMS_SUCCESS("contact ", YCTX, LY_STMT_CONTACT, "contact"); - TEST_STMS_SUCCESS("container ", YCTX, LY_STMT_CONTAINER, "container"); - TEST_STMS_SUCCESS("default ", YCTX, LY_STMT_DEFAULT, "default"); - TEST_STMS_SUCCESS("description ", YCTX, LY_STMT_DESCRIPTION, "description"); - TEST_STMS_SUCCESS("deviate ", YCTX, LY_STMT_DEVIATE, "deviate"); - TEST_STMS_SUCCESS("deviation ", YCTX, LY_STMT_DEVIATION, "deviation"); - TEST_STMS_SUCCESS("enum ", YCTX, LY_STMT_ENUM, "enum"); - TEST_STMS_SUCCESS("error-app-tag ", YCTX, LY_STMT_ERROR_APP_TAG, "error-app-tag"); - TEST_STMS_SUCCESS("error-message ", YCTX, LY_STMT_ERROR_MESSAGE, "error-message"); - TEST_STMS_SUCCESS("extension ", YCTX, LY_STMT_EXTENSION, "extension"); - TEST_STMS_SUCCESS("feature ", YCTX, LY_STMT_FEATURE, "feature"); - TEST_STMS_SUCCESS("fraction-digits ", YCTX, LY_STMT_FRACTION_DIGITS, "fraction-digits"); - TEST_STMS_SUCCESS("grouping ", YCTX, LY_STMT_GROUPING, "grouping"); - TEST_STMS_SUCCESS("identity ", YCTX, LY_STMT_IDENTITY, "identity"); - TEST_STMS_SUCCESS("if-feature ", YCTX, LY_STMT_IF_FEATURE, "if-feature"); - TEST_STMS_SUCCESS("import ", YCTX, LY_STMT_IMPORT, "import"); - TEST_STMS_SUCCESS("include ", YCTX, LY_STMT_INCLUDE, "include"); - TEST_STMS_SUCCESS("input{", YCTX, LY_STMT_INPUT, "input"); - TEST_STMS_SUCCESS("key ", YCTX, LY_STMT_KEY, "key"); - TEST_STMS_SUCCESS("leaf ", YCTX, LY_STMT_LEAF, "leaf"); - TEST_STMS_SUCCESS("leaf-list ", YCTX, LY_STMT_LEAF_LIST, "leaf-list"); - TEST_STMS_SUCCESS("length ", YCTX, LY_STMT_LENGTH, "length"); - TEST_STMS_SUCCESS("list ", YCTX, LY_STMT_LIST, "list"); - TEST_STMS_SUCCESS("mandatory ", YCTX, LY_STMT_MANDATORY, "mandatory"); - TEST_STMS_SUCCESS("max-elements ", YCTX, LY_STMT_MAX_ELEMENTS, "max-elements"); - TEST_STMS_SUCCESS("min-elements ", YCTX, LY_STMT_MIN_ELEMENTS, "min-elements"); - TEST_STMS_SUCCESS("modifier ", YCTX, LY_STMT_MODIFIER, "modifier"); - TEST_STMS_SUCCESS("module ", YCTX, LY_STMT_MODULE, "module"); - TEST_STMS_SUCCESS("must ", YCTX, LY_STMT_MUST, "must"); - TEST_STMS_SUCCESS("namespace ", YCTX, LY_STMT_NAMESPACE, "namespace"); - TEST_STMS_SUCCESS("notification ", YCTX, LY_STMT_NOTIFICATION, "notification"); - TEST_STMS_SUCCESS("ordered-by ", YCTX, LY_STMT_ORDERED_BY, "ordered-by"); - TEST_STMS_SUCCESS("organization ", YCTX, LY_STMT_ORGANIZATION, "organization"); - TEST_STMS_SUCCESS("output ", YCTX, LY_STMT_OUTPUT, "output"); - TEST_STMS_SUCCESS("path ", YCTX, LY_STMT_PATH, "path"); - TEST_STMS_SUCCESS("pattern ", YCTX, LY_STMT_PATTERN, "pattern"); - TEST_STMS_SUCCESS("position ", YCTX, LY_STMT_POSITION, "position"); - TEST_STMS_SUCCESS("prefix ", YCTX, LY_STMT_PREFIX, "prefix"); - TEST_STMS_SUCCESS("presence ", YCTX, LY_STMT_PRESENCE, "presence"); - TEST_STMS_SUCCESS("range ", YCTX, LY_STMT_RANGE, "range"); - TEST_STMS_SUCCESS("reference ", YCTX, LY_STMT_REFERENCE, "reference"); - TEST_STMS_SUCCESS("refine ", YCTX, LY_STMT_REFINE, "refine"); - TEST_STMS_SUCCESS("require-instance ", YCTX, LY_STMT_REQUIRE_INSTANCE, "require-instance"); - TEST_STMS_SUCCESS("revision ", YCTX, LY_STMT_REVISION, "revision"); - TEST_STMS_SUCCESS("revision-date ", YCTX, LY_STMT_REVISION_DATE, "revision-date"); - TEST_STMS_SUCCESS("rpc ", YCTX, LY_STMT_RPC, "rpc"); - TEST_STMS_SUCCESS("status ", YCTX, LY_STMT_STATUS, "status"); - TEST_STMS_SUCCESS("submodule ", YCTX, LY_STMT_SUBMODULE, "submodule"); - TEST_STMS_SUCCESS("type ", YCTX, LY_STMT_TYPE, "type"); - TEST_STMS_SUCCESS("typedef ", YCTX, LY_STMT_TYPEDEF, "typedef"); - TEST_STMS_SUCCESS("unique ", YCTX, LY_STMT_UNIQUE, "unique"); - TEST_STMS_SUCCESS("units ", YCTX, LY_STMT_UNITS, "units"); - TEST_STMS_SUCCESS("uses ", YCTX, LY_STMT_USES, "uses"); - TEST_STMS_SUCCESS("value ", YCTX, LY_STMT_VALUE, "value"); - TEST_STMS_SUCCESS("when ", YCTX, LY_STMT_WHEN, "when"); - TEST_STMS_SUCCESS("yang-version ", YCTX, LY_STMT_YANG_VERSION, "yang-version"); - TEST_STMS_SUCCESS("yin-element ", YCTX, LY_STMT_YIN_ELEMENT, "yin-element"); - TEST_STMS_SUCCESS(";config false;", YCTX, LY_STMT_SYNTAX_SEMICOLON, ";"); - assert_string_equal("config false;", in.current); - TEST_STMS_SUCCESS("{ config false;", YCTX, LY_STMT_SYNTAX_LEFT_BRACE, "{"); - assert_string_equal(" config false;", in.current); - TEST_STMS_SUCCESS("}", YCTX, LY_STMT_SYNTAX_RIGHT_BRACE, "}"); - assert_string_equal("", in.current); - - /* geenric extension */ - in.current = p = "nacm:default-deny-write;"; - assert_int_equal(LY_SUCCESS, get_keyword(YCTX, &kw, &word, &len)); - assert_int_equal(LY_STMT_EXTENSION_INSTANCE, kw); - assert_int_equal(23, len); - assert_ptr_equal(p, word); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test {namespace \"urn:test:err\"; prefix e; /input { }", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid identifier first character '/'.", NULL, 1); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module test { namespace \"urn:test:err2\"; prefix e2; not-a-statement-nor-extension {}", LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid character sequence \"not-a-statement-nor-extension\", expected a keyword.", NULL, 1); + + TEST_STMS_SUCCESS(UTEST_LYCTX, "t-input-fmt", "rpc my-rpc { \n// comment\n\tinput\t{ leaf in-leaf { type string; } } }"); + TEST_STMS_SUCCESS(UTEST_LYCTX, "t-output-fmt", "rpc my-rpc { \t /* comment */\t output\n\t{ leaf out-leaf { type string; } } }"); } static void test_minmax(void **state) { - uint16_t flags = 0; - uint32_t value = 0; - struct lysp_ext_instance *ext = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - - in.current = " 1invalid; ..."; - assert_int_equal(LY_EVALID, parse_minelements(YCTX, &value, &flags, &ext)); + const char *yang = + "module test {" + " yang-version 1.1;" + " namespace \"urn:test\";" + " prefix t;" + " leaf-list ll {" + " type string;" + " min-elements %s;" + " max-elements %s;" + " }" + "}"; + char buf[256]; + + snprintf(buf, sizeof buf, yang, "1invalid", "..."); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"1invalid\" of \"min-elements\".", NULL, 1); - flags = value = 0; - in.current = " -1; ..."; - assert_int_equal(LY_EVALID, parse_minelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "-1", "..."); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-1\" of \"min-elements\".", NULL, 1); /* implementation limit */ - flags = value = 0; - in.current = " 4294967296; ..."; - assert_int_equal(LY_EVALID, parse_minelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "4294967296", "..."); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Value \"4294967296\" is out of \"min-elements\" bounds.", NULL, 1); - flags = value = 0; - in.current = " 1 {config true;} ..."; - assert_int_equal(LY_EVALID, parse_minelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "1 {config true;}", "..."); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"min-elements\".", NULL, 1); - in.current = " 1invalid; ..."; - assert_int_equal(LY_EVALID, parse_maxelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "2", "1invalid"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"1invalid\" of \"max-elements\".", NULL, 1); - flags = value = 0; - in.current = " -1; ..."; - assert_int_equal(LY_EVALID, parse_maxelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "2", "-1"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-1\" of \"max-elements\".", NULL, 1); - /* implementation limit */ - flags = value = 0; - in.current = " 4294967296; ..."; - assert_int_equal(LY_EVALID, parse_maxelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "2", "4294967296"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Value \"4294967296\" is out of \"max-elements\" bounds.", NULL, 1); - flags = value = 0; - in.current = " 1 {config true;} ..."; - assert_int_equal(LY_EVALID, parse_maxelements(YCTX, &value, &flags, &ext)); + snprintf(buf, sizeof buf, yang, "2", "1 {config true;}"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buf, LYS_IN_YANG, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"max-elements\".", NULL, 1); } @@ -712,41 +509,6 @@ test_valid_module(void **state) free(printed); } -static struct lysp_module * -mod_renew(struct lysp_yang_ctx *ctx) -{ - struct ly_ctx *ly_ctx = PARSER_CUR_PMOD(ctx)->mod->ctx; - struct lysp_module *pmod; - - lys_module_free(PARSER_CTX(YCTX), PARSER_CUR_PMOD(ctx)->mod, 0); - pmod = calloc(1, sizeof *pmod); - ctx->parsed_mods->objs[0] = pmod; - pmod->mod = calloc(1, sizeof *pmod->mod); - pmod->mod->parsed = pmod; - pmod->mod->ctx = ly_ctx; - - ctx->in->line = 1; - - return pmod; -} - -static struct lysp_submodule * -submod_renew(struct lysp_yang_ctx *ctx) -{ - struct ly_ctx *ly_ctx = PARSER_CUR_PMOD(ctx)->mod->ctx; - struct lysp_submodule *submod; - - lys_module_free(PARSER_CTX(YCTX), PARSER_CUR_PMOD(ctx)->mod, 0); - submod = calloc(1, sizeof *submod); - ctx->parsed_mods->objs[0] = submod; - submod->mod = calloc(1, sizeof *submod->mod); - lysdict_insert(ly_ctx, "name", 0, &submod->mod->name); - submod->mod->parsed = (struct lysp_module *)submod; - submod->mod->ctx = ly_ctx; - - return submod; -} - 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, @@ -761,306 +523,154 @@ test_imp_clb(const char *UNUSED(mod_name), const char *UNUSED(mod_rev), const ch static void test_module(void **state) { - struct lysp_module *mod = NULL; - struct lysp_submodule *submod = NULL; - struct lys_module *m; - struct lysp_yang_ctx *ctx_p; - - mod = mod_renew(YCTX); - - /* missing mandatory substatements */ - in.current = " name {}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - assert_string_equal("name", mod->mod->name); + /* Missing mandatory substatements */ + TEST_MOD(UTEST_LYCTX, "module name {}", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"name\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory keyword \"namespace\" as a child of \"module\".", NULL, 1); - - mod = mod_renew(YCTX); - in.current = " name {namespace urn:name;}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - assert_string_equal("urn:name", mod->mod->ns); + TEST_MOD(UTEST_LYCTX, "module name { namespace urn:name; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"name\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory keyword \"prefix\" as a child of \"module\".", NULL, 1); - mod = mod_renew(YCTX); - - in.current = " name {namespace urn:name;prefix \"n\";}"; - assert_int_equal(LY_SUCCESS, parse_module(YCTX, mod)); - assert_string_equal("n", mod->mod->prefix); - mod = mod_renew(YCTX); - -#define SCHEMA_BEGINNING " name {yang-version 1.1;namespace urn:x;prefix \"x\";" -#define SCHEMA_BEGINNING2 " name {namespace urn:x;prefix \"x\";" -#define TEST_NODE(NODETYPE, INPUT, NAME) \ - in.current = SCHEMA_BEGINNING INPUT; \ - assert_int_equal(LY_SUCCESS, parse_module(YCTX, mod)); \ - assert_non_null(mod->data); \ - assert_int_equal(NODETYPE, mod->data->nodetype); \ - assert_string_equal(NAME, mod->data->name); \ - mod = mod_renew(YCTX); -#define TEST_GENERIC(INPUT, TARGET, TEST) \ - in.current = SCHEMA_BEGINNING INPUT; \ - assert_int_equal(LY_SUCCESS, parse_module(YCTX, mod)); \ - assert_non_null(TARGET); \ - TEST; \ - mod = mod_renew(YCTX); -#define TEST_DUP(MEMBER, VALUE1, VALUE2, LINE) \ - TEST_DUP_GENERIC(SCHEMA_BEGINNING, MEMBER, VALUE1, VALUE2, \ - parse_module, mod, LINE, mod = mod_renew(YCTX)) - - /* duplicated namespace, prefix */ - TEST_DUP("namespace", "y", "z", 1); - TEST_DUP("prefix", "y", "z", 1); - TEST_DUP("contact", "a", "b", 1); - TEST_DUP("description", "a", "b", 1); - TEST_DUP("organization", "a", "b", 1); - TEST_DUP("reference", "a", "b", 1); - - /* not allowed in module (submodule-specific) */ - in.current = SCHEMA_BEGINNING "belongs-to master {prefix m;}}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Invalid keyword \"belongs-to\" as a child of \"module\".", NULL, 1); - mod = mod_renew(YCTX); - - /* 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->mod->contact, - assert_string_equal("firstname surname", mod->mod->contact)); - /* container */ - TEST_NODE(LYS_CONTAINER, "container test;}", "test"); - /* description 0..1 */ - TEST_GENERIC("description \'some description\';}", mod->mod->dsc, - assert_string_equal("some description", mod->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 */ - ly_ctx_set_module_imp_clb(PARSER_CUR_PMOD(YCTX)->mod->ctx, test_imp_clb, "module zzz { namespace urn:zzz; prefix z;}"); - TEST_GENERIC("import zzz {prefix z;}}", mod->imports, - assert_string_equal("zzz", mod->imports[0].name)); - - /* import - prefix collision */ - in.current = SCHEMA_BEGINNING "import zzz {prefix x;}}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Prefix \"x\" already used as module prefix.", NULL, 1); - mod = mod_renew(YCTX); - - in.current = SCHEMA_BEGINNING "import zzz {prefix y;}import zzz {prefix y;}}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Prefix \"y\" already used to import \"zzz\" module.", NULL, 1); - - mod = mod_renew(YCTX); - ly_log_location_revert(0, 0, 1); - - in.current = "module name10 {yang-version 1.1;namespace urn:name10;prefix \"n10\";import zzz {prefix y;}import zzz {prefix z;}}"; - assert_int_equal(lys_parse_mem(PARSER_CUR_PMOD(YCTX)->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_SUCCESS); - CHECK_LOG_CTX("Single revision of the module \"zzz\" imported twice.", NULL, 0); - /* include */ - ly_ctx_set_module_imp_clb(PARSER_CUR_PMOD(YCTX)->mod->ctx, test_imp_clb, "module xxx { namespace urn:xxx; prefix x;}"); - in.current = "module" SCHEMA_BEGINNING "include xxx;}"; - assert_int_equal(lys_parse_mem(PARSER_CUR_PMOD(YCTX)->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_EINVAL); - CHECK_LOG_CTX("Parsing module \"name\" failed.", NULL, 0); - CHECK_LOG_CTX("Parsing submodule \"xxx\" failed.", NULL, 0); - CHECK_LOG_CTX("Input data contains module in situation when a submodule is expected.", NULL, 0); + /* Successful minimal module */ + TEST_MOD(UTEST_LYCTX, "module name { namespace urn:name; prefix n; }", LY_SUCCESS); + + /* Duplicated headers */ + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; namespace urn:y; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"namespace\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; prefix y; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"prefix\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; contact a; contact b; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"contact\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; description a; description b; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"description\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; organization a; organization b; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"organization\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module dup { namespace urn:x; prefix x; reference a; reference b; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"dup\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"reference\".", NULL, 1); - ly_ctx_set_module_imp_clb(PARSER_CUR_PMOD(YCTX)->mod->ctx, test_imp_clb, "submodule xxx {belongs-to wrong-name {prefix w;}}"); - in.current = "module" SCHEMA_BEGINNING "include xxx;}"; - assert_int_equal(lys_parse_mem(PARSER_CUR_PMOD(YCTX)->mod->ctx, in.current, LYS_IN_YANG, NULL), LY_EVALID); - CHECK_LOG_CTX("Parsing module \"name\" failed.", NULL, 0); - CHECK_LOG_CTX("Parsing submodule \"xxx\" failed.", NULL, 0); - UTEST_LOG_CTX_CLEAN; - - ly_ctx_set_module_imp_clb(PARSER_CUR_PMOD(YCTX)->mod->ctx, test_imp_clb, "submodule xxx {belongs-to name {prefix x;}}"); - TEST_GENERIC("include xxx;}", mod->includes, - assert_string_equal("xxx", 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->mod->org, - assert_string_equal("CESNET a.l.e.", mod->mod->org)); - /* reference 0..1 */ - TEST_GENERIC("reference RFC7950;}", mod->mod->ref, - assert_string_equal("RFC7950", mod->mod->ref)); - /* revision */ - TEST_GENERIC("revision 2018-10-12;}", mod->revs, - assert_string_equal("2018-10-12", mod->revs[0].date)); - /* 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 */ - in.current = SCHEMA_BEGINNING2 "\n\tyang-version 10;}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Invalid value \"10\" of \"yang-version\".", NULL, 0); - mod = mod_renew(YCTX); - in.current = SCHEMA_BEGINNING2 "yang-version 1;yang-version 1.1;}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Duplicate keyword \"yang-version\".", NULL, 0); - mod = mod_renew(YCTX); - in.current = SCHEMA_BEGINNING2 "yang-version 1;}"; - assert_int_equal(LY_SUCCESS, parse_module(YCTX, mod)); - assert_int_equal(1, mod->version); - mod = mod_renew(YCTX); - in.current = SCHEMA_BEGINNING2 "yang-version \"1.1\";}"; - assert_int_equal(LY_SUCCESS, parse_module(YCTX, mod)); - assert_int_equal(2, mod->version); - mod = mod_renew(YCTX); - - in.current = "module " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}"; - m = calloc(1, sizeof *m); - m->ctx = PARSER_CUR_PMOD(YCTX)->mod->ctx; - assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m)); - CHECK_LOG_CTX("Trailing garbage \"module q {names...\" after module, expected end-of-input.", NULL, 1); - lysp_yang_ctx_free(ctx_p); - lys_module_free(PARSER_CTX(YCTX), m, 0); - - in.current = "prefix " SCHEMA_BEGINNING "}"; - m = calloc(1, sizeof *m); - m->ctx = PARSER_CUR_PMOD(YCTX)->mod->ctx; - assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m)); + /* Invalid Keywords in Module (Submodule-specific or illegal) */ + TEST_MOD(UTEST_LYCTX, "module inv { namespace urn:x; prefix x; belongs-to master { prefix m; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"inv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid keyword \"belongs-to\" as a child of \"module\".", NULL, 1); + + TEST_MOD(UTEST_LYCTX, "module inv { namespace urn:x; prefix x; must false; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"inv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid keyword \"must\" as a child of \"module\".", NULL, 1); + + /* Yang-version parsing and validation */ + TEST_MOD(UTEST_LYCTX, "module yv { yang-version 10; namespace urn:x; prefix x; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"yv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid value \"10\" of \"yang-version\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module yv { yang-version 1.1; yang-version 1.1; namespace urn:x; prefix x; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"yv\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"yang-version\".", NULL, 1); + TEST_MOD(UTEST_LYCTX, "module yv { yang-version 1; namespace urn:x; prefix x; }", LY_SUCCESS); + TEST_MOD(UTEST_LYCTX, "module yv { yang-version \"1.1\"; namespace \"urn:yv4\"; prefix \"yv4\";}", LY_SUCCESS); + + /* Trailing Garbage and Base Syntax */ + TEST_MOD(UTEST_LYCTX, "module tg1 { namespace urn:x; prefix x; } module q { namespace urn:q; prefix q; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"tg1\" failed.", NULL, 0); + CHECK_LOG_CTX("Trailing garbage \"module q { name...\" after module, expected end-of-input.", NULL, 1); + TEST_MOD(UTEST_LYCTX, "prefix name { }", LY_EVALID); CHECK_LOG_CTX("Invalid keyword \"prefix\", expected \"module\" or \"submodule\".", NULL, 1); - lysp_yang_ctx_free(ctx_p); - lys_module_free(PARSER_CTX(YCTX), m, 0); - - in.current = "module " SCHEMA_BEGINNING "leaf enum {type enumeration {enum seven { position 7;}}}}"; - m = calloc(1, sizeof *m); - m->ctx = PARSER_CUR_PMOD(YCTX)->mod->ctx; - assert_int_equal(LY_EVALID, yang_parse_module(&ctx_p, &in, m)); - CHECK_LOG_CTX("Invalid keyword \"position\" as a child of \"enum\".", NULL, 1); - lysp_yang_ctx_free(ctx_p); - lys_module_free(PARSER_CTX(YCTX), m, 0); - - /* extensions */ - TEST_GENERIC("prefix:test;}", mod->exts, - assert_string_equal("prefix:test", mod->exts[0].name); - assert_int_equal(LY_STMT_MODULE, mod->exts[0].parent_stmt)); - mod = mod_renew(YCTX); - /* invalid substatement */ - in.current = SCHEMA_BEGINNING "must false;}"; - assert_int_equal(LY_EVALID, parse_module(YCTX, mod)); - CHECK_LOG_CTX("Invalid keyword \"must\" as a child of \"module\".", NULL, 0); - - /* submodule */ - submod = submod_renew(YCTX); - - /* missing mandatory substatements */ - in.current = " subname {}"; - assert_int_equal(LY_EVALID, parse_submodule(YCTX, submod)); - CHECK_LOG_CTX("Missing mandatory keyword \"belongs-to\" as a child of \"submodule\".", NULL, 0); - assert_string_equal("subname", submod->name); - - submod = submod_renew(YCTX); - - in.current = " subname {belongs-to name {prefix x;}}"; - assert_int_equal(LY_SUCCESS, parse_submodule(YCTX, submod)); - assert_string_equal("name", submod->mod->name); - submod = submod_renew(YCTX); - -#undef SCHEMA_BEGINNING -#define SCHEMA_BEGINNING " subname {belongs-to name {prefix x;}" - - /* duplicated namespace, prefix */ - in.current = " subname {belongs-to name {prefix x;}belongs-to module1;belongs-to module2;} ..."; - assert_int_equal(LY_EVALID, parse_submodule(YCTX, submod)); - CHECK_LOG_CTX("Duplicate keyword \"belongs-to\".", NULL, 0); - submod = submod_renew(YCTX); - - /* not allowed in submodule (module-specific) */ - in.current = SCHEMA_BEGINNING "namespace \"urn:z\";}"; - assert_int_equal(LY_EVALID, parse_submodule(YCTX, submod)); - CHECK_LOG_CTX("Invalid keyword \"namespace\" as a child of \"submodule\".", NULL, 0); - submod = submod_renew(YCTX); - in.current = SCHEMA_BEGINNING "prefix m;}}"; - assert_int_equal(LY_EVALID, parse_submodule(YCTX, submod)); - CHECK_LOG_CTX("Invalid keyword \"prefix\" as a child of \"submodule\".", NULL, 0); - submod = submod_renew(YCTX); - - in.current = "submodule " SCHEMA_BEGINNING "} module q {namespace urn:q;prefixq;}"; - assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, PARSER_CUR_PMOD(YCTX)->mod->ctx, (struct lysp_ctx *)YCTX, YCTX->in, &submod)); - CHECK_LOG_CTX("Trailing garbage \"module q {names...\" after submodule, expected end-of-input.", NULL, 1); - lysp_yang_ctx_free(ctx_p); - - in.current = "prefix " SCHEMA_BEGINNING "}"; - assert_int_equal(LY_EVALID, yang_parse_submodule(&ctx_p, PARSER_CUR_PMOD(YCTX)->mod->ctx, (struct lysp_ctx *)YCTX, YCTX->in, &submod)); + /* Submodules */ + TEST_SUBMOD(UTEST_LYCTX, "submodule subname {}", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); + CHECK_LOG_CTX("Missing mandatory keyword \"belongs-to\" as a child of \"submodule\".", NULL, 1); + TEST_SUBMOD(UTEST_LYCTX, "submodule subname { belongs-to parent { prefix p; } belongs-to parent2; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"belongs-to\".", NULL, 1); + TEST_SUBMOD(UTEST_LYCTX, "submodule subname { belongs-to parent { prefix p; } namespace \"urn:z\"; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid keyword \"namespace\" as a child of \"submodule\".", NULL, 1); + TEST_SUBMOD(UTEST_LYCTX, "submodule subname { belongs-to parent { prefix p; } prefix m; }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid keyword \"prefix\" as a child of \"submodule\".", NULL, 1); + TEST_SUBMOD(UTEST_LYCTX, "submodule subname { belongs-to parent { prefix p; } } module q {}", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); + CHECK_LOG_CTX("Trailing garbage \"module q {}\" after submodule, expected end-of-input.", NULL, 1); + TEST_SUBMOD(UTEST_LYCTX, "prefix subname { belongs-to parent { prefix p; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"subname\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"prefix\", expected \"module\" or \"submodule\".", NULL, 1); - lysp_yang_ctx_free(ctx_p); - submod = submod_renew(YCTX); -#undef TEST_GENERIC -#undef TEST_NODE -#undef TEST_DUP -#undef SCHEMA_BEGINNING + TEST_SUBMOD(UTEST_LYCTX, "submodule subname { belongs-to parent { prefix p; } }", LY_SUCCESS); + + /* Pre-load modules required for the Import tests */ + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module zzz { yang-version 1.1; namespace \"urn:zzz\"; prefix z; }", LYS_IN_YANG, NULL)); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module yyy { yang-version 1.1; namespace \"urn:yyy\"; prefix y; }", LYS_IN_YANG, NULL)); + + /* Imports */ + TEST_MOD(UTEST_LYCTX, "module imp-success { namespace urn:s1; prefix s1; import zzz { prefix my-z; } }", LY_SUCCESS); + TEST_MOD(UTEST_LYCTX, "module imp-multi { namespace urn:s2; prefix s2; import zzz { prefix z; } import yyy { prefix y; } }", LY_SUCCESS); + TEST_MOD(UTEST_LYCTX, "module imp { namespace urn:e4; prefix e4; import zzz { prefix a; } import zzz { prefix b; } }", LY_SUCCESS); + CHECK_LOG_CTX("Single revision of the module \"zzz\" imported twice.", NULL, 0); + TEST_MOD(UTEST_LYCTX, "module err { namespace urn:e1; prefix e1; import missing-mod { prefix m; } }", LY_EINVAL); + CHECK_LOG_CTX("Parsing module \"err\" failed.", NULL, 0); + CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL, 0); + TEST_MOD(UTEST_LYCTX, "module err { namespace urn:e2; prefix e2; import zzz { prefix x; } import yyy { prefix x; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"err\" failed.", NULL, 0); + CHECK_LOG_CTX("Prefix \"x\" already used to import \"zzz\" module.", NULL, 1); + + TEST_MOD(UTEST_LYCTX, "module err { namespace urn:e3; prefix z; import zzz { prefix z; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"err\" failed.", NULL, 0); + CHECK_LOG_CTX("Prefix \"z\" already used as module prefix.", NULL, 1); } static void test_deviation(void **state) { - struct lysp_deviation *d = NULL; - /* invalid cardinality */ - TEST_DUP_GENERIC(" test {deviate not-supported;", "description", "a", "b", parse_deviation, &d, 1, ); - TEST_DUP_GENERIC(" test {deviate not-supported;", "reference", "a", "b", parse_deviation, &d, 1, ); + TEST_MOD(UTEST_LYCTX, "module d1 { namespace urn:d1; prefix d; deviation /d:target { deviate not-supported; description \"a\"; description \"b\"; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"d1\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"description\".", NULL, 1); + + TEST_MOD(UTEST_LYCTX, "module d2 { namespace urn:d2; prefix d; deviation /d:target { deviate not-supported; reference \"a\"; reference \"b\"; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"d2\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"reference\".", NULL, 1); /* missing mandatory substatement */ - in.current = " test {description text;}"; - assert_int_equal(LY_EVALID, parse_deviation(YCTX, &d)); + TEST_MOD(UTEST_LYCTX, "module d3 { namespace urn:d3; prefix d; deviation /d:target { description \"text\"; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"d3\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory keyword \"deviate\" as a child of \"deviation\".", NULL, 1); /* invalid substatement */ - in.current = " test {deviate not-supported; status obsolete;}"; - assert_int_equal(LY_EVALID, parse_deviation(YCTX, &d)); + TEST_MOD(UTEST_LYCTX, "module d4 { namespace urn:d4; prefix d; deviation /d:target { deviate not-supported; status obsolete; } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"d4\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"status\" as a child of \"deviation\".", NULL, 1); } static void test_deviate(void **state) { - struct lysp_deviate *d = NULL; +#define TEST_DEVIATE_ERR(MEMBER, ERR_MSG) \ + TEST_MOD(UTEST_LYCTX, "module dev { yang-version 1.1; namespace urn:cont; prefix c; deviation /c:t { " MEMBER " } }", LY_EVALID); \ + CHECK_LOG_CTX("Parsing module \"dev\" failed.", NULL, 0);\ + CHECK_LOG_CTX(ERR_MSG, NULL, 1) /* invalid cardinality */ - TEST_DUP_GENERIC("add {", "config", "true", "false", parse_deviate, &d, 1, ); - TEST_DUP_GENERIC("add {", "mandatory", "true", "false", parse_deviate, &d, 1, ); - TEST_DUP_GENERIC("add {", "max-elements", "1", "2", parse_deviate, &d, 1, ); - TEST_DUP_GENERIC("add {", "min-elements", "1", "2", parse_deviate, &d, 1, ); - TEST_DUP_GENERIC("add {", "units", "kilometers", "miles", parse_deviate, &d, 1, ); + TEST_DEVIATE_ERR("deviate add { config true; config false; }", "Duplicate keyword \"config\"."); + TEST_DEVIATE_ERR("deviate add { mandatory true; mandatory false; }", "Duplicate keyword \"mandatory\"."); + TEST_DEVIATE_ERR("deviate add { max-elements 1; max-elements 2; }", "Duplicate keyword \"max-elements\"."); + TEST_DEVIATE_ERR("deviate add { min-elements 1; min-elements 2; }", "Duplicate keyword \"min-elements\"."); + TEST_DEVIATE_ERR("deviate add { units \"kilometers\"; units \"miles\"; }", "Duplicate keyword \"units\"."); - /* invalid substatements */ #define TEST_NOT_SUP(DEV, STMT, VALUE) \ - in.current = " "DEV" {"STMT" "VALUE";}..."; \ - assert_int_equal(LY_EVALID, parse_deviate(YCTX, &d)); \ - CHECK_LOG_CTX("Deviate \""DEV"\" does not support keyword \""STMT"\".", NULL, 1); + TEST_DEVIATE_ERR("deviate "DEV" {"STMT" "VALUE";}", "Deviate \""DEV"\" does not support keyword \""STMT"\"."); + /* invalid substatements */ TEST_NOT_SUP("not-supported", "units", "meters"); TEST_NOT_SUP("not-supported", "must", "1"); TEST_NOT_SUP("not-supported", "unique", "x"); @@ -1078,635 +688,817 @@ test_deviate(void **state) TEST_NOT_SUP("delete", "type", "string"); TEST_NOT_SUP("replace", "must", "1"); TEST_NOT_SUP("replace", "unique", "a"); - - in.current = " nonsence; ..."; - assert_int_equal(LY_EVALID, parse_deviate(YCTX, &d)); - CHECK_LOG_CTX("Invalid value \"nonsence\" of \"deviate\".", NULL, 1);\ - assert_null(d); -#undef TEST_NOT_SUP +#undef TEST_DEVIATE_ERR } static void test_container(void **state) { - struct lysp_node_container *c = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "cont {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_container(YCTX, NULL, (struct lysp_node**)&c)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)c); c = NULL; + TEST_MOD(UTEST_LYCTX, "module cont { yang-version 1.1; namespace urn:cont; prefix c; container test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID); \ + CHECK_LOG_CTX("Parsing module \"cont\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("presence", "true", "false"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - 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;}" - "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;} ..."; - assert_int_equal(LY_SUCCESS, parse_container(YCTX, NULL, (struct lysp_node **)&c)); - CHECK_LYSP_NODE(c, "test", 1, LYS_CONFIG_R | LYS_STATUS_CURR, 1, "cont", 0, LYS_CONTAINER, 0, "test", 1); - assert_non_null(c->actions); - assert_non_null(c->child); - assert_non_null(c->groupings); - assert_non_null(c->musts); - assert_non_null(c->notifs); - assert_string_equal("true", c->presence); - assert_non_null(c->typedefs); - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - ly_set_erase(&YCTX->grps_nodes, NULL); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); c = NULL; + TEST_MOD(UTEST_LYCTX, + "module cont {" + " yang-version 1.1;" + " namespace \"urn:cont\";" + " prefix c;" + " feature f;" + " extension ext;" + " container test {" + " action x;" + " anydata any;" + " anyxml anyxml;" + " choice ch;" + " config false;" + " container c;" + " description test;" + " grouping g;" + " if-feature f;" + " leaf l {type string;}" + " 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()';" + " c:ext;" + " }" + "}", + LY_SUCCESS); /* invalid */ - in.current = " cont {augment /root;} ..."; - assert_int_equal(LY_EVALID, parse_container(YCTX, NULL, (struct lysp_node **)&c)); + TEST_MOD(UTEST_LYCTX, "module cont2 { yang-version 1.1; namespace urn:cont2; prefix c2; container test {augment /root;} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"cont2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"augment\" as a child of \"container\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); c = NULL; - in.current = " cont {nonsence true;} ..."; - assert_int_equal(LY_EVALID, parse_container(YCTX, NULL, (struct lysp_node **)&c)); + + TEST_MOD(UTEST_LYCTX, "module cont2 { yang-version 1.1; namespace urn:cont2; prefix c2; container test {nonsence true;} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"cont2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid character sequence \"nonsence\", expected a keyword.", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); c = NULL; - PARSER_CUR_PMOD(YCTX)->version = 1; /* simulate YANG 1.0 */ - in.current = " cont {action x;} ..."; - assert_int_equal(LY_EVALID, parse_container(YCTX, NULL, (struct lysp_node **)&c)); + TEST_MOD(UTEST_LYCTX, "module cont2 { namespace urn:cont2; prefix c2; container test {action x;} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"cont2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"action\" as a child of \"container\" - " "the statement is allowed only in YANG 1.1 modules.", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); c = NULL; } static void test_leaf(void **state) { - struct lysp_node_leaf *l = NULL; - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_leaf(YCTX, NULL, (struct lysp_node**)&l)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)l); l = NULL; + TEST_MOD(UTEST_LYCTX, "module leaf1 { namespace urn:leaf1; prefix l1; leaf test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID); \ + CHECK_LOG_CTX("Parsing module \"leaf1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); TEST_DUP("default", "x", "y"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("mandatory", "true", "false"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); TEST_DUP("type", "int8", "uint8"); TEST_DUP("units", "text1", "text2"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content - without mandatory which is mutual exclusive with default */ - in.current = "l {config false;default \"xxx\";description test;if-feature f;" - "must 'expr';reference test;status current;type string; units yyy;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_leaf(YCTX, NULL, (struct lysp_node **)&l)); - CHECK_LYSP_NODE(l, "test", 1, LYS_CONFIG_R | LYS_STATUS_CURR, 1, "l", 0, LYS_LEAF, 0, "test", 1); - assert_string_equal("xxx", l->dflt.str); - assert_string_equal("yyy", l->units); - assert_string_equal("string", l->type.name); - assert_non_null(l->musts); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; + TEST_MOD(UTEST_LYCTX, + "module leaf1 {" + " namespace \"urn:leaf1\";" + " prefix l1;" + " feature f;" + " extension ext;" + " leaf test {" + " config false;" + " default \"xxx\";" + " description test;" + " if-feature f;" + " must 'expr';" + " reference test;" + " status current;" + " type string;" + " units yyy;" + " when 'true()';" + " l1:ext;" + " }" + "}", + LY_SUCCESS); /* full content - now with mandatory */ - in.current = "l {mandatory true; type string;} ..."; - assert_int_equal(LY_SUCCESS, parse_leaf(YCTX, NULL, (struct lysp_node **)&l)); - CHECK_LYSP_NODE(l, NULL, 0, LYS_MAND_TRUE, 0, "l", 0, LYS_LEAF, 0, NULL, 0); - assert_string_equal("string", l->type.name); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; + TEST_MOD(UTEST_LYCTX, + "module leaf2 {" + " namespace \"urn:leaf2\";" + " prefix l2;" + " leaf test {" + " mandatory true;" + " type string;" + " }" + "}", + LY_SUCCESS); /* invalid */ - in.current = " l {description \"missing type\";} ..."; - assert_int_equal(LY_EVALID, parse_leaf(YCTX, NULL, (struct lysp_node **)&l)); + TEST_MOD(UTEST_LYCTX, "module leaf3 { namespace urn:leaf3; prefix l3; leaf test {description \"missing type\";} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"leaf3\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory keyword \"type\" as a child of \"leaf\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; - in.current = "l { type iid { path qpud wrong {"; - assert_int_equal(LY_EVALID, parse_leaf(YCTX, NULL, (struct lysp_node **)&l)); + TEST_MOD(UTEST_LYCTX, "module leaf3 { namespace urn:leaf3; prefix l3; leaf test { type iid { path qpud wrong {} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"leaf3\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid character sequence \"wrong\", expected a keyword.", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; } static void test_leaflist(void **state) { - struct lysp_node_leaflist *ll = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "ll {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_leaflist(YCTX, NULL, (struct lysp_node**)&ll)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)ll); ll = NULL; + TEST_MOD(UTEST_LYCTX, "module leaflist1 { yang-version 1.1; namespace urn:leaflist1; prefix ll1; leaf-list test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID); \ + CHECK_LOG_CTX("Parsing module \"leaflist1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("max-elements", "10", "20"); TEST_DUP("min-elements", "10", "20"); TEST_DUP("ordered-by", "user", "system"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); TEST_DUP("type", "int8", "uint8"); TEST_DUP("units", "text1", "text2"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content - without min-elements which is mutual exclusive with default */ - in.current = "ll {config false;default \"xxx\"; default \"yyy\";description test;if-feature f;" - "max-elements 10;must 'expr';ordered-by user;reference test;" - "status current;type string; units zzz;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_leaflist(YCTX, NULL, (struct lysp_node **)&ll)); - CHECK_LYSP_NODE(ll, "test", 1, 0x446, 1, "ll", 0, LYS_LEAFLIST, 0, "test", 1); - assert_non_null(ll->dflts); - assert_int_equal(2, LY_ARRAY_COUNT(ll->dflts)); - assert_string_equal("xxx", ll->dflts[0].str); - assert_string_equal("yyy", ll->dflts[1].str); - assert_string_equal("zzz", ll->units); - assert_int_equal(10, ll->max); - assert_int_equal(0, ll->min); - assert_string_equal("string", ll->type.name); - assert_non_null(ll->musts); - assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_USER | LYS_SET_MAX, ll->flags); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ll); ll = NULL; + TEST_MOD(UTEST_LYCTX, + "module leaflist1 {" + " yang-version 1.1;" + " namespace \"urn:leaflist1\";" + " prefix ll1;" + " feature f;" + " extension ext;" + " leaf-list test {" + " config false;" + " default \"xxx\";" + " description test;" + " if-feature f;" + " max-elements 10;" + " must 'expr';" + " ordered-by user;" + " reference test;" + " status current;" + " type string;" + " units zzz;" + " when 'true()';" + " ll1:ext;" + " }" + "}", + LY_SUCCESS); /* full content - now with min-elements */ - in.current = "ll {min-elements 10; type string;} ..."; - assert_int_equal(LY_SUCCESS, parse_leaflist(YCTX, NULL, (struct lysp_node **)&ll)); - CHECK_LYSP_NODE(ll, NULL, 0, 0x200, 0, "ll", 0, LYS_LEAFLIST, 0, NULL, 0); - assert_string_equal("string", ll->type.name); - assert_int_equal(0, ll->max); - assert_int_equal(10, ll->min); - assert_int_equal(LYS_SET_MIN, ll->flags); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ll); ll = NULL; + TEST_MOD(UTEST_LYCTX, + "module leaflist2 {" + " yang-version 1.1;" + " namespace \"urn:leaflist2\";" + " prefix ll2;" + " leaf-list test {" + " type string;" + " }" + "}", + LY_SUCCESS); /* invalid */ - in.current = " ll {description \"missing type\";} ..."; - assert_int_equal(LY_EVALID, parse_leaflist(YCTX, NULL, (struct lysp_node **)&ll)); + TEST_MOD(UTEST_LYCTX, "module leaflist3 { yang-version 1.1; namespace urn:leaflist3; prefix ll3; leaf-list test {description \"missing type\";} }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"leaflist3\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory keyword \"type\" as a child of \"leaf-list\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ll); ll = NULL; - PARSER_CUR_PMOD(YCTX)->version = 1; /* simulate YANG 1.0 - default statement is not allowed */ - in.current = " ll {default xx; type string;} ..."; - assert_int_equal(LY_EVALID, parse_leaflist(YCTX, NULL, (struct lysp_node **)&ll)); + TEST_MOD(UTEST_LYCTX, "module leaflist3 { namespace urn:leaflist3; prefix ll3; leaf-list test {default xx; type string;}}", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"leaflist3\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"default\" as a child of \"leaf-list\" - the statement is allowed only in YANG 1.1 modules.", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ll); ll = NULL; } static void test_list(void **state) { - struct lysp_node_list *l = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_list(YCTX, NULL, (struct lysp_node**)&l)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)l); l = NULL; + TEST_MOD(UTEST_LYCTX, "module list1 { yang-version 1.1; namespace urn:list1; prefix l1; list test {" MEMBER" "VALUE1";"MEMBER" "VALUE2"; key \"name\"; leaf name {type string;}} }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"list1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("key", "one", "two"); TEST_DUP("max-elements", "10", "20"); TEST_DUP("min-elements", "10", "20"); TEST_DUP("ordered-by", "user", "system"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - 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;}" - "leaf-list ll {type string;} list li;max-elements 10; min-elements 1;must 'expr';notification not; ordered-by system; reference test;" - "status current;typedef t {type int8;}unique xxx;unique yyy;uses g;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_list(YCTX, NULL, (struct lysp_node **)&l)); - CHECK_LYSP_NODE(l, "test", 1, LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_SYSTEM | LYS_SET_MAX | LYS_SET_MIN, 1, "l", - 0, LYS_LIST, 0, "test", 1); - assert_string_equal("l", l->key); - assert_non_null(l->uniques); - assert_int_equal(2, LY_ARRAY_COUNT(l->uniques)); - assert_string_equal("xxx", l->uniques[0].str); - assert_string_equal("yyy", l->uniques[1].str); - assert_int_equal(10, l->max); - assert_int_equal(1, l->min); - assert_non_null(l->musts); - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - ly_set_erase(&YCTX->grps_nodes, NULL); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; + TEST_MOD(UTEST_LYCTX, + "module list1 {" + " yang-version 1.1;" + " namespace \"urn:list1\";" + " prefix l1;" + " feature f;" + " extension ext;" + " list test {" + " 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;}" + " leaf xxx {type string;} " + " leaf yyy {type string;} " + " leaf-list ll {type string;}" + " list li;" + " max-elements 10;" + " min-elements 1;" + " must 'expr';" + " notification not;" + " ordered-by system;" + " reference test;" + " status current;" + " typedef t {type int8;} unique xxx;" + " unique yyy;" + " uses g;" + " when 'true()';" + " l1:ext;" + " }" + "}", + LY_SUCCESS); /* invalid content */ - PARSER_CUR_PMOD(YCTX)->version = 1; /* simulate YANG 1.0 */ - in.current = "l {action x;} ..."; - assert_int_equal(LY_EVALID, parse_list(YCTX, NULL, (struct lysp_node **)&l)); + TEST_MOD(UTEST_LYCTX, "module list2 { namespace \"urn:list2\"; prefix l2; list test {action x; key \"name\"; leaf name {type string} } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"list2\" failed.", NULL, 0);\ CHECK_LOG_CTX("Invalid keyword \"action\" as a child of \"list\" - the statement is allowed only in YANG 1.1 modules.", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)l); l = NULL; } static void test_choice(void **state) { - struct lysp_node_choice *ch = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "ch {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_choice(YCTX, NULL, (struct lysp_node**)&ch)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)ch); ch = NULL; + TEST_MOD(UTEST_LYCTX, "module choice1 { yang-version 1.1; namespace \"urn:choice1\"; prefix c1; choice test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"choice1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); TEST_DUP("default", "a", "b"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("mandatory", "true", "false"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content - without default due to a collision with mandatory */ - in.current = "ch {anydata any;anyxml anyxml; case c;choice ch;config false;container c;description test;if-feature f;leaf l {type string;}" - "leaf-list ll {type string;} list li;mandatory true;reference test;status current;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_choice(YCTX, NULL, (struct lysp_node **)&ch)); - CHECK_LYSP_NODE(ch, "test", 1, LYS_CONFIG_R | LYS_STATUS_CURR | LYS_MAND_TRUE, 1, "ch", 0, LYS_CHOICE, 0, "test", 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ch); ch = NULL; + TEST_MOD(UTEST_LYCTX, + "module choice1 {" + " yang-version 1.1;" + " namespace \"urn:choice1\";" + " prefix c1;" + " feature f;" + " extension ext;" + " choice test {" + " anydata any;" + " anyxml anyxml;" + " case c;" + " choice ch;" + " config false;" + " container cont;" + " description test;" + " if-feature f;" + " leaf l {type string;}" + " leaf-list ll {type string;}" + " list li;" + " mandatory true;" + " reference test;" + " status current;" + " when 'true()';" + " c1:ext;" + " }" + "}", + LY_SUCCESS); /* full content - the default missing from the previous node */ - in.current = "ch {default c;case c;} ..."; - assert_int_equal(LY_SUCCESS, parse_choice(YCTX, NULL, (struct lysp_node **)&ch)); - CHECK_LYSP_NODE(ch, NULL, 0, 0, 0, "ch", 0, LYS_CHOICE, 0, NULL, 0); - assert_string_equal("c", ch->dflt.str); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)ch); ch = NULL; + TEST_MOD(UTEST_LYCTX, + "module choice2 {" + " yang-version 1.1;" + " namespace \"urn:choice2\";" + " prefix c2;" + " choice test {" + " default c;" + " case c;" + " }" + "}", + LY_SUCCESS); } static void test_case(void **state) { - struct lysp_node_case *cs = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "cs {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_case(YCTX, NULL, (struct lysp_node**)&cs)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)cs); cs = NULL; + TEST_MOD(UTEST_LYCTX, "module case1 { yang-version 1.1; namespace \"urn:case1\"; prefix c1; choice ch {case test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"case1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); - TEST_DUP("description", "text1", "text2"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - in.current = "cs {anydata any;anyxml anyxml; choice ch;container c;description test;if-feature f;leaf l {type string;}" - "leaf-list ll {type string;} list li;reference test;status current;uses grp;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_case(YCTX, NULL, (struct lysp_node **)&cs)); - CHECK_LYSP_NODE(cs, "test", 1, LYS_STATUS_CURR, 1, "cs", 0, LYS_CASE, 0, "test", 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)cs); cs = NULL; + TEST_MOD(UTEST_LYCTX, + "module case1 {" + " yang-version 1.1;" + " namespace \"urn:case1\";" + " prefix c1;" + " feature f;" + " extension ext;" + " grouping grp;" + " choice ch {" + " case test {" + " anydata any;" + " anyxml anyxml;" + " choice cho;" + " container cont;" + " description test;" + " if-feature f;" + " leaf l {type string;}" + " leaf-list ll {type string;}" + " list li { config false; }" + " reference test;" + " status current;" + " uses grp;" + " when 'true()';" + " c1:ext;" + " }" + " }" + "}", + LY_SUCCESS); /* invalid content */ - in.current = "cs {config true} ..."; - assert_int_equal(LY_EVALID, parse_case(YCTX, NULL, (struct lysp_node **)&cs)); + TEST_MOD(UTEST_LYCTX, + "module case1 {" + " yang-version 1.1;" + " namespace \"urn:case1\";" + " prefix c1;" + " feature f;" + " extension ext;" + " choice ch {" + " case test {" + " config true;" + " }" + " }" + "}", + LY_EVALID); + CHECK_LOG_CTX("Parsing module \"case1\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"case\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)cs); cs = NULL; } static void -test_any(void **state, enum ly_stmt kw) +test_anydata(void **state) { - struct lysp_node_anydata *any = NULL; - - if (kw == LY_STMT_ANYDATA) { - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - } else { - PARSER_CUR_PMOD(YCTX)->version = 1; /* simulate YANG 1.0 */ - } - - /* invalid cardinality */ -#define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_any(YCTX, kw, NULL, (struct lysp_node**)&any)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)any); any = NULL; + #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ + TEST_MOD(UTEST_LYCTX, "module anydata1 { yang-version 1.1; namespace \"urn:anydata1\"; prefix a1; anydata test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"anydata1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); TEST_DUP("config", "true", "false"); - TEST_DUP("description", "text1", "text2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); TEST_DUP("mandatory", "true", "false"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - in.current = "any {config true;description test;if-feature f;mandatory true;must 'expr';reference test;status current;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_any(YCTX, kw, NULL, (struct lysp_node **)&any)); - // CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, TYPE, PARENT, REF, WHEN) - uint16_t node_type = kw == LY_STMT_ANYDATA ? LYS_ANYDATA : LYS_ANYXML; - - CHECK_LYSP_NODE(any, "test", 1, LYS_CONFIG_W | LYS_STATUS_CURR | LYS_MAND_TRUE, 1, "any", 0, node_type, 0, "test", 1); - assert_non_null(any->musts); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)any); any = NULL; -} - -static void -test_anydata(void **state) -{ - test_any(state, LY_STMT_ANYDATA); + TEST_MOD(UTEST_LYCTX, + "module anydata1 {" + " yang-version 1.1;" + " namespace \"urn:anydata1\";" + " prefix a1;" + " feature f;" + " extension ext;" + " anydata test {" + " config true;" + " description test;" + " if-feature f;" + " mandatory true;" + " must 'expr';" + " reference test;" + " status current;" + " when 'true()';" + " a1:ext;" + " }" + "}", + LY_SUCCESS); } static void test_anyxml(void **state) { - test_any(state, LY_STMT_ANYXML); +#define TEST_DUP(MEMBER, VALUE1, VALUE2) \ + TEST_MOD(UTEST_LYCTX, "module anyxml1 { yang-version 1.1; namespace \"urn:anyxml1\"; prefix a1; anyxml test {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"anyxml1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); + + TEST_DUP("config", "true", "false"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("mandatory", "true", "false"); + TEST_DUP("reference", "\"1\"", "\"2\""); + TEST_DUP("status", "current", "obsolete"); + TEST_DUP("when", "'true()'", "'false()'"); +#undef TEST_DUP + + /* full content */ + TEST_MOD(UTEST_LYCTX, + "module anyxml1 {" + " yang-version 1.1;" + " namespace \"urn:anyxml1\";" + " prefix a1;" + " feature f;" + " extension ext;" + " anyxml test {" + " config true;" + " description test;" + " if-feature f;" + " mandatory true;" + " must 'expr';" + " reference test;" + " status current;" + " when 'true()';" + " a1:ext;" + " }" + "}", + LY_SUCCESS); } static void test_grouping(void **state) { - struct lysp_node_grp *grp = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_grouping(YCTX, NULL, &grp)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), &grp->node); grp = NULL; + TEST_MOD(UTEST_LYCTX, "module grouping1 { yang-version 1.1; namespace \"urn:group1\"; prefix g1; grouping test {" MEMBER" "VALUE1";"MEMBER" "VALUE2"; leaf name {type string} } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"grouping1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); - TEST_DUP("description", "text1", "text2"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); #undef TEST_DUP /* full content */ - in.current = "grp {action x;anydata any;anyxml anyxml; choice ch;container c;description test;grouping g;leaf l {type string;}" - "leaf-list ll {type string;} list li;notification not;reference test;status current;typedef t {type int8;}uses g;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_grouping(YCTX, NULL, &grp)); - assert_non_null(grp); - assert_int_equal(LYS_GROUPING, grp->nodetype); - assert_string_equal("grp", grp->name); - assert_string_equal("test", grp->dsc); - assert_non_null(grp->exts); - assert_string_equal("test", grp->ref); - assert_null(grp->parent); - assert_int_equal(LYS_STATUS_CURR, grp->flags); - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - ly_set_erase(&YCTX->grps_nodes, NULL); - lysp_node_free(PARSER_CTX(YCTX), &grp->node); - grp = NULL; + TEST_MOD(UTEST_LYCTX, + "module grouping1 {" + " yang-version 1.1;" + " namespace \"urn:grouping1\";" + " prefix g1;" + " feature f;" + " extension ext;" + " grouping test {" + " anydata any;" + " anyxml anyxml;" + " choice ch;" + " container cont;" + " description test;" + " grouping g;" + " leaf l {type string;}" + " leaf-list ll {type string;}" + " list li { config false; }" + " notification not;" + " reference test;" + " status current;" + " typedef t {type int8;}uses g;" + " g1:ext;" + " }" + "}", + LY_SUCCESS); /* invalid content */ - in.current = "grp {config true} ..."; - assert_int_equal(LY_EVALID, parse_grouping(YCTX, NULL, &grp)); + TEST_MOD(UTEST_LYCTX, + "module grouping2 {" + " yang-version 1.1;" + " namespace \"urn:grouping2\";" + " prefix g2;" + " grouping test {" + " config true" + " }" + "}", + LY_EVALID); + CHECK_LOG_CTX("Parsing module \"grouping2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"grouping\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), &grp->node); - grp = NULL; - in.current = "grp {must 'expr'} ..."; - assert_int_equal(LY_EVALID, parse_grouping(YCTX, NULL, &grp)); + TEST_MOD(UTEST_LYCTX, + "module grouping2 {" + " yang-version 1.1;" + " namespace \"urn:grouping2\";" + " prefix g2;" + " grouping test {" + " must 'expr'" + " }" + "}", + LY_EVALID); + CHECK_LOG_CTX("Parsing module \"grouping2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"must\" as a child of \"grouping\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), &grp->node); - grp = NULL; } static void test_action(void **state) { - struct lysp_node_action *rpcs = NULL; - struct lysp_node_container *c = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_action(YCTX, NULL, &rpcs)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)rpcs); rpcs = NULL; - - TEST_DUP("description", "text1", "text2"); - TEST_DUP("input", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a"); - TEST_DUP("output", "{leaf l1 {type empty;}} description a", "{leaf l2 {type empty;}} description a"); - TEST_DUP("reference", "1", "2"); + TEST_MOD(UTEST_LYCTX, "module act1 { yang-version 1.1; namespace \"urn:act1\"; prefix a; container top { action test { " MEMBER " " VALUE1 "; " MEMBER " " VALUE2 "; } } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"act1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); + + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); #undef TEST_DUP + TEST_MOD(UTEST_LYCTX, "module act1 { yang-version 1.1; namespace \"urn:act-in\"; prefix a; container top { action func { input { leaf l1 {type empty;} } input { leaf l2 {type empty;} } } } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"act1\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"input\".", NULL, 1); + + TEST_MOD(UTEST_LYCTX, "module act1 { yang-version 1.1; namespace \"urn:act-out\"; prefix a; container top { action func { output { leaf l1 {type empty;} } output { leaf l2 {type empty;} } } } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"act1\" failed.", NULL, 0); + CHECK_LOG_CTX("Duplicate keyword \"output\".", NULL, 1); + /* full content */ - in.current = "top;"; - assert_int_equal(LY_SUCCESS, parse_container(YCTX, NULL, (struct lysp_node **)&c)); - in.current = "func {description test;grouping grp;if-feature f;reference test;status current;typedef mytype {type int8;} m:ext;" - "input {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}" - " list li; must 1; typedef mytypei {type int8;} uses grp; m:ext;}" - "output {anydata a1; anyxml a2; choice ch; container c; grouping grp; leaf l {type int8;} leaf-list ll {type int8;}" - " list li; must 1; typedef mytypeo {type int8;} uses grp; m:ext;}} ..."; - assert_int_equal(LY_SUCCESS, parse_action(YCTX, (struct lysp_node *)c, &rpcs)); - assert_non_null(rpcs); - assert_int_equal(LYS_ACTION, rpcs->nodetype); - assert_string_equal("func", rpcs->name); - assert_string_equal("test", rpcs->dsc); - assert_non_null(rpcs->exts); - assert_non_null(rpcs->iffeatures); - assert_string_equal("test", rpcs->ref); - assert_non_null(rpcs->groupings); - assert_non_null(rpcs->typedefs); - assert_int_equal(LYS_STATUS_CURR, rpcs->flags); - /* input */ - assert_int_equal(rpcs->input.nodetype, LYS_INPUT); - assert_non_null(rpcs->input.groupings); - assert_non_null(rpcs->input.exts); - assert_non_null(rpcs->input.musts); - assert_non_null(rpcs->input.typedefs); - assert_non_null(rpcs->input.child); - /* output */ - assert_int_equal(rpcs->output.nodetype, LYS_OUTPUT); - assert_non_null(rpcs->output.groupings); - assert_non_null(rpcs->output.exts); - assert_non_null(rpcs->output.musts); - assert_non_null(rpcs->output.typedefs); - assert_non_null(rpcs->output.child); - - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - ly_set_erase(&YCTX->grps_nodes, NULL); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)rpcs); rpcs = NULL; + TEST_MOD(UTEST_LYCTX, + "module act1 {" + " yang-version 1.1;" + " namespace \"urn:act1\";" + " prefix a;" + " feature f;" + " extension ext;" + " container top {" + " action test {" + " description test;" + " grouping grp {}" + " if-feature f;" + " reference test;" + " status current;" + " typedef mytype {type int8;}" + " a:ext;" + " input {" + " anydata a1;" + " anyxml a2;" + " choice ch { leaf x { type empty; } }" + " container c;" + " grouping grp-in {}" + " leaf l {type int8;}" + " leaf-list ll {type int8;}" + " list li { key k; leaf k {type empty;} }" + " must 'true()';" + " typedef mytypei {type int8;}" + " uses grp-in;" + " a:ext;" + " }" + " output {" + " anydata a1;" + " anyxml a2;" + " choice ch { leaf x { type empty; } }" + " container c;" + " grouping grp-out {}" + " leaf l {type int8;}" + " leaf-list ll {type int8;}" + " list li { key k; leaf k {type empty;} }" + " must 'true()';" + " typedef mytypeo {type int8;}" + " uses grp-out;" + " a:ext;" + " }" + " }" + " }" + "}", + LY_SUCCESS); /* invalid content */ - in.current = "func {config true} ..."; - assert_int_equal(LY_EVALID, parse_action(YCTX, NULL, &rpcs)); - CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"rpc\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)rpcs); rpcs = NULL; - - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); + TEST_MOD(UTEST_LYCTX, + "module act2 {" + " yang-version 1.1;" + " namespace \"urn:act2\";" + " prefix a;" + " container top {" + " action func { config true; }" + " }" + "}", + LY_EVALID); + CHECK_LOG_CTX("Parsing module \"act2\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"action\".", NULL, 1); } static void test_notification(void **state) { - struct lysp_node_notif *notifs = NULL; - struct lysp_node_container *c = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "func {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_notif(YCTX, NULL, ¬ifs)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)notifs); notifs = NULL; + TEST_MOD(UTEST_LYCTX, "module notif1 { yang-version 1.1; namespace \"urn:notif1\"; prefix n; notification ntf { " MEMBER " " VALUE1 "; " MEMBER " " VALUE2 "; } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"notif1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); - TEST_DUP("description", "text1", "text2"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); #undef TEST_DUP /* full content */ - in.current = "top;"; - assert_int_equal(LY_SUCCESS, parse_container(YCTX, NULL, (struct lysp_node **)&c)); - in.current = "ntf {anydata a1; anyxml a2; choice ch; container c; description test; grouping grp; if-feature f; leaf l {type int8;}" - "leaf-list ll {type int8;} list li; must 1; reference test; status current; typedef mytype {type int8;} uses grp; m:ext;}"; - assert_int_equal(LY_SUCCESS, parse_notif(YCTX, (struct lysp_node *)c, ¬ifs)); - assert_non_null(notifs); - assert_int_equal(LYS_NOTIF, notifs->nodetype); - assert_string_equal("ntf", notifs->name); - assert_string_equal("test", notifs->dsc); - assert_non_null(notifs->exts); - assert_non_null(notifs->iffeatures); - assert_string_equal("test", notifs->ref); - assert_non_null(notifs->groupings); - assert_non_null(notifs->typedefs); - assert_non_null(notifs->musts); - assert_non_null(notifs->child); - assert_int_equal(LYS_STATUS_CURR, notifs->flags); - - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - ly_set_erase(&YCTX->grps_nodes, NULL); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)notifs); notifs = NULL; + TEST_MOD(UTEST_LYCTX, + "module notif1 {" + " yang-version 1.1;" + " namespace \"urn:notif1\";" + " prefix n;" + " feature f;" + " extension ext;" + " container top {" + " notification ntf {" + " anydata a1;" + " anyxml a2;" + " choice ch { leaf x { type empty; } }" + " container c;" + " description test;" + " grouping grp {}" + " if-feature f;" + " leaf l {type int8;}" + " leaf-list ll {type int8;}" + " list li { key k; leaf k {type empty;} }" + " must 'true()';" + " reference test;" + " status current;" + " typedef mytype {type int8;}" + " uses grp;" + " n:ext;" + " }" + " }" + "}", + LY_SUCCESS); /* invalid content */ - in.current = "ntf {config true} ..."; - assert_int_equal(LY_EVALID, parse_notif(YCTX, NULL, ¬ifs)); + TEST_MOD(UTEST_LYCTX, + "module notif2 {" + " yang-version 1.1;" + " namespace \"urn:notif2\";" + " prefix n;" + " notification ntf { config true; }" /* Notifications cannot have config true */ + "}", + LY_EVALID); + CHECK_LOG_CTX("Parsing module \"notif2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid keyword \"config\" as a child of \"notification\".", NULL, 1); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)notifs); notifs = NULL; - - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)c); } static void test_uses(void **state) { - struct lysp_node_uses *u = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_uses(YCTX, NULL, (struct lysp_node**)&u)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node*)u); u = NULL; + TEST_MOD(UTEST_LYCTX, "module uses1 { yang-version 1.1; namespace \"urn:uses1\"; prefix u; grouping g; container c { uses g { " MEMBER " " VALUE1 "; " MEMBER " " VALUE2 "; } } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"uses1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); - TEST_DUP("description", "text1", "text2"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - in.current = "grpref {augment some/node;description test;if-feature f;reference test;refine some/other/node;status current;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_uses(YCTX, NULL, (struct lysp_node **)&u)); - CHECK_LYSP_NODE(u, "test", 1, LYS_STATUS_CURR, 1, "grpref", 0, LYS_USES, 0, "test", 1); - assert_non_null(u->augments); - assert_non_null(u->refines); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)u); u = NULL; + TEST_MOD(UTEST_LYCTX, + "module uses1 {" + " yang-version 1.1;" + " namespace \"urn:uses1\";" + " prefix u;" + " feature f;" + " extension ext;" + " " + " /* We MUST build the tree inside the grouping so augment/refine can find their targets! */" + " grouping grpref {" + " container some {" + " container node;" + " container other {" + " leaf node { type string; }" + " }" + " }" + " }" + " " + " container top {" + " uses grpref {" + " augment \"some/node\" { leaf new-leaf { type empty; } }" + " description test;" + " if-feature f;" + " reference test;" + " refine \"some/other/node\" { description \"refined\"; }" + " status current;" + " when 'true()';" + " u:ext;" + " }" + " }" + "}", + LY_SUCCESS); } static void test_augment(void **state) { - struct lysp_node_augment *a = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - /* invalid cardinality */ #define TEST_DUP(MEMBER, VALUE1, VALUE2) \ - in.current = "l {" MEMBER" "VALUE1";"MEMBER" "VALUE2";} ..."; \ - assert_int_equal(LY_EVALID, parse_augment(YCTX, NULL, &a)); \ - CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); \ - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)a); a = NULL; + TEST_MOD(UTEST_LYCTX, "module aug1 { yang-version 1.1; namespace \"urn:aug1\"; prefix a; container target { container nodeid; } augment \"/a:target/a:nodeid\" { " MEMBER " " VALUE1 "; " MEMBER " " VALUE2 "; } }", LY_EVALID);\ + CHECK_LOG_CTX("Parsing module \"aug1\" failed.", NULL, 0);\ + CHECK_LOG_CTX("Duplicate keyword \""MEMBER"\".", NULL, 1); - TEST_DUP("description", "text1", "text2"); - TEST_DUP("reference", "1", "2"); + TEST_DUP("description", "\"text1\"", "\"text2\""); + TEST_DUP("reference", "\"1\"", "\"2\""); TEST_DUP("status", "current", "obsolete"); - TEST_DUP("when", "true", "false"); + TEST_DUP("when", "'true()'", "'false()'"); #undef TEST_DUP /* full content */ - 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;}" - "leaf-list ll {type string;} list li;notification not;reference test;status current;uses g;when true;m:ext;} ..."; - assert_int_equal(LY_SUCCESS, parse_augment(YCTX, NULL, &a)); - assert_non_null(a); - assert_int_equal(LYS_AUGMENT, a->nodetype); - assert_string_equal("/target/nodeid", a->nodeid); - assert_string_equal("test", a->dsc); - assert_non_null(a->exts); - assert_non_null(a->iffeatures); - assert_string_equal("test", a->ref); - assert_non_null(a->when); - assert_null(a->parent); - assert_int_equal(LYS_STATUS_CURR, a->flags); - lysp_node_free(PARSER_CTX(YCTX), (struct lysp_node *)a); a = NULL; + TEST_MOD(UTEST_LYCTX, + "module aug1 {" + " yang-version 1.1;" + " namespace \"urn:aug1\";" + " prefix a;" + " feature f;" + " extension ext;" + " grouping g;" + " " + " container target {" + " container nodeid;" + " choice ch;" + " }" + " " + " /* Augmenting a container */" + " augment \"/a:target/a:nodeid\" {" + " action x;" + " anydata any;" + " anyxml anyxml;" + " choice ch { leaf ch-l { type empty; } }" + " container c;" + " description test;" + " if-feature f;" + " leaf l {type string;}" + " leaf-list ll {type string;}" + " list li { key k; leaf k {type empty;} }" + " notification not;" + " reference test;" + " status current;" + " uses g;" + " when 'true()';" + " a:ext;" + " }" + " " + " augment \"/a:target/a:ch\" {" + " case cs { leaf cs-l { type empty; } }" + " }" + "}", + LY_SUCCESS); } static void test_when(void **state) { - struct lysp_when *w = NULL; - - PARSER_CUR_PMOD(YCTX)->version = 2; /* simulate YANG 1.1 */ - - in.current = "l { description text1;description text2;} ..."; - assert_int_equal(LY_EVALID, parse_when(YCTX, &w)); - assert_null(w); + TEST_MOD(UTEST_LYCTX, "module when1 { yang-version 1.1; namespace \"urn:when1\"; prefix w; leaf l { type empty; when 'true()' { description text1; description text2; } } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"when1\" failed.", NULL, 0); CHECK_LOG_CTX("Duplicate keyword \"description\".", NULL, 1); - in.current = "l { reference 1;reference 2;} ..."; - assert_int_equal(LY_EVALID, parse_when(YCTX, &w)); - assert_null(w); + TEST_MOD(UTEST_LYCTX, "module when1 { yang-version 1.1; namespace \"urn:when1\"; prefix w; leaf l { type empty; when 'true()' { reference 1; reference 2; } } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"when1\" failed.", NULL, 0); CHECK_LOG_CTX("Duplicate keyword \"reference\".", NULL, 1); } static void test_value(void **state) { - struct lysp_type_enum enm; - - in.current = "-0;"; - memset(&enm, 0, sizeof enm); - assert_int_equal(parse_type_enum_value_pos(YCTX, LY_STMT_VALUE, &enm), LY_SUCCESS); + TEST_MOD(UTEST_LYCTX, "module val1 { yang-version 1.1; namespace \"urn:val1\"; prefix v; leaf l { type enumeration { enum a { value -0; } } } }", LY_SUCCESS); - in.current = "-0;"; - memset(&enm, 0, sizeof enm); - assert_int_equal(parse_type_enum_value_pos(YCTX, LY_STMT_POSITION, &enm), LY_EVALID); + TEST_MOD(UTEST_LYCTX, "module val2 { yang-version 1.1; namespace \"urn:val2\"; prefix v; leaf l { type bits { bit a { position -0; } } } }", LY_EVALID); + CHECK_LOG_CTX("Parsing module \"val2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-0\" of \"position\".", NULL, 1); } @@ -1714,30 +1506,30 @@ int main(void) { const struct CMUnitTest tests[] = { - UTEST(test_helpers, setup, teardown), - UTEST(test_comments, setup, teardown), - UTEST(test_arg, setup, teardown), - UTEST(test_stmts, setup, teardown), - UTEST(test_minmax, setup, teardown), - UTEST(test_valid_module, setup, teardown), - UTEST(test_module, setup, teardown), - UTEST(test_deviation, setup, teardown), - UTEST(test_deviate, setup, teardown), - UTEST(test_container, setup, teardown), - UTEST(test_leaf, setup, teardown), - UTEST(test_leaflist, setup, teardown), - UTEST(test_list, setup, teardown), - UTEST(test_choice, setup, teardown), - UTEST(test_case, setup, teardown), - UTEST(test_anydata, setup, teardown), - UTEST(test_anyxml, setup, teardown), - UTEST(test_action, setup, teardown), - UTEST(test_notification, setup, teardown), - UTEST(test_grouping, setup, teardown), - UTEST(test_uses, setup, teardown), - UTEST(test_augment, setup, teardown), - UTEST(test_when, setup, teardown), - UTEST(test_value, setup, teardown), + UTEST(test_helpers), + UTEST(test_comments), + UTEST(test_arg), + UTEST(test_stmts), + UTEST(test_minmax), + UTEST(test_valid_module), + UTEST(test_module), + UTEST(test_deviation), + UTEST(test_deviate), + UTEST(test_container), + UTEST(test_leaf), + UTEST(test_leaflist), + UTEST(test_list), + UTEST(test_choice), + UTEST(test_case), + UTEST(test_anydata), + UTEST(test_anyxml), + UTEST(test_action), + UTEST(test_notification), + UTEST(test_grouping), + UTEST(test_uses), + UTEST(test_augment), + UTEST(test_when), + UTEST(test_value), }; return cmocka_run_group_tests(tests, NULL, NULL); diff --git a/tests/utests/schema/test_yin.c b/tests/utests/schema/test_yin.c index 50eab90346..f1b7cda397 100644 --- a/tests/utests/schema/test_yin.c +++ b/tests/utests/schema/test_yin.c @@ -20,382 +20,145 @@ #include #include "in.h" -#include "ly_common.h" -#include "parser_internal.h" -#include "schema_compile.h" #include "tree.h" #include "tree_edit.h" #include "tree_schema.h" -#include "tree_schema_internal.h" -#include "xml.h" -#include "xpath.h" - -/* copied from parser_yin.c */ -enum yin_argument { - YIN_ARG_UNKNOWN = 0, /**< parsed argument can not be matched with any supported yin argument keyword */ - YIN_ARG_NAME, /**< argument name */ - YIN_ARG_TARGET_NODE, /**< argument target-node */ - YIN_ARG_MODULE, /**< argument module */ - YIN_ARG_VALUE, /**< argument value */ - YIN_ARG_TEXT, /**< argument text */ - YIN_ARG_CONDITION, /**< argument condition */ - YIN_ARG_URI, /**< argument uri */ - YIN_ARG_DATE, /**< argument data */ - YIN_ARG_TAG, /**< argument tag */ - YIN_ARG_NONE /**< empty (special value) */ -}; - -struct yin_subelement { - enum ly_stmt type; /**< type of keyword */ - void *dest; /**< meta infromation passed to responsible function (mostly information about where parsed subelement should be stored) */ - uint16_t flags; /**< describes constraints of subelement can be set to YIN_SUBELEM_MANDATORY, YIN_SUBELEM_UNIQUE, YIN_SUBELEM_FIRST, YIN_SUBELEM_VER2, and YIN_SUBELEM_DEFAULT_TEXT */ -}; - -struct import_meta { - const char *prefix; /**< module prefix. */ - struct lysp_import **imports; /**< imports to add to. */ -}; - -struct yin_argument_meta { - uint16_t *flags; /**< Argument flags */ - const char **argument; /**< Argument value */ -}; - -struct tree_node_meta { - struct lysp_node *parent; /**< parent node */ - struct lysp_node **nodes; /**< linked list of siblings */ -}; - -struct include_meta { - const char *name; /**< Module/submodule name. */ - struct lysp_include **includes; /**< [Sized array](@ref sizedarrays) of parsed includes to add to. */ -}; - -struct inout_meta { - struct lysp_node *parent; /**< Parent node. */ - struct lysp_node_action_inout *inout_p; /**< inout_p Input/output pointer to write to. */ -}; - -struct minmax_dev_meta { - uint32_t *lim; /**< min/max value to write to. */ - uint16_t *flags; /**< min/max flags to write to. */ - struct lysp_ext_instance **exts; /**< extension instances to add to. */ -}; - -#define YIN_SUBELEM_MANDATORY 0x01 -#define YIN_SUBELEM_UNIQUE 0x02 -#define YIN_SUBELEM_FIRST 0x04 -#define YIN_SUBELEM_VER2 0x08 - -#define YIN_SUBELEM_PARSED 0x80 - -/* prototypes of static functions */ -enum yin_argument yin_match_argument_name(const char *name, size_t len); - -LY_ERR yin_parse_content(struct lysp_yin_ctx *ctx, struct yin_subelement *subelem_info, size_t subelem_info_size, - const void *parent, enum ly_stmt parent_stmt, const char **text_content, struct lysp_ext_instance **exts); -LY_ERR yin_validate_value(struct lysp_yin_ctx *ctx, enum yang_arg val_type); -enum ly_stmt yin_match_keyword(struct lysp_yin_ctx *ctx, const char *name, size_t name_len, - const char *prefix, size_t prefix_len, enum ly_stmt parrent); - -LY_ERR yin_parse_extension_instance(struct lysp_yin_ctx *ctx, const void *parent, enum ly_stmt parent_stmt, - LY_ARRAY_COUNT_TYPE parent_stmt_index, struct lysp_ext_instance **exts); -LY_ERR yin_parse_element_generic(struct lysp_yin_ctx *ctx, enum ly_stmt parent, struct lysp_stmt **element); -LY_ERR yin_parse_mod(struct lysp_yin_ctx *ctx, struct lysp_module *mod); -LY_ERR yin_parse_submod(struct lysp_yin_ctx *ctx, struct lysp_submodule *submod); - -/* wrapping element used for mocking has nothing to do with real module structure */ -#define ELEMENT_WRAPPER_START "" -#define ELEMENT_WRAPPER_END "" - -#define TEST_1_CHECK_LYSP_EXT_INSTANCE(NODE, INSUBSTMT)\ - CHECK_LYSP_EXT_INSTANCE((NODE), NULL, 1, INSUBSTMT, 0, "myext:c-define", LY_VALUE_XML) - -struct lysp_yin_ctx *YCTX; - -static int -setup_ctx(void **state) -{ - struct lysp_module *pmod; - - /* allocate parser context */ - YCTX = calloc(1, sizeof(*YCTX)); - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - YCTX->format = LYS_IN_YIN; - ly_set_new(&YCTX->parsed_mods); - - /* allocate new parsed module */ - pmod = calloc(1, sizeof *pmod); - ly_set_add(YCTX->parsed_mods, pmod, 1, NULL); - - /* allocate new module */ - pmod->mod = calloc(1, sizeof *pmod->mod); - pmod->mod->ctx = UTEST_LYCTX; - pmod->mod->parsed = pmod; - - return 0; -} - -static int -setup(void **state) -{ - UTEST_SETUP; - - setup_ctx(state); - return 0; -} - -static int -teardown_ctx(void **state) -{ - lys_module_free(UTEST_LYCTX, PARSER_CUR_PMOD(YCTX)->mod, 0); - lysp_yin_ctx_free(YCTX); - YCTX = NULL; - - return 0; -} - -static int -teardown(void **state) -{ - teardown_ctx(state); - - UTEST_TEARDOWN; - - return 0; -} - -#define RESET_STATE \ - ly_in_free(UTEST_IN, 0); \ - UTEST_IN = NULL; \ - teardown_ctx(state); \ - setup_ctx(state) +#define TEST_1_CHECK_LYSP_EXT_INSTANCE(NODE, INSUBSTMT, ARGUMENT)\ + CHECK_LYSP_EXT_INSTANCE((NODE), (ARGUMENT), 1, INSUBSTMT, 0, "myext:c-define", LY_VALUE_XML) static void test_yin_match_keyword(void **state) { - const char *prefix; - size_t prefix_len; - - /* create mock yin namespace in xml context */ - ly_in_new_memory("", &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - prefix = YCTX->xmlctx->prefix; - prefix_len = YCTX->xmlctx->prefix_len; - - assert_int_equal(yin_match_keyword(YCTX, "anydatax", strlen("anydatax"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_NONE); - assert_int_equal(yin_match_keyword(YCTX, "asdasd", strlen("asdasd"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_NONE); - assert_int_equal(yin_match_keyword(YCTX, "", 0, prefix, prefix_len, LY_STMT_NONE), LY_STMT_NONE); - assert_int_equal(yin_match_keyword(YCTX, "anydata", strlen("anydata"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ANYDATA); - assert_int_equal(yin_match_keyword(YCTX, "anyxml", strlen("anyxml"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ANYXML); - assert_int_equal(yin_match_keyword(YCTX, "argument", strlen("argument"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ARGUMENT); - assert_int_equal(yin_match_keyword(YCTX, "augment", strlen("augment"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_AUGMENT); - assert_int_equal(yin_match_keyword(YCTX, "base", strlen("base"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_BASE); - assert_int_equal(yin_match_keyword(YCTX, "belongs-to", strlen("belongs-to"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_BELONGS_TO); - assert_int_equal(yin_match_keyword(YCTX, "bit", strlen("bit"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_BIT); - assert_int_equal(yin_match_keyword(YCTX, "case", strlen("case"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_CASE); - assert_int_equal(yin_match_keyword(YCTX, "choice", strlen("choice"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_CHOICE); - assert_int_equal(yin_match_keyword(YCTX, "config", strlen("config"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_CONFIG); - assert_int_equal(yin_match_keyword(YCTX, "contact", strlen("contact"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_CONTACT); - assert_int_equal(yin_match_keyword(YCTX, "container", strlen("container"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_CONTAINER); - assert_int_equal(yin_match_keyword(YCTX, "default", strlen("default"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_DEFAULT); - assert_int_equal(yin_match_keyword(YCTX, "description", strlen("description"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_DESCRIPTION); - assert_int_equal(yin_match_keyword(YCTX, "deviate", strlen("deviate"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_DEVIATE); - assert_int_equal(yin_match_keyword(YCTX, "deviation", strlen("deviation"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_DEVIATION); - assert_int_equal(yin_match_keyword(YCTX, "enum", strlen("enum"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ENUM); - assert_int_equal(yin_match_keyword(YCTX, "error-app-tag", strlen("error-app-tag"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ERROR_APP_TAG); - assert_int_equal(yin_match_keyword(YCTX, "error-message", strlen("error-message"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ERROR_MESSAGE); - assert_int_equal(yin_match_keyword(YCTX, "extension", strlen("extension"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_EXTENSION); - assert_int_equal(yin_match_keyword(YCTX, "feature", strlen("feature"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_FEATURE); - assert_int_equal(yin_match_keyword(YCTX, "fraction-digits", strlen("fraction-digits"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_FRACTION_DIGITS); - assert_int_equal(yin_match_keyword(YCTX, "grouping", strlen("grouping"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_GROUPING); - assert_int_equal(yin_match_keyword(YCTX, "identity", strlen("identity"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_IDENTITY); - assert_int_equal(yin_match_keyword(YCTX, "if-feature", strlen("if-feature"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_IF_FEATURE); - assert_int_equal(yin_match_keyword(YCTX, "import", strlen("import"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_IMPORT); - assert_int_equal(yin_match_keyword(YCTX, "include", strlen("include"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_INCLUDE); - assert_int_equal(yin_match_keyword(YCTX, "input", strlen("input"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_INPUT); - assert_int_equal(yin_match_keyword(YCTX, "key", strlen("key"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_KEY); - assert_int_equal(yin_match_keyword(YCTX, "leaf", strlen("leaf"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_LEAF); - assert_int_equal(yin_match_keyword(YCTX, "leaf-list", strlen("leaf-list"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_LEAF_LIST); - assert_int_equal(yin_match_keyword(YCTX, "length", strlen("length"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_LENGTH); - assert_int_equal(yin_match_keyword(YCTX, "list", strlen("list"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_LIST); - assert_int_equal(yin_match_keyword(YCTX, "mandatory", strlen("mandatory"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MANDATORY); - assert_int_equal(yin_match_keyword(YCTX, "max-elements", strlen("max-elements"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MAX_ELEMENTS); - assert_int_equal(yin_match_keyword(YCTX, "min-elements", strlen("min-elements"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MIN_ELEMENTS); - assert_int_equal(yin_match_keyword(YCTX, "modifier", strlen("modifier"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MODIFIER); - assert_int_equal(yin_match_keyword(YCTX, "module", strlen("module"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MODULE); - assert_int_equal(yin_match_keyword(YCTX, "must", strlen("must"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_MUST); - assert_int_equal(yin_match_keyword(YCTX, "namespace", strlen("namespace"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_NAMESPACE); - assert_int_equal(yin_match_keyword(YCTX, "notification", strlen("notification"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_NOTIFICATION); - assert_int_equal(yin_match_keyword(YCTX, "ordered-by", strlen("ordered-by"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ORDERED_BY); - assert_int_equal(yin_match_keyword(YCTX, "organization", strlen("organization"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_ORGANIZATION); - assert_int_equal(yin_match_keyword(YCTX, "output", strlen("output"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_OUTPUT); - assert_int_equal(yin_match_keyword(YCTX, "path", strlen("path"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_PATH); - assert_int_equal(yin_match_keyword(YCTX, "pattern", strlen("pattern"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_PATTERN); - assert_int_equal(yin_match_keyword(YCTX, "position", strlen("position"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_POSITION); - assert_int_equal(yin_match_keyword(YCTX, "prefix", strlen("prefix"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_PREFIX); - assert_int_equal(yin_match_keyword(YCTX, "presence", strlen("presence"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_PRESENCE); - assert_int_equal(yin_match_keyword(YCTX, "range", strlen("range"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_RANGE); - assert_int_equal(yin_match_keyword(YCTX, "reference", strlen("reference"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_REFERENCE); - assert_int_equal(yin_match_keyword(YCTX, "refine", strlen("refine"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_REFINE); - assert_int_equal(yin_match_keyword(YCTX, "require-instance", strlen("require-instance"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_REQUIRE_INSTANCE); - assert_int_equal(yin_match_keyword(YCTX, "revision", strlen("revision"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_REVISION); - assert_int_equal(yin_match_keyword(YCTX, "revision-date", strlen("revision-date"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_REVISION_DATE); - assert_int_equal(yin_match_keyword(YCTX, "rpc", strlen("rpc"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_RPC); - assert_int_equal(yin_match_keyword(YCTX, "status", strlen("status"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_STATUS); - assert_int_equal(yin_match_keyword(YCTX, "submodule", strlen("submodule"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_SUBMODULE); - assert_int_equal(yin_match_keyword(YCTX, "type", strlen("type"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_TYPE); - assert_int_equal(yin_match_keyword(YCTX, "typedef", strlen("typedef"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_TYPEDEF); - assert_int_equal(yin_match_keyword(YCTX, "unique", strlen("unique"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_UNIQUE); - assert_int_equal(yin_match_keyword(YCTX, "units", strlen("units"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_UNITS); - assert_int_equal(yin_match_keyword(YCTX, "uses", strlen("uses"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_USES); - assert_int_equal(yin_match_keyword(YCTX, "value", strlen("value"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_VALUE); - assert_int_equal(yin_match_keyword(YCTX, "when", strlen("when"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_WHEN); - assert_int_equal(yin_match_keyword(YCTX, "yang-version", strlen("yang-version"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_YANG_VERSION); - assert_int_equal(yin_match_keyword(YCTX, "yin-element", strlen("yin-element"), prefix, prefix_len, LY_STMT_NONE), LY_STMT_YIN_ELEMENT); -} + const char *yin_data; -static void -test_yin_match_argument_name(void **UNUSED(state)) -{ - assert_int_equal(yin_match_argument_name("", 5), YIN_ARG_UNKNOWN); - assert_int_equal(yin_match_argument_name("qwertyasd", 5), YIN_ARG_UNKNOWN); - assert_int_equal(yin_match_argument_name("conditionasd", 8), YIN_ARG_UNKNOWN); - assert_int_equal(yin_match_argument_name("condition", 9), YIN_ARG_CONDITION); - assert_int_equal(yin_match_argument_name("date", 4), YIN_ARG_DATE); - assert_int_equal(yin_match_argument_name("module", 6), YIN_ARG_MODULE); - assert_int_equal(yin_match_argument_name("name", 4), YIN_ARG_NAME); - assert_int_equal(yin_match_argument_name("tag", 3), YIN_ARG_TAG); - assert_int_equal(yin_match_argument_name("target-node", 11), YIN_ARG_TARGET_NODE); - assert_int_equal(yin_match_argument_name("text", 4), YIN_ARG_TEXT); - assert_int_equal(yin_match_argument_name("uri", 3), YIN_ARG_URI); - assert_int_equal(yin_match_argument_name("value", 5), YIN_ARG_VALUE); + yin_data = + "" + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Unexpected sub-element \"anydatax\" of \"module\" element.", NULL, 1); + + yin_data = + "" + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Unexpected sub-element \"asdasd\" of \"module\" element.", NULL, 1); + + yin_data = + "" + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Identifier \">\" starts with an invalid character.", NULL, 1); } static void test_yin_parse_content(void **state) { - LY_ERR ret = LY_SUCCESS; - const char *data = - "\n" - " totally amazing extension\n" - " \n" - " \n" - " desc\n" - " ref\n" - " \n" - " \n" - " wsefsdf\n" - " \n" - " \n" - " when_ref\n" - " when_desc\n" - " \n" - " \n" - " \n" - " error-msg\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - ""; - struct lysp_ext_instance *exts = NULL; - const char *value; - - /* test unique subelem */ - const char *prefix_value; - struct yin_subelement subelems2[2] = {{LY_STMT_PREFIX, &prefix_value, YIN_SUBELEM_UNIQUE}, - {LY_STMT_ARG_TEXT, &value, YIN_SUBELEM_UNIQUE}}; - - data = ELEMENT_WRAPPER_START - "" - "wsefsdf" - "wsefsdf" - ELEMENT_WRAPPER_END; - ly_in_new_memory(data, &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - lyxml_ctx_next(YCTX->xmlctx); - - ret = yin_parse_content(YCTX, subelems2, 2, NULL, LY_STMT_STATUS, NULL, &exts); - assert_int_equal(ret, LY_EVALID); - CHECK_LOG_CTX("Redefinition of \"text\" sub-element in \"status\" element.", NULL, 1); - lysdict_remove(UTEST_LYCTX, prefix_value); - lysdict_remove(UTEST_LYCTX, value); - RESET_STATE; - - /* test first subelem */ - data = ELEMENT_WRAPPER_START - "" - "wsefsdf" - "wsefsdf" - ELEMENT_WRAPPER_END; - struct yin_subelement subelems3[2] = {{LY_STMT_PREFIX, &prefix_value, YIN_SUBELEM_UNIQUE}, - {LY_STMT_ARG_TEXT, &value, YIN_SUBELEM_FIRST}}; - - ly_in_new_memory(data, &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - lyxml_ctx_next(YCTX->xmlctx); - - ret = yin_parse_content(YCTX, subelems3, 2, NULL, LY_STMT_STATUS, NULL, &exts); - assert_int_equal(ret, LY_EVALID); - CHECK_LOG_CTX("Sub-element \"text\" of \"status\" element must be defined as it's first sub-element.", NULL, 1); - lysdict_remove(UTEST_LYCTX, prefix_value); - RESET_STATE; - - /* test mandatory subelem */ - data = ELEMENT_WRAPPER_START ELEMENT_WRAPPER_END; - struct yin_subelement subelems4[1] = {{LY_STMT_PREFIX, &prefix_value, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE}}; - - ly_in_new_memory(data, &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - lyxml_ctx_next(YCTX->xmlctx); - - ret = yin_parse_content(YCTX, subelems4, 1, NULL, LY_STMT_STATUS, NULL, &exts); - assert_int_equal(ret, LY_EVALID); - CHECK_LOG_CTX("Missing mandatory sub-element \"prefix\" of \"status\" element.", NULL, 1); + const char *yin_data; + + yin_data = + "" + " " + " " + " " + " " + " First text" + " Second text (invalid duplication)" + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Redefinition of \"text\" sub-element in \"description\" element.", NULL, 1); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " Desc" + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid order of module's sub-elements \"description\" can't appear after \"extension\".", NULL, 1); + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"test\" failed.", NULL, 0); + CHECK_LOG_CTX("Missing mandatory sub-element \"text\" of \"description\" element.", NULL, 1); + } static void test_validate_value(void **state) { - const char *data = ELEMENT_WRAPPER_START ELEMENT_WRAPPER_END; - - /* create some XML context */ - ly_in_new_memory(data, &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - YCTX->xmlctx->status = LYXML_ELEM_CONTENT; - YCTX->xmlctx->dynamic = 0; + char buffer[512]; + const char *yin_ident = + "" + " " + " " + " " + ""; + const char *yin_str_empty = + "" + " " + " " + " " + " " + ""; + const char *yin_pref = + "" + " " + " " + " " + " " + " " + " " + " " + ""; - YCTX->xmlctx->value = "#invalid"; - YCTX->xmlctx->value_len = 8; - assert_int_equal(yin_validate_value(YCTX, Y_IDENTIF_ARG), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_ident, "#invalid"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); CHECK_LOG_CTX("Invalid identifier first character '#' (0x0023).", NULL, 1); - YCTX->xmlctx->value = ""; - YCTX->xmlctx->value_len = 0; - assert_int_equal(yin_validate_value(YCTX, Y_STR_ARG), LY_SUCCESS); - - YCTX->xmlctx->value = "pre:b"; - YCTX->xmlctx->value_len = 5; - assert_int_equal(yin_validate_value(YCTX, Y_IDENTIF_ARG), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_ident, "pre:b"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); CHECK_LOG_CTX("Invalid identifier character ':' (0x003a).", NULL, 1); - assert_int_equal(yin_validate_value(YCTX, Y_PREF_IDENTIF_ARG), LY_SUCCESS); - YCTX->xmlctx->value = "pre:pre:b"; - YCTX->xmlctx->value_len = 9; - assert_int_equal(yin_validate_value(YCTX, Y_PREF_IDENTIF_ARG), LY_EVALID); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_str_empty, LYS_IN_YIN, NULL)); + + snprintf(buffer, sizeof(buffer), yin_pref, "pre:pre:b"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"t3\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid identifier character ':' (0x003a).", NULL, 1); + + snprintf(buffer, sizeof(buffer), yin_pref, "pre:b"); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); } static void @@ -1167,186 +930,142 @@ test_print_submodule(void **state) ly_out_free(out, NULL, 1); } -/* helper function to simplify unit test of each element using parse_content function */ -LY_ERR -test_element_helper(void **state, const char *data, void *dest, const char **text, struct lysp_ext_instance **exts) -{ - const char *name, *prefix; - size_t name_len, prefix_len; - LY_ERR ret = LY_SUCCESS; - struct yin_subelement subelems[71] = { - {LY_STMT_ACTION, dest, 0}, - {LY_STMT_ANYDATA, dest, 0}, - {LY_STMT_ANYXML, dest, 0}, - {LY_STMT_ARGUMENT, dest, 0}, - {LY_STMT_AUGMENT, dest, 0}, - {LY_STMT_BASE, dest, 0}, - {LY_STMT_BELONGS_TO, dest, 0}, - {LY_STMT_BIT, dest, 0}, - {LY_STMT_CASE, dest, 0}, - {LY_STMT_CHOICE, dest, 0}, - {LY_STMT_CONFIG, dest, 0}, - {LY_STMT_CONTACT, dest, 0}, - {LY_STMT_CONTAINER, dest, 0}, - {LY_STMT_DEFAULT, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_DESCRIPTION, dest, 0}, - {LY_STMT_DEVIATE, dest, 0}, - {LY_STMT_DEVIATION, dest, 0}, - {LY_STMT_ENUM, dest, 0}, - {LY_STMT_ERROR_APP_TAG, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_ERROR_MESSAGE, dest, 0}, - {LY_STMT_EXTENSION, dest, 0}, - {LY_STMT_FEATURE, dest, 0}, - {LY_STMT_FRACTION_DIGITS, dest, 0}, - {LY_STMT_GROUPING, dest, 0}, - {LY_STMT_IDENTITY, dest, 0}, - {LY_STMT_IF_FEATURE, dest, 0}, - {LY_STMT_IMPORT, dest, 0}, - {LY_STMT_INCLUDE, dest, 0}, - {LY_STMT_INPUT, dest, 0}, - {LY_STMT_KEY, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_LEAF, dest, 0}, - {LY_STMT_LEAF_LIST, dest, 0}, - {LY_STMT_LENGTH, dest, 0}, - {LY_STMT_LIST, dest, 0}, - {LY_STMT_MANDATORY, dest, 0}, - {LY_STMT_MAX_ELEMENTS, dest, 0}, - {LY_STMT_MIN_ELEMENTS, dest, 0}, - {LY_STMT_MODIFIER, dest, 0}, - {LY_STMT_MODULE, dest, 0}, - {LY_STMT_MUST, dest, 0}, - {LY_STMT_NAMESPACE, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_NOTIFICATION, dest, 0}, - {LY_STMT_ORDERED_BY, dest, 0}, - {LY_STMT_ORGANIZATION, dest, 0}, - {LY_STMT_OUTPUT, dest, 0}, - {LY_STMT_PATH, dest, 0}, - {LY_STMT_PATTERN, dest, 0}, - {LY_STMT_POSITION, dest, 0}, - {LY_STMT_PREFIX, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_PRESENCE, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_RANGE, dest, 0}, - {LY_STMT_REFERENCE, dest, 0}, - {LY_STMT_REFINE, dest, 0}, - {LY_STMT_REQUIRE_INSTANCE, dest, 0}, - {LY_STMT_REVISION, dest, 0}, - {LY_STMT_REVISION_DATE, dest, 0}, - {LY_STMT_RPC, dest, 0}, - {LY_STMT_STATUS, dest, 0}, - {LY_STMT_SUBMODULE, dest, 0}, - {LY_STMT_TYPE, dest, 0}, - {LY_STMT_TYPEDEF, dest, 0}, - {LY_STMT_UNIQUE, dest, 0}, - {LY_STMT_UNITS, dest, YIN_SUBELEM_UNIQUE}, - {LY_STMT_USES, dest, 0}, - {LY_STMT_VALUE, dest, 0}, - {LY_STMT_WHEN, dest, 0}, - {LY_STMT_YANG_VERSION, dest, 0}, - {LY_STMT_YIN_ELEMENT, dest, 0}, - {LY_STMT_EXTENSION_INSTANCE, dest, 0}, - {LY_STMT_ARG_TEXT, dest, 0}, - {LY_STMT_ARG_VALUE, dest, 0} - }; - - YCTX->main_ctx = (struct lysp_ctx *)YCTX; - ly_in_new_memory(data, &UTEST_IN); - lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx); - prefix = YCTX->xmlctx->prefix; - prefix_len = YCTX->xmlctx->prefix_len; - name = YCTX->xmlctx->name; - name_len = YCTX->xmlctx->name_len; - lyxml_ctx_next(YCTX->xmlctx); - - ret = yin_parse_content(YCTX, subelems, 71, NULL, - yin_match_keyword(YCTX, name, name_len, prefix, prefix_len, LY_STMT_NONE), text, exts); - - /* free parser and input */ - lyxml_ctx_free(YCTX->xmlctx); - YCTX->xmlctx = NULL; - ly_in_free(UTEST_IN, 0); - UTEST_IN = NULL; - return ret; -} - -#define EXT_SUBELEM "" +#define EXT_SUBELEM "" static void test_enum_elem(void **state) { - struct lysp_type type = {0}; - const char *data; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " desc...\n" - " ref...\n" - " " EXT_SUBELEM "\n" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; uint16_t flags = LYS_STATUS_DEPRC | LYS_SET_VALUE; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc..." + " ref..." + EXT_SUBELEM + " " + " " + " " + " " + " " + " " + ""; - CHECK_LYSP_TYPE_ENUM(type.enums, "desc...", 1, flags, 1, "enum-name", "ref...", 55); - assert_string_equal(type.enums->iffeatures[0].str, "feature"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(type.enums->exts, LY_STMT_ENUM); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof type); - - data = ELEMENT_WRAPPER_START - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - assert_string_equal(type.enums->name, "enum-name"); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof type); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_non_null(mod); + assert_non_null(mod->parsed); + assert_non_null(mod->parsed->data); + assert_int_equal(LYS_LEAF, mod->parsed->data->nodetype); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + CHECK_LYSP_TYPE_ENUM(type->enums, "desc...", 1, flags, 1, "enum-name", "ref...", 55); + assert_string_equal(type->enums->iffeatures[0].str, "feature"); + TEST_1_CHECK_LYSP_EXT_INSTANCE(type->enums->exts, LY_STMT_ENUM, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + assert_string_equal(leaf->type.enums[0].name, "enum-name"); } static void test_bit_elem(void **state) { - struct lysp_type type = {0}; - const char *data; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " desc...\n" - " ref...\n" - EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; uint16_t flags = LYS_STATUS_DEPRC | LYS_SET_VALUE; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc..." + " ref..." + EXT_SUBELEM + " " + " " + " " + " " + " " + " " + ""; - CHECK_LYSP_TYPE_ENUM(type.bits, "desc...", 1, flags, 1, "bit-name", "ref...", 55); - assert_string_equal(type.bits->iffeatures[0].str, "feature"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(type.bits->exts, LY_STMT_BIT); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof type); - - data = ELEMENT_WRAPPER_START - " " - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_TYPE_ENUM(type.bits, NULL, 0, 0, 0, "bit-name", NULL, 0); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof type); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_non_null(mod); + assert_non_null(mod->parsed); + assert_non_null(mod->parsed->data); + assert_int_equal(LYS_LEAF, mod->parsed->data->nodetype); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + CHECK_LYSP_TYPE_ENUM(type->bits, "desc...", 1, flags, 1, "bit-name", "ref...", 55); + assert_string_equal(type->bits->iffeatures[0].str, "feature"); + TEST_1_CHECK_LYSP_EXT_INSTANCE(type->bits->exts, LY_STMT_BIT, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + CHECK_LYSP_TYPE_ENUM(leaf->type.bits, NULL, 0, 0, 0, "bit-name", NULL, 0); } static void test_status_elem(void **state) { - const char *data; - uint16_t flags = 0; + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; - /* test invalid value */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + CHECK_LOG_CTX("Parsing module \"t-status\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"status\" element. " "Valid values are \"current\", \"deprecated\" and \"obsolete\".", NULL, 1); } @@ -1354,11 +1073,20 @@ test_status_elem(void **state) static void test_yin_element_elem(void **state) { - const char *data; - uint16_t flags = 0; + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + CHECK_LOG_CTX("Parsing module \"t-yin-elem\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"yin-element\" element. " "Valid values are \"true\" and \"false\".", NULL, 1); } @@ -1366,61 +1094,91 @@ test_yin_element_elem(void **state) static void test_yangversion_elem(void **state) { - const char *data; - uint8_t version = 0; - - /* invalid value */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &version, NULL, NULL), LY_EVALID); - CHECK_LOG_CTX("Invalid value \"version\" of \"value\" attribute in \"yang-version\" element. " - "Valid values are \"1\" and \"1.1\".", NULL, 1); + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + CHECK_LOG_CTX("Parsing module \"t-ver\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"yang-version\" element. Valid values are \"1\" and \"1.1\".", NULL, 1); } static void test_argument_elem(void **state) { - const char *data; - uint16_t flags = 0; - const char *arg; - struct yin_argument_meta arg_meta = {&flags, &arg}; + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; - /* min subelems */ - data = ELEMENT_WRAPPER_START - "" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &arg_meta, NULL, NULL), LY_SUCCESS); - assert_string_equal(arg, "arg"); - assert_true(flags == 0); - lysdict_remove(UTEST_LYCTX, arg); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_string_equal(mod->parsed->extensions->argname, "arg"); + assert_true(mod->parsed->extensions->flags == 0); } static void test_belongsto_elem(void **state) { - const char *data; - struct lysp_submodule submod; - - lysdict_insert(UTEST_LYCTX, "module-name", 0, &PARSER_CUR_PMOD(YCTX)->mod->name); + struct lys_module *mod = NULL; + const char *parent_yin = + "" + " " + " " + " " + ""; + char *submod_in = + "" + " " + " " + " " + ""; + char *submod_fail = + "" + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &submod, NULL, NULL), LY_EVALID); + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, submod_fail); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, parent_yin, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"parent\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"sub\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory sub-element \"prefix\" of \"belongs-to\" element.", NULL, 1); + + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, submod_in); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, parent_yin, LYS_IN_YIN, &mod)); } static void test_config_elem(void **state) { - const char *data; - uint16_t flags = 0; + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + char buffer[256]; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_SUCCESS); - assert_true(flags & LYS_CONFIG_R); - flags = 0; + snprintf(buffer, sizeof(buffer), yin_data, "false"); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, &mod)); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "invalid"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, &mod)); + CHECK_LOG_CTX("Parsing module \"config\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"config\" element. " "Valid values are \"true\" and \"false\".", NULL, 1); } @@ -1428,309 +1186,506 @@ test_config_elem(void **state) static void test_default_elem(void **state) { - const char *data; - struct lysp_qname val = {0}; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"def\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute value of default element.", NULL, 1); } static void test_err_app_tag_elem(void **state) { - const char *data; - const char *val = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"err-app-tag\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute value of error-app-tag element.", NULL, 1); } static void test_err_msg_elem(void **state) { - const char *data; - const char *val = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"err-msg\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory sub-element \"value\" of \"error-message\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + yin_data = "" + " " + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"err-msg\" failed.", NULL, 0); CHECK_LOG_CTX("Unexpected attribute \"invalid\" of \"error-message\" element.", NULL, 1); } static void test_fracdigits_elem(void **state) { - const char *data; - struct lysp_type type = {0}; + char buffer[256]; + const char *yin_data = + "" + " " + " " + " " + ""; /* invalid values */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "-1"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"frac-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-1\" of \"value\" attribute in \"fraction-digits\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "02"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"frac-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"02\" of \"value\" attribute in \"fraction-digits\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "1p"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"frac-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"1p\" of \"value\" attribute in \"fraction-digits\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "19"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"frac-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"19\" of \"value\" attribute in \"fraction-digits\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + snprintf(buffer, sizeof(buffer), yin_data, "999999999999999999"); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, buffer, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"frac-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"999999999999999999\" of \"value\" attribute in \"fraction-digits\" element.", NULL, 1); + } static void test_iffeature_elem(void **state) { - const char *data; - const char **iffeatures = NULL; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &iffeatures, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"feat\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute name of if-feature element.", NULL, 1); - LY_ARRAY_FREE(iffeatures); - iffeatures = NULL; } static void test_length_elem(void **state) { - const char *data; - struct lysp_type type = {0}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " err-msg\n" - " \n" - " desc\n" - " ref\n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " err-msg" + " " + " desc" + " ref" EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_RESTR(type.length, "length-str", "desc", - "err-app-tag", "err-msg", 1, "ref"); - assert_true(type.flags & LYS_SET_LENGTH); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.length->exts[0]), LY_STMT_LENGTH); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + + CHECK_LYSP_RESTR(type->length, "1..10", "desc", "err-app-tag", "err-msg", 1, "ref"); + assert_true(type->flags & LYS_SET_LENGTH); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type->length->exts[0]), LY_STMT_LENGTH, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START - "" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_RESTR(type.length, "length-str", NULL, - NULL, NULL, 0, NULL); - lysp_type_free(UTEST_LYCTX, &type); - assert_true(type.flags & LYS_SET_LENGTH); - memset(&type, 0, sizeof(type)); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + + CHECK_LYSP_RESTR(type->length, "1..10", NULL, NULL, NULL, 0, NULL); + assert_true(type->flags & LYS_SET_LENGTH); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"len-fail\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute value of length element.", NULL, 1); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); } static void test_modifier_elem(void **state) { - const char *data; - const char *pat; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; - assert_int_equal(LY_SUCCESS, lysdict_insert(UTEST_LYCTX, "\006pattern", 8, &pat)); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &pat, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"modif\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invert\" of \"value\" attribute in \"modifier\" element. " "Only valid value is \"invert-match\".", NULL, 1); - lysdict_remove(UTEST_LYCTX, pat); } static void test_namespace_elem(void **state) { - const char *data; - const char *ns; + const char *yin_data = + "" + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &ns, NULL, NULL), LY_EVALID); + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"ns\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute uri of namespace element.", NULL, 1); } static void test_pattern_elem(void **state) { - const char *data; - struct lysp_type type = {0}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " err-msg-value\n" - " \n" - " "pattern-desc"\n" - " pattern-ref\n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " err-msg-value" + " " + " "pattern-desc"" + " pattern-ref" EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - assert_true(type.flags & LYS_SET_PATTERN); - CHECK_LYSP_RESTR(type.patterns, "\x015super_pattern", "\"pattern-desc\"", + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + assert_true(type->flags & LYS_SET_PATTERN); + CHECK_LYSP_RESTR(type->patterns, "\x015super_pattern", "\"pattern-desc\"", "err-app-tag-value", "err-msg-value", 1, "pattern-ref"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.patterns->exts[0]), LY_STMT_PATTERN); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type->patterns->exts[0]), LY_STMT_PATTERN, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START " " ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_RESTR(type.patterns, "\x006pattern", NULL, NULL, NULL, 0, NULL); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + CHECK_LYSP_RESTR(type->patterns, "\x006pattern", NULL, NULL, NULL, 0, NULL); } static void test_value_position_elem(void **state) { - const char *data; - struct lysp_type_enum en = {0}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; /* valid values */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_TYPE_ENUM(&(en), NULL, 0, LYS_SET_VALUE, 0, NULL, NULL, -55); - memset(&en, 0, sizeof(en)); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_TYPE_ENUM(&(en), NULL, 0, LYS_SET_VALUE, 0, NULL, NULL, 0); - memset(&en, 0, sizeof(en)); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_TYPE_ENUM(&(en), NULL, 0, LYS_SET_VALUE, 0, NULL, NULL, 0); - memset(&en, 0, sizeof(en)); + yin_data = "" + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + CHECK_LYSP_TYPE_ENUM(&(leaf->type.enums[0]), NULL, 0, LYS_SET_VALUE, 0, "e", NULL, -55); + + yin_data = "" + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + CHECK_LYSP_TYPE_ENUM(&(leaf->type.enums[0]), NULL, 0, LYS_SET_VALUE, 0, "e", NULL, 0); + + yin_data = "" + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + CHECK_LYSP_TYPE_ENUM(&(leaf->type.enums[0]), NULL, 0, LYS_SET_VALUE, 0, "e", NULL, 0); /* valid positions */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_TYPE_ENUM(&(en), NULL, 0, LYS_SET_VALUE, 0, NULL, NULL, 0); - memset(&en, 0, sizeof(en)); + yin_data = "" + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + CHECK_LYSP_TYPE_ENUM(&(leaf->type.bits[0]), NULL, 0, LYS_SET_VALUE, 0, "b", NULL, 0); /* invalid values */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"99999999999999999999999\" of \"value\" attribute in \"value\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"1k\" of \"value\" attribute in \"value\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"\" of \"value\" attribute in \"value\" element.", NULL, 1); /*invalid positions */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-5\" of \"value\" attribute in \"position\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-0\" of \"value\" attribute in \"position\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"99999999999999999999\" of \"value\" attribute in \"position\" element.", NULL, 1); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"vp5\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"\" of \"value\" attribute in \"position\" element.", NULL, 1); } static void test_prefix_elem(void **state) { - const char *data; - const char *value = NULL; + struct lys_module *mod = NULL; + const char *yin_data = + "" + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &value, NULL, NULL), LY_SUCCESS); - assert_string_equal(value, "pref"); - lysdict_remove(UTEST_LYCTX, value); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_string_equal(mod->prefix, "pref"); } static void test_range_elem(void **state) { - const char *data; - struct lysp_type type = {0}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " err-msg\n" - " \n" - " desc\n" - " ref\n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " err-msg" + " " + " desc" + " ref" EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_RESTR(type.range, "range-str", "desc", + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + assert_true(type->flags & LYS_SET_RANGE); + CHECK_LYSP_RESTR(type->range, "1..10", "desc", "err-app-tag", "err-msg", 1, "ref"); - assert_true(type.flags & LYS_SET_RANGE); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.range->exts[0]), LY_STMT_RANGE); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type->range->exts[0]), LY_STMT_RANGE, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_RESTR(type.range, "range-str", NULL, - NULL, NULL, 0, NULL); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + CHECK_LYSP_RESTR(type->range, "1..10", NULL, NULL, NULL, 0, NULL); } static void test_reqinstance_elem(void **state) { - const char *data; - struct lysp_type type = {0}; - - data = ELEMENT_WRAPPER_START "" EXT_SUBELEM "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - assert_int_equal(type.require_instance, 1); - assert_true(type.flags & LYS_SET_REQINST); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LY_STMT_REQUIRE_INSTANCE); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - assert_int_equal(type.require_instance, 0); - assert_true(type.flags & LYS_SET_REQINST); - memset(&type, 0, sizeof(type)); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_EVALID); - memset(&type, 0, sizeof(type)); + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + struct lysp_type *type; + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + EXT_SUBELEM + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + assert_int_equal(type->require_instance, 1); + assert_true(type->flags & LYS_SET_REQINST); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type->exts[0]), LY_STMT_REQUIRE_INSTANCE, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + type = &leaf->type; + assert_int_equal(type->require_instance, 0); + assert_true(type->flags & LYS_SET_REQINST); + + /* invalid */ + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"req-mod3\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"require-instance\" element. " "Valid values are \"true\" and \"false\".", NULL, 1); } @@ -1738,189 +1693,247 @@ test_reqinstance_elem(void **state) static void test_revision_date_elem(void **state) { - const char *data; - char rev[LY_REV_SIZE]; + const char *yin_data; + struct lys_module *mod = NULL; + struct lys_module *dummy = NULL; + + const char *dummy_mod = + "" + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, rev, NULL, NULL), LY_SUCCESS); - assert_string_equal(rev, "2000-01-01"); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, dummy_mod, LYS_IN_YIN, &dummy)); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, rev, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_string_equal(mod->parsed->imports[0].rev, "2000-01-01"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"rev-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"2000-50-05\" of \"revision-date\".", NULL, 1); } static void test_unique_elem(void **state) { - const char *data; - const char **values = NULL; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &values, NULL, NULL), LY_SUCCESS); - assert_string_equal(*values, "tag"); - lysdict_remove(UTEST_LYCTX, *values); - LY_ARRAY_FREE(values); - values = NULL; + struct lys_module *mod = NULL; + struct lysp_node_list *list; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + list = (struct lysp_node_list *)mod->parsed->data; + assert_string_equal(list->uniques[0].str, "tag"); } static void test_units_elem(void **state) { - const char *data; - const char *values = NULL; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &values, NULL, NULL), LY_SUCCESS); - assert_string_equal(values, "name"); - lysdict_remove(UTEST_LYCTX, values); - values = NULL; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; + const char *yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + assert_string_equal(leaf->units, "name"); } static void test_yin_text_value_elem(void **state) { - const char *data; - const char *val; - - data = ELEMENT_WRAPPER_START "text" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_SUCCESS); - assert_string_equal(val, "text"); - lysdict_remove(UTEST_LYCTX, val); - - data = " text "; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_SUCCESS); - assert_string_equal(val, "text"); - lysdict_remove(UTEST_LYCTX, val); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_SUCCESS); - assert_string_equal("", val); - lysdict_remove(UTEST_LYCTX, val); -} + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_leaf *leaf; -static void -test_type_elem(void **state) -{ - const char *data; - struct lysp_type type = {0}; + yin_data = + "" + " " + " " + " text" + ""; - /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - assert_string_equal(type.name, "type-name"); - assert_string_equal(*type.bases, "base-name"); - assert_string_equal(type.bits->name, "bit"); - assert_string_equal(type.enums->name, "enum"); - assert_int_equal(type.fraction_digits, 2); - CHECK_LYSP_RESTR(type.length, "length", NULL, - NULL, NULL, 0, NULL); - assert_string_equal(type.path->expr, "/path"); - CHECK_LYSP_RESTR(type.patterns, "\006pattern", NULL, - NULL, NULL, 0, NULL); - CHECK_LYSP_RESTR(type.range, "range", NULL, - NULL, NULL, 0, NULL); - assert_int_equal(type.require_instance, 1); - assert_string_equal(type.types->name, "sub-type-name"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LY_STMT_TYPE); - assert_true(type.flags & LYS_SET_BASE); - assert_true(type.flags & LYS_SET_BIT); - assert_true(type.flags & LYS_SET_ENUM); - assert_true(type.flags & LYS_SET_FRDIGITS); - assert_true(type.flags & LYS_SET_LENGTH); - assert_true(type.flags & LYS_SET_PATH); - assert_true(type.flags & LYS_SET_PATTERN); - assert_true(type.flags & LYS_SET_RANGE); - assert_true(type.flags & LYS_SET_REQINST); - assert_true(type.flags & LYS_SET_TYPE); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_string_equal(mod->dsc, "text"); + + yin_data = + "" + " " + " " + " " + " " + " " + " text" + " " + " " + ""; - /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS); - lysp_type_free(UTEST_LYCTX, &type); - memset(&type, 0, sizeof(type)); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + leaf = (struct lysp_node_leaf *)mod->parsed->data; + assert_string_equal(leaf->musts->emsg, "text"); + + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_string_equal(mod->dsc, ""); } static void test_max_elems_elem(void **state) { - const char *data; - struct lysp_node_list list = {0}; - struct lysp_refine refine = {0}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_uses *uses; + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; - data = " "; - assert_int_equal(test_element_helper(state, data, &refine, NULL, NULL), LY_SUCCESS); - assert_int_equal(refine.max, 10); - assert_true(refine.flags & LYS_SET_MAX); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + uses = (struct lysp_node_uses *)mod->parsed->data; + assert_int_equal(uses->refines->max, 10); + assert_true(uses->refines->flags & LYS_SET_MAX); - data = " "; - assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"max-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"0\" of \"value\" attribute in \"max-elements\" element.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"max-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"-10\" of \"value\" attribute in \"max-elements\" element.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"max-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"k\" of \"value\" attribute in \"max-elements\" element.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"max-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"u12\" of \"value\" attribute in \"max-elements\" element.", NULL, 1); } static void test_min_elems_elem(void **state) { - const char *data; - struct lysp_node_leaflist llist = {0}; + const char *yin_data; - data = " "; - assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"min-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Value \"-5\" of \"value\" attribute in \"min-elements\" element is out of bounds.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"min-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Value \"99999999999999999\" of \"value\" attribute in \"min-elements\" element is out of bounds.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"min-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"5k\" of \"value\" attribute in \"min-elements\" element.", NULL, 1); - data = " "; - assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_EVALID); + yin_data = "" + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"min-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"05\" of \"value\" attribute in \"min-elements\" element.", NULL, 1); } static void test_ordby_elem(void **state) { - const char *data; - uint16_t flags = 0; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_SUCCESS); - assert_true(flags & LYS_ORDBY_USER); + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_list *list; + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &flags, NULL, NULL), LY_EVALID); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + list = (struct lysp_node_list *)mod->parsed->data; + assert_true(list->flags & LYS_ORDBY_USER); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"ord-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"inv\" of \"value\" attribute in \"ordered-by\" element. " "Valid values are \"system\" and \"user\".", NULL, 1); } @@ -1928,390 +1941,503 @@ test_ordby_elem(void **state) static void test_any_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {.parent = NULL, .nodes = &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_anydata *parsed = NULL; - uint16_t flags; + uint16_t flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_DEPRC; /* anyxml max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " ref" + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_anydata *)siblings; - flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_DEPRC; + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_anydata *)mod->parsed->data; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "any-name", 0, LYS_ANYXML, 0, "ref", 1); + "any-name", 0, LYS_ANYXML, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_ANYXML); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_ANYXML, "MY_MTU"); /* anydata max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " ref" + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_anydata *)siblings; - flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_DEPRC; + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_anydata *)mod->parsed->data; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "any-name", 0, LYS_ANYDATA, 0, "ref", 1); + "any-name", 0, LYS_ANYDATA, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_ANYDATA); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_ANYDATA, "MY_MTU"); /* min subelems */ - node_meta.parent = (void *)0x10; - data = ELEMENT_WRAPPER_START " " ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_anydata *)siblings; - assert_ptr_equal(parsed->parent, node_meta.parent); + yin_data = + "" + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_anydata *)mod->parsed->data; CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, - "any-name", 0, LYS_ANYDATA, 1, NULL, 0); - lysp_node_free(UTEST_LYCTX, siblings); + "any-name", 0, LYS_ANYDATA, 0, NULL); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 0); } static void test_leaf_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {.parent = NULL, .nodes = &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_leaf *parsed = NULL; uint16_t flags; /* max elements */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " ref" + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaf *)siblings; + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaf *)mod->parsed->data; flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_DEPRC; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "leaf", 0, LYS_LEAF, 0, "ref", 1); + "leaf1", 1, LYS_LEAF, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF, "MY_MTU"); assert_string_equal(parsed->musts->arg.str, "must-cond"); - assert_string_equal(parsed->type.name, "type"); + assert_string_equal(parsed->type.name, "string"); assert_string_equal(parsed->units, "uni"); + + parsed = (struct lysp_node_leaf *)parsed->next; + assert_string_equal(parsed->name, "leaf2"); assert_string_equal(parsed->dflt.str, "def-val"); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; /* min elements */ - data = ELEMENT_WRAPPER_START " " ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaf *)siblings; + yin_data = "" + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaf *)mod->parsed->data; assert_string_equal(parsed->name, "leaf"); - assert_string_equal(parsed->type.name, "type"); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + assert_string_equal(parsed->type.name, "string"); } static void test_leaf_list_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {.parent = NULL, .nodes = &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_leaflist *parsed = NULL; uint16_t flags; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " ref" + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaflist *)siblings; + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaflist *)mod->parsed->data; flags = LYS_CONFIG_W | LYS_ORDBY_USER | LYS_STATUS_CURR | LYS_SET_MAX; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "llist", 0, LYS_LEAFLIST, 0, "ref", 1); + "llist", 0, LYS_LEAFLIST, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_RESTR(parsed->musts, "must-cond", NULL, NULL, NULL, 0, NULL); assert_string_equal(parsed->dflts[0].str, "def-val0"); assert_string_equal(parsed->dflts[1].str, "def-val1"); assert_string_equal(parsed->iffeatures[0].str, "feature"); assert_int_equal(parsed->max, 5); - assert_string_equal(parsed->type.name, "type"); + assert_string_equal(parsed->type.name, "string"); assert_string_equal(parsed->units, "uni"); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF_LIST); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF_LIST, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " ref" + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaflist *)siblings; + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaflist *)mod->parsed->data; flags = LYS_CONFIG_W | LYS_ORDBY_USER | LYS_STATUS_CURR | LYS_SET_MIN; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "llist", 0, LYS_LEAFLIST, 0, "ref", 1); + "llist", 0, LYS_LEAFLIST, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_RESTR(parsed->musts, "must-cond", NULL, NULL, NULL, 0, NULL); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); assert_int_equal(parsed->min, 5); - assert_string_equal(parsed->type.name, "type"); + assert_string_equal(parsed->type.name, "string"); assert_string_equal(parsed->units, "uni"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF_LIST); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaflist *)siblings; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LEAF_LIST, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " ref" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaflist *)mod->parsed->data; flags = LYS_CONFIG_W | LYS_ORDBY_USER | LYS_STATUS_CURR | LYS_SET_MIN | LYS_SET_MAX; CHECK_LYSP_NODE(parsed, "desc", 0, flags, 1, - "llist", 0, LYS_LEAFLIST, 0, "ref", 1); + "llist", 0, LYS_LEAFLIST, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_RESTR(parsed->musts, "must-cond", NULL, NULL, NULL, 0, NULL); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); assert_int_equal(parsed->min, 5); assert_int_equal(parsed->max, 15); - assert_string_equal(parsed->type.name, "type"); + assert_string_equal(parsed->type.name, "string"); assert_string_equal(parsed->units, "uni"); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_leaflist *)siblings; + + yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_leaflist *)mod->parsed->data; assert_string_equal(parsed->name, "llist"); - assert_string_equal(parsed->type.name, "type"); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + assert_string_equal(parsed->type.name, "string"); /* invalid combinations */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " " - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"ll-inv\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid combination of min-elements and max-elements: min value 15 is bigger than the max value 5.", - NULL, 4); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_EVALID); - CHECK_LOG_CTX("Invalid combination of sub-elemnts \"min-elements\" and \"default\" in \"leaf-list\" element.", NULL, 5); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; - - data = ELEMENT_WRAPPER_START - "" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_EVALID); + NULL, 1); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"ll-inv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid combination of sub-elemnts \"min-elements\" and \"default\" in \"leaf-list\" element.", NULL, 1); + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"ll-inv\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory sub-element \"type\" of \"leaf-list\" element.", NULL, 1); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; } static void test_presence_elem(void **state) { - const char *data; - const char *val; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_SUCCESS); - assert_string_equal(val, "presence-val"); - lysdict_remove(UTEST_LYCTX, val); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_container *cont; + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + cont = (struct lysp_node_container *)mod->parsed->data; + assert_string_equal(cont->presence, "presence-val"); + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"pres-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute value of presence element.", NULL, 1); } static void test_key_elem(void **state) { - const char *data; - const char *val; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_SUCCESS); - assert_string_equal(val, "key-value"); - lysdict_remove(UTEST_LYCTX, val); - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &val, NULL, NULL), LY_EVALID); + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_list *list; + + yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + list = (struct lysp_node_list *)mod->parsed->data; + assert_string_equal(list->key, "key-value"); + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"key-mod2\" failed.", NULL, 0); CHECK_LOG_CTX("Missing mandatory attribute value of key element.", NULL, 1); } static void test_uses_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {NULL, &siblings}; - struct lysp_node_uses *parsed = NULL; + struct lys_module *mod; + struct lysp_node_uses *parsed; + const char *yin_data; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " desc\n" - " ref\n" - " \n" - " \n" - EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_uses *)&siblings[0]; - CHECK_LYSP_NODE(parsed, "desc", 1, LYS_STATUS_OBSLT, 1, - "uses-name", 0, LYS_USES, 0, "ref", 1); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " ref" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_uses *)mod->parsed->data; + CHECK_LYSP_NODE(parsed, "desc", 0, LYS_STATUS_OBSLT, 1, + "uses-name", 0, LYS_USES, 0, "ref"); CHECK_LYSP_WHEN(parsed->when, "cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "feature"); assert_string_equal(parsed->refines->nodeid, "target"); assert_string_equal(parsed->augments->nodeid, "target"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_USES); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - assert_string_equal(siblings[0].name, "uses-name"); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_uses *)mod->parsed->data; + assert_string_equal(parsed->name, "uses-name"); } static void test_list_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {NULL, &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_list *parsed = NULL; + uint16_t flags = LYS_ORDBY_USER | LYS_STATUS_DEPRC | LYS_CONFIG_W | LYS_SET_MIN; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " desc\n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " ref" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_list *)&siblings[0]; + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_list *)mod->parsed->data; + assert_string_equal(parsed->child->name, "anyd"); assert_int_equal(parsed->child->nodetype, LYS_ANYDATA); assert_string_equal(parsed->child->next->name, "anyx"); @@ -2326,13 +2452,16 @@ test_list_elem(void **state) assert_int_equal(parsed->child->next->next->next->next->next->nodetype, LYS_LEAFLIST); assert_string_equal(parsed->child->next->next->next->next->next->next->name, "sub-list"); assert_int_equal(parsed->child->next->next->next->next->next->next->nodetype, LYS_LIST); - assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "uses-name"); + assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "grp"); assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_USES); - assert_null(parsed->child->next->next->next->next->next->next->next->next); - uint16_t flags = LYS_ORDBY_USER | LYS_STATUS_DEPRC | LYS_CONFIG_W | LYS_SET_MIN; - - CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "list-name", 0, LYS_LIST, 0, "ref", 1); + assert_string_equal(parsed->child->next->next->next->next->next->next->next->next->name, "key"); + assert_int_equal(parsed->child->next->next->next->next->next->next->next->next->nodetype, LYS_LEAF); + assert_string_equal(parsed->child->next->next->next->next->next->next->next->next->next->name, "utag"); + assert_int_equal(parsed->child->next->next->next->next->next->next->next->next->next->nodetype, LYS_LEAF); + assert_null(parsed->child->next->next->next->next->next->next->next->next->next->next); + + CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, "list-name", 0, LYS_LIST, 0, "ref"); + CHECK_POINTER(parsed->when, 1); CHECK_LYSP_RESTR(parsed->musts, "must-cond", NULL, NULL, NULL, 0, NULL); CHECK_LYSP_WHEN(parsed->when, "when", NULL, 0, NULL); assert_string_equal(parsed->groupings->name, "grp"); @@ -2344,51 +2473,67 @@ test_list_elem(void **state) assert_int_equal(parsed->min, 10); assert_string_equal(parsed->typedefs->name, "tpdf"); assert_string_equal(parsed->uniques->str, "utag"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LIST); - lysp_node_free(UTEST_LYCTX, siblings); - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_LIST, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_list *)&siblings[0]; - CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, - "list-name", 0, LYS_LIST, 0, NULL, 0); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + yin_data = + "" + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_list *)mod->parsed->data; + CHECK_LYSP_NODE(parsed, NULL, 0, LYS_CONFIG_R, 0, "list-name", 0, LYS_LIST, 0, NULL); + CHECK_POINTER(parsed->when, 0); } static void test_notification_elem(void **state) { - const char *data; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_notif *notifs = NULL; - struct tree_node_meta notif_meta = {NULL, (struct lysp_node **)¬ifs}; /* max subelems */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " ref" + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, ¬if_meta, NULL, NULL), LY_SUCCESS); + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + notifs = mod->parsed->notifs; + assert_string_equal(notifs->name, "notif-name"); assert_string_equal(notifs->child->name, "anyd"); assert_int_equal(notifs->child->nodetype, LYS_ANYDATA); @@ -2416,47 +2561,61 @@ test_notification_elem(void **state) assert_null(notifs->parent); assert_string_equal(notifs->ref, "ref"); assert_string_equal(notifs->typedefs->name, "tpdf"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(notifs->exts[0]), LY_STMT_NOTIFICATION); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)notifs); - notifs = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(notifs->exts[0]), LY_STMT_NOTIFICATION, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, ¬if_meta, NULL, NULL), LY_SUCCESS); + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + notifs = mod->parsed->notifs; assert_string_equal(notifs->name, "notif-name"); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)notifs); - notifs = NULL; } static void test_grouping_elem(void **state) { - const char *data; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_grp *grps = NULL; - struct tree_node_meta grp_meta = {NULL, (struct lysp_node **)&grps}; /* max subelems */ - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " ref" + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &grp_meta, NULL, NULL), LY_SUCCESS); + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + grps = &mod->parsed->groupings[0]; + assert_string_equal(grps->name, "grp-name"); assert_string_equal(grps->child->name, "anyd"); assert_string_equal(grps->child->next->name, "anyx"); @@ -2478,66 +2637,83 @@ test_grouping_elem(void **state) assert_int_equal(grps->child->next->next->next->next->next->next->nodetype, LYS_CONTAINER); assert_string_equal(grps->child->next->next->next->next->next->next->next->name, "choice"); assert_int_equal(grps->child->next->next->next->next->next->next->next->nodetype, LYS_CHOICE); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(grps->exts[0]), LY_STMT_GROUPING); - lysp_node_free(UTEST_LYCTX, &grps->node); - grps = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(grps->exts[0]), LY_STMT_GROUPING, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &grp_meta, NULL, NULL), LY_SUCCESS); + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + grps = mod->parsed->groupings; assert_string_equal(grps->name, "grp-name"); - lysp_node_free(UTEST_LYCTX, &grps->node); - grps = NULL; } static void test_container_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {NULL, &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_container *parsed = NULL; + uint16_t flags = LYS_CONFIG_W | LYS_STATUS_CURR; /* max subelems */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " " + " " + " " + " ref" + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_container *)siblings; - uint16_t flags = LYS_CONFIG_W | LYS_STATUS_CURR; + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + parsed = (struct lysp_node_container *)mod->parsed->data; + while (parsed && strcmp(parsed->name, "cont-name") != 0) { + parsed = (struct lysp_node_container *)parsed->next; + } CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "cont-name", 0, LYS_CONTAINER, 0, "ref", 1); + "cont-name", 0, LYS_CONTAINER, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); CHECK_LYSP_RESTR(parsed->musts, "cond", NULL, NULL, NULL, 0, NULL); CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "iff"); assert_string_equal(parsed->presence, "presence"); assert_string_equal(parsed->typedefs->name, "tpdf"); - assert_string_equal(parsed->groupings->name, "sub-grp"); + assert_string_equal(parsed->groupings->name, "grp"); assert_string_equal(parsed->child->name, "anyd"); assert_int_equal(parsed->child->nodetype, LYS_ANYDATA); assert_string_equal(parsed->child->next->name, "anyx"); @@ -2550,63 +2726,83 @@ test_container_elem(void **state) assert_int_equal(parsed->child->next->next->next->next->nodetype, LYS_LEAFLIST); assert_string_equal(parsed->child->next->next->next->next->next->name, "list"); assert_int_equal(parsed->child->next->next->next->next->next->nodetype, LYS_LIST); - assert_string_equal(parsed->child->next->next->next->next->next->next->name, "uses-name"); + assert_string_equal(parsed->child->next->next->next->next->next->next->name, "grp"); assert_int_equal(parsed->child->next->next->next->next->next->next->nodetype, LYS_USES); assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "choice"); assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_CHOICE); assert_null(parsed->child->next->next->next->next->next->next->next->next); assert_string_equal(parsed->notifs->name, "notf"); assert_string_equal(parsed->actions->name, "act"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CONTAINER); - lysp_node_free(UTEST_LYCTX, siblings); - ly_set_erase(&YCTX->tpdfs_nodes, NULL); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CONTAINER, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_container *)siblings; + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_container *)mod->parsed->data; CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, - "cont-name", 0, LYS_CONTAINER, 0, NULL, 0); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + "cont-name", 0, LYS_CONTAINER, 0, NULL); + CHECK_POINTER(parsed->when, 0); } static void test_case_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {NULL, &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node *node = NULL; struct lysp_node_case *parsed = NULL; + uint16_t flags = LYS_STATUS_CURR; /* max subelems */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " ref" + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_case *)siblings; - uint16_t flags = LYS_STATUS_CURR; + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + node = mod->parsed->data; + while (node && strcmp(node->name, "ch") != 0) { + node = node->next; + } + parsed = (struct lysp_node_case *)((struct lysp_node_choice *)node)->child; CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "case-name", 0, LYS_CASE, 0, "ref", 1); - CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); + "case-name", 0, LYS_CASE, 1, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); + CHECK_LYSP_WHEN(parsed->when, "/c1:cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "iff"); assert_string_equal(parsed->child->name, "anyd"); assert_int_equal(parsed->child->nodetype, LYS_ANYDATA); @@ -2625,58 +2821,80 @@ test_case_elem(void **state) assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "choice"); assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_CHOICE); assert_null(parsed->child->next->next->next->next->next->next->next->next); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CASE); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CASE, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_case *)siblings; + yin_data = + "" + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_case *)((struct lysp_node_choice *)mod->parsed->data)->child; CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, - "case-name", 0, LYS_CASE, 0, NULL, 0); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + "case-name", 0, LYS_CASE, 1, NULL); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 0); } static void test_choice_elem(void **state) { - const char *data; - struct lysp_node *siblings = NULL; - struct tree_node_meta node_meta = {NULL, &siblings}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node *node = NULL; struct lysp_node_choice *parsed = NULL; + uint16_t flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_CURR; /* max subelems */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " ref" + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_choice *)siblings; - uint16_t flags = LYS_CONFIG_W | LYS_MAND_TRUE | LYS_STATUS_CURR; + " " + " " + " " + " " + " " + ""; - CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, - "choice-name", 0, LYS_CHOICE, 0, "ref", 1); - CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + node = mod->parsed->data; + while (node && strcmp(node->name, "choice-name") != 0) { + node = node->next; + } + parsed = (struct lysp_node_choice *)node; + + CHECK_LYSP_NODE(parsed, "desc", 1, flags, 1, "choice-name", 1, LYS_CHOICE, 0, "ref"); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 1); + CHECK_LYSP_WHEN(parsed->when, "/ch1:cond", NULL, 0, NULL); assert_string_equal(parsed->iffeatures[0].str, "iff"); assert_string_equal(parsed->child->name, "anyd"); assert_int_equal(parsed->child->nodetype, LYS_ANYDATA); @@ -2695,402 +2913,514 @@ test_choice_elem(void **state) assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "list"); assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_LIST); assert_null(parsed->child->next->next->next->next->next->next->next->next); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CHOICE); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_CHOICE, "MY_MTU"); + + parsed = (struct lysp_node_choice *)parsed->next; + assert_string_equal(parsed->name, "choice2"); + assert_string_equal(parsed->dflt.str, "sub-case"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &node_meta, NULL, NULL), LY_SUCCESS); - parsed = (struct lysp_node_choice *)siblings; + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + parsed = (struct lysp_node_choice *)mod->parsed->data; assert_string_equal(parsed->name, "choice-name"); - CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, - "choice-name", 0, LYS_CHOICE, 0, NULL, 0); - lysp_node_free(UTEST_LYCTX, siblings); - siblings = NULL; + CHECK_LYSP_NODE(parsed, NULL, 0, 0, 0, "choice-name", 0, LYS_CHOICE, 0, NULL); + CHECK_POINTER(((struct lysp_node_leaf *)parsed)->when, 0); } static void test_inout_elem(void **state) { - const char *data; - struct lysp_node_action_inout inout = {0}; - struct inout_meta inout_meta = {NULL, &inout}; + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_node_action *rpc = NULL; + struct lysp_node_action_inout *inout = NULL; /* max subelements */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &inout_meta, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_ACTION_INOUT(&(inout), 1, 1, 1, 1, LYS_INPUT, 0, 1); - CHECK_LYSP_RESTR(inout.musts, "cond", NULL, NULL, NULL, 0, NULL); - assert_string_equal(inout.typedefs->name, "tpdf"); - assert_string_equal(inout.groupings->name, "sub-grp"); - assert_string_equal(inout.child->name, "anyd"); - assert_int_equal(inout.child->nodetype, LYS_ANYDATA); - assert_string_equal(inout.child->next->name, "anyx"); - assert_int_equal(inout.child->next->nodetype, LYS_ANYXML); - assert_string_equal(inout.child->next->next->name, "choice"); - assert_int_equal(inout.child->next->next->nodetype, LYS_CHOICE); - assert_string_equal(inout.child->next->next->next->name, "subcont"); - assert_int_equal(inout.child->next->next->next->nodetype, LYS_CONTAINER); - assert_string_equal(inout.child->next->next->next->next->name, "leaf"); - assert_int_equal(inout.child->next->next->next->next->nodetype, LYS_LEAF); - assert_string_equal(inout.child->next->next->next->next->next->name, "llist"); - assert_int_equal(inout.child->next->next->next->next->next->nodetype, LYS_LEAFLIST); - assert_string_equal(inout.child->next->next->next->next->next->next->name, "list"); - assert_int_equal(inout.child->next->next->next->next->next->next->nodetype, LYS_LIST); - assert_string_equal(inout.child->next->next->next->next->next->next->next->name, "uses-name"); - assert_int_equal(inout.child->next->next->next->next->next->next->next->nodetype, LYS_USES); - assert_null(inout.child->next->next->next->next->next->next->next->next); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LY_STMT_INPUT); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout); - memset(&inout, 0, sizeof inout); + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + rpc = mod->parsed->rpcs; + inout = &rpc->input; + + CHECK_LYSP_ACTION_INOUT(inout, 1, 1, 1, 1, LYS_INPUT, 1, 1); + CHECK_LYSP_RESTR(inout->musts, "/io1:cond", NULL, NULL, NULL, 0, NULL); + assert_string_equal(inout->typedefs->name, "tpdf"); + assert_string_equal(inout->groupings->name, "sub-grp"); + assert_string_equal(inout->child->name, "anyd"); + assert_int_equal(inout->child->nodetype, LYS_ANYDATA); + assert_string_equal(inout->child->next->name, "anyx"); + assert_int_equal(inout->child->next->nodetype, LYS_ANYXML); + assert_string_equal(inout->child->next->next->name, "choice"); + assert_int_equal(inout->child->next->next->nodetype, LYS_CHOICE); + assert_string_equal(inout->child->next->next->next->name, "subcont"); + assert_int_equal(inout->child->next->next->next->nodetype, LYS_CONTAINER); + assert_string_equal(inout->child->next->next->next->next->name, "leaf"); + assert_int_equal(inout->child->next->next->next->next->nodetype, LYS_LEAF); + assert_string_equal(inout->child->next->next->next->next->next->name, "llist"); + assert_int_equal(inout->child->next->next->next->next->next->nodetype, LYS_LEAFLIST); + assert_string_equal(inout->child->next->next->next->next->next->next->name, "list"); + assert_int_equal(inout->child->next->next->next->next->next->next->nodetype, LYS_LIST); + assert_string_equal(inout->child->next->next->next->next->next->next->next->name, "uses-name"); + assert_int_equal(inout->child->next->next->next->next->next->next->next->nodetype, LYS_USES); + assert_null(inout->child->next->next->next->next->next->next->next->next); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout->exts[0]), LY_STMT_INPUT, "MY_MTU"); /* max subelements */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &inout_meta, NULL, NULL), LY_SUCCESS); - CHECK_LYSP_ACTION_INOUT(&(inout), 1, 1, 1, 1, LYS_OUTPUT, 0, 1); - assert_string_equal(inout.musts->arg.str, "cond"); - assert_string_equal(inout.typedefs->name, "tpdf"); - assert_string_equal(inout.groupings->name, "sub-grp"); - assert_string_equal(inout.child->name, "anyd"); - assert_int_equal(inout.child->nodetype, LYS_ANYDATA); - assert_string_equal(inout.child->next->name, "anyx"); - assert_int_equal(inout.child->next->nodetype, LYS_ANYXML); - assert_string_equal(inout.child->next->next->name, "choice"); - assert_int_equal(inout.child->next->next->nodetype, LYS_CHOICE); - assert_string_equal(inout.child->next->next->next->name, "subcont"); - assert_int_equal(inout.child->next->next->next->nodetype, LYS_CONTAINER); - assert_string_equal(inout.child->next->next->next->next->name, "leaf"); - assert_int_equal(inout.child->next->next->next->next->nodetype, LYS_LEAF); - assert_string_equal(inout.child->next->next->next->next->next->name, "llist"); - assert_int_equal(inout.child->next->next->next->next->next->nodetype, LYS_LEAFLIST); - assert_string_equal(inout.child->next->next->next->next->next->next->name, "list"); - assert_int_equal(inout.child->next->next->next->next->next->next->nodetype, LYS_LIST); - assert_string_equal(inout.child->next->next->next->next->next->next->next->name, "uses-name"); - assert_int_equal(inout.child->next->next->next->next->next->next->next->nodetype, LYS_USES); - assert_null(inout.child->next->next->next->next->next->next->next->next); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LY_STMT_OUTPUT); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout); - memset(&inout, 0, sizeof inout); + " " + " " + ""; - /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &inout_meta, NULL, NULL), LY_SUCCESS); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout); - memset(&inout, 0, sizeof inout); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + rpc = mod->parsed->rpcs; + inout = &rpc->output; + + CHECK_LYSP_ACTION_INOUT(inout, 1, 1, 1, 1, LYS_OUTPUT, 1, 1); + assert_string_equal(inout->musts->arg.str, "/io2:cond"); + assert_string_equal(inout->typedefs->name, "tpdf"); + assert_string_equal(inout->groupings->name, "sub-grp"); + assert_string_equal(inout->child->name, "anyd"); + assert_int_equal(inout->child->nodetype, LYS_ANYDATA); + assert_string_equal(inout->child->next->name, "anyx"); + assert_int_equal(inout->child->next->nodetype, LYS_ANYXML); + assert_string_equal(inout->child->next->next->name, "choice"); + assert_int_equal(inout->child->next->next->nodetype, LYS_CHOICE); + assert_string_equal(inout->child->next->next->next->name, "subcont"); + assert_int_equal(inout->child->next->next->next->nodetype, LYS_CONTAINER); + assert_string_equal(inout->child->next->next->next->next->name, "leaf"); + assert_int_equal(inout->child->next->next->next->next->nodetype, LYS_LEAF); + assert_string_equal(inout->child->next->next->next->next->next->name, "llist"); + assert_int_equal(inout->child->next->next->next->next->next->nodetype, LYS_LEAFLIST); + assert_string_equal(inout->child->next->next->next->next->next->next->name, "list"); + assert_int_equal(inout->child->next->next->next->next->next->next->nodetype, LYS_LIST); + assert_string_equal(inout->child->next->next->next->next->next->next->next->name, "uses-name"); + assert_int_equal(inout->child->next->next->next->next->next->next->next->nodetype, LYS_USES); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout->exts[0]), LY_STMT_OUTPUT, "MY_MTU"); - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &inout_meta, NULL, NULL), LY_SUCCESS); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout); - memset(&inout, 0, sizeof inout); + /* min subelems */ + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); /* invalid combinations */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &inout_meta, NULL, NULL), LY_EVALID); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout); + yin_data = + "" + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"io-mod5\" failed.", NULL, 0); CHECK_LOG_CTX("Unexpected attribute \"name\" of \"input\" element.", NULL, 1); - memset(&inout, 0, sizeof inout); } static void test_action_elem(void **state) { - const char *data; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_action *actions = NULL; - struct tree_node_meta act_meta = {NULL, (struct lysp_node **)&actions}; - uint16_t flags; + struct lysp_node_container *cont = NULL; + uint16_t flags = LYS_STATUS_DEPRC; /* max subelems */ - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " ref" + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - /* there must be parent for action */ - act_meta.parent = (void *)1; - assert_int_equal(test_element_helper(state, data, &act_meta, NULL, NULL), LY_SUCCESS); - act_meta.parent = NULL; - flags = LYS_STATUS_DEPRC; - CHECK_LYSP_ACTION(actions, "desc", 1, flags, 1, 1,\ - 1, 0, 0, 0,\ - 1, 0,\ - "act", LYS_ACTION, \ - 1, 0, 0, 1,\ - 1, 0,\ - 1, "ref", 1); - + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + cont = (struct lysp_node_container *)mod->parsed->data; + while (cont && strcmp(cont->name, "c") != 0) { + cont = (struct lysp_node_container *)cont->next; + } + actions = cont->actions; + CHECK_LYSP_ACTION(actions, "desc", 1, flags, 1, 1, 1, 0, 0, 0, 1, 0, + "act", LYS_ACTION, 1, 0, 0, 1, 1, 0, 1, "ref", 1); assert_string_equal(actions->iffeatures[0].str, "iff"); assert_string_equal(actions->typedefs->name, "tpdf"); assert_string_equal(actions->groupings->name, "grouping"); - assert_string_equal(actions->output.musts->arg.str, "cond"); + assert_string_equal(actions->output.musts->arg.str, "/a1:cond"); assert_string_equal(actions->input.child->name, "uses-name"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_ACTION); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)actions); - actions = NULL; - - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_ACTION, "MY_MTU"); + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " ref" + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &act_meta, NULL, NULL), LY_SUCCESS); - flags = LYS_STATUS_DEPRC; - CHECK_LYSP_ACTION(actions, "desc", 1, flags, 1, 1,\ - 1, 0, 0, 0,\ - 1, 0,\ - "act", LYS_RPC, \ - 1, 0, 0, 1,\ - 1, 0,\ - 0, "ref", 1); - + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + actions = mod->parsed->rpcs; + CHECK_LYSP_ACTION(actions, "desc", 1, flags, 1, 1, 1, 0, 0, 0, 1, 0, "act", LYS_RPC, 1, 0, 0, 1, 1, 0, 0, "ref", 1); assert_string_equal(actions->iffeatures[0].str, "iff"); assert_string_equal(actions->typedefs->name, "tpdf"); assert_string_equal(actions->groupings->name, "grouping"); assert_string_equal(actions->input.child->name, "uses-name"); - assert_string_equal(actions->output.musts->arg.str, "cond"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_RPC); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)actions); - actions = NULL; + assert_string_equal(actions->output.musts->arg.str, "/a2:cond"); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_RPC, "MY_MTU"); /* min subelems */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &act_meta, NULL, NULL), LY_SUCCESS); + yin_data = + "" + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + cont = (struct lysp_node_container *)mod->parsed->data; + actions = cont->actions; assert_string_equal(actions->name, "act"); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)actions); - actions = NULL; } static void test_augment_elem(void **state) { - const char *data; + const char *yin_data; + struct lys_module *mod = NULL; struct lysp_node_augment *augments = NULL; - struct tree_node_meta aug_meta = {NULL, (struct lysp_node **)&augments}; - - PARSER_CUR_PMOD(YCTX)->version = LYS_VERSION_1_1; - data = ELEMENT_WRAPPER_START - "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " desc\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " ref\n" - " \n" - " \n" - " \n" + + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " desc" + " " + " " + " " + " " + " " + " ref" + " " + " " + " " EXT_SUBELEM - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &aug_meta, NULL, NULL), LY_SUCCESS); - assert_string_equal(augments->nodeid, "target"); + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + + augments = mod->parsed->augments; + + assert_string_equal(augments->nodeid, "/aug-test:target"); assert_null(augments->parent); assert_int_equal(augments->nodetype, LYS_AUGMENT); assert_true(augments->flags & LYS_STATUS_CURR); assert_string_equal(augments->dsc, "desc"); assert_string_equal(augments->ref, "ref"); - assert_string_equal(augments->when->cond, "when-cond"); + assert_string_equal(augments->when->cond, "/aug-test:when-cond"); assert_string_equal(augments->iffeatures[0].str, "iff"); assert_string_equal(augments->child->name, "anyd"); assert_int_equal(augments->child->nodetype, LYS_ANYDATA); assert_string_equal(augments->child->next->name, "anyx"); assert_int_equal(augments->child->next->nodetype, LYS_ANYXML); - assert_string_equal(augments->child->next->next->name, "case"); - assert_int_equal(augments->child->next->next->nodetype, LYS_CASE); - assert_string_equal(augments->child->next->next->next->name, "choice"); - assert_int_equal(augments->child->next->next->next->nodetype, LYS_CHOICE); - assert_string_equal(augments->child->next->next->next->next->name, "subcont"); - assert_int_equal(augments->child->next->next->next->next->nodetype, LYS_CONTAINER); - assert_string_equal(augments->child->next->next->next->next->next->name, "leaf"); - assert_int_equal(augments->child->next->next->next->next->next->nodetype, LYS_LEAF); - assert_string_equal(augments->child->next->next->next->next->next->next->name, "llist"); - assert_int_equal(augments->child->next->next->next->next->next->next->nodetype, LYS_LEAFLIST); - assert_string_equal(augments->child->next->next->next->next->next->next->next->name, "list"); - assert_int_equal(augments->child->next->next->next->next->next->next->next->nodetype, LYS_LIST); - assert_string_equal(augments->child->next->next->next->next->next->next->next->next->name, "uses"); - assert_int_equal(augments->child->next->next->next->next->next->next->next->next->nodetype, LYS_USES); - assert_null(augments->child->next->next->next->next->next->next->next->next->next); + assert_string_equal(augments->child->next->next->name, "choice"); + assert_int_equal(augments->child->next->next->nodetype, LYS_CHOICE); + assert_string_equal(((struct lysp_node_choice *)augments->child->next->next)->child->name, "case"); + assert_int_equal(((struct lysp_node_choice *)augments->child->next->next)->child->nodetype, LYS_CASE); + assert_string_equal(augments->child->next->next->next->name, "subcont"); + assert_int_equal(augments->child->next->next->next->nodetype, LYS_CONTAINER); + assert_string_equal(augments->child->next->next->next->next->name, "leaf"); + assert_int_equal(augments->child->next->next->next->next->nodetype, LYS_LEAF); + assert_string_equal(augments->child->next->next->next->next->next->name, "llist"); + assert_int_equal(augments->child->next->next->next->next->next->nodetype, LYS_LEAFLIST); + assert_string_equal(augments->child->next->next->next->next->next->next->name, "list"); + assert_int_equal(augments->child->next->next->next->next->next->next->nodetype, LYS_LIST); + assert_string_equal(augments->child->next->next->next->next->next->next->next->name, "uses"); + assert_int_equal(augments->child->next->next->next->next->next->next->next->nodetype, LYS_USES); + assert_null(augments->child->next->next->next->next->next->next->next->next); assert_string_equal(augments->actions->name, "action"); assert_string_equal(augments->notifs->name, "notif"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(augments->exts[0]), LY_STMT_AUGMENT); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)augments); - augments = NULL; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &aug_meta, NULL, NULL), LY_SUCCESS); - assert_string_equal(augments->nodeid, "target"); - lysp_node_free(UTEST_LYCTX, (struct lysp_node *)augments); - augments = NULL; + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(augments->exts[0]), LY_STMT_AUGMENT, "MY_MTU"); + + /* min subelems */ + yin_data = + "" + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + augments = mod->parsed->augments; + assert_string_equal(augments->nodeid, "/a2:target"); } static void test_deviate_elem(void **state) { - const char *data; - struct lysp_deviate *deviates = NULL; + const char *yin_data; /* invalid arguments */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"\" of \"value\" attribute in \"deviate\" element. " "Valid values are \"not-supported\", \"add\", \"replace\" and \"delete\".", NULL, 1); - deviates = NULL; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"invalid\" of \"value\" attribute in \"deviate\" element. " "Valid values are \"not-supported\", \"add\", \"replace\" and \"delete\".", NULL, 1); - deviates = NULL; - - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"ad\" of \"value\" attribute in \"deviate\" element. " "Valid values are \"not-supported\", \"add\", \"replace\" and \"delete\".", NULL, 1); - deviates = NULL; - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_EVALID); + yin_data = + "" + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev-mod\" failed.", NULL, 0); CHECK_LOG_CTX("Invalid value \"adds\" of \"value\" attribute in \"deviate\" element. " "Valid values are \"not-supported\", \"add\", \"replace\" and \"delete\".", NULL, 1); - deviates = NULL; - - data = ELEMENT_WRAPPER_START - "\n" - " \n" - "" - ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_EVALID); - CHECK_LOG_CTX("Deviate of this type doesn't allow \"must\" as it's sub-element.", NULL, 2); + yin_data = + "" + " " + " " + " " + " " + " " + " " + " " + ""; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev-mod\" failed.", NULL, 0); + CHECK_LOG_CTX("Deviate of this type doesn't allow \"must\" as it's sub-element.", NULL, 1); } static void test_deviation_elem(void **state) { - const char *data; - struct lysp_deviation *deviations = NULL; + const char *yin_data; /* invalid */ - data = ELEMENT_WRAPPER_START "" ELEMENT_WRAPPER_END; - assert_int_equal(test_element_helper(state, data, &deviations, NULL, NULL), LY_EVALID); - CHECK_LOG_CTX("Missing mandatory sub-element \"deviate\" of \"deviation\" element.", NULL, 1); -} - -static struct lysp_module * -mod_renew(struct lysp_yin_ctx *ctx) -{ - struct ly_ctx *ly_ctx = PARSER_CUR_PMOD(ctx)->mod->ctx; - struct lysp_module *pmod; - - lys_module_free(ly_ctx, PARSER_CUR_PMOD(ctx)->mod, 0); - pmod = calloc(1, sizeof *pmod); - ctx->parsed_mods->objs[0] = pmod; - pmod->mod = calloc(1, sizeof *pmod->mod); - pmod->mod->parsed = pmod; - pmod->mod->ctx = ly_ctx; + yin_data = + "" + " " + " " + " " + " " + ""; - return pmod; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"dev\" failed.", NULL, 0); + CHECK_LOG_CTX("Missing mandatory sub-element \"deviate\" of \"deviation\" element.", NULL, 1); } static void test_module_elem(void **state) { - const char *data; - struct lysp_module *lysp_mod = mod_renew(YCTX); + const char *yin_data; + struct lys_module *mod = NULL; + struct lysp_module *lysp_mod = NULL; + const char *a_mod = + "" + " " + " " + ""; + char *b_mod = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, a_mod, LYS_IN_YIN, NULL)); + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, b_mod); /* max subelems */ - data = "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " org\n" - " contact\n" - " desc\n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - EXT_SUBELEM "\n" - "\n"; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); + yin_data = + "" + " " + " " + " " + " " + " " + " org" + " contact" + " desc" + " ref" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " EXT_SUBELEM "" + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + lysp_mod = mod->parsed; - assert_int_equal(yin_parse_mod(YCTX, lysp_mod), LY_SUCCESS); assert_string_equal(lysp_mod->mod->name, "mod"); assert_string_equal(lysp_mod->revs[0].date, "2019-02-02"); assert_string_equal(lysp_mod->mod->ns, "ns"); @@ -3101,14 +3431,13 @@ test_module_elem(void **state) assert_string_equal(lysp_mod->mod->dsc, "desc"); assert_string_equal(lysp_mod->mod->ref, "ref"); assert_int_equal(lysp_mod->version, LYS_VERSION_1_1); - CHECK_LYSP_IMPORT(lysp_mod->imports, NULL, 0, "a-mod", - "imp-pref", NULL, ""); + CHECK_LYSP_IMPORT(lysp_mod->imports, NULL, 0, "a-mod", "imp-pref", NULL, ""); assert_string_equal(lysp_mod->includes->name, "b-mod"); - assert_string_equal(lysp_mod->extensions->name, "ext"); + assert_string_equal(lysp_mod->extensions->name, "c-define"); assert_string_equal(lysp_mod->features->name, "feature"); assert_string_equal(lysp_mod->identities->name, "ident-name"); assert_string_equal(lysp_mod->typedefs->name, "tpdf"); - assert_string_equal(lysp_mod->groupings->name, "grp"); + assert_string_equal(lysp_mod->groupings->name, "uses-name"); assert_string_equal(lysp_mod->data->name, "anyd"); assert_int_equal(lysp_mod->data->nodetype, LYS_ANYDATA); assert_string_equal(lysp_mod->data->next->name, "anyx"); @@ -3126,105 +3455,102 @@ test_module_elem(void **state) assert_string_equal(lysp_mod->data->next->next->next->next->next->next->next->name, "uses-name"); assert_int_equal(lysp_mod->data->next->next->next->next->next->next->next->nodetype, LYS_USES); assert_null(lysp_mod->data->next->next->next->next->next->next->next->next); - assert_string_equal(lysp_mod->augments->nodeid, "target"); + assert_string_equal(lysp_mod->augments->nodeid, "/pref:cont"); assert_string_equal(lysp_mod->rpcs->name, "rpc-name"); assert_string_equal(lysp_mod->notifs->name, "notf"); - assert_string_equal(lysp_mod->deviations->nodeid, "target"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_mod->exts[0]), LY_STMT_MODULE); + assert_string_equal(lysp_mod->deviations->nodeid, "/pref:cont"); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_mod->exts[0]), LY_STMT_MODULE, "MY_MTU"); /* min subelems */ - ly_in_free(UTEST_IN, 0); - lyxml_ctx_free(YCTX->xmlctx); - lysp_mod = mod_renew(YCTX); - data = "\n" - " \n" - " \n" - " \n" - ""; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); - assert_int_equal(yin_parse_mod(YCTX, lysp_mod), LY_SUCCESS); - assert_string_equal(lysp_mod->mod->name, "mod"); + yin_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + lysp_mod = mod->parsed; + assert_string_equal(lysp_mod->mod->name, "mod-min"); /* incorrect subelem order */ - ly_in_free(UTEST_IN, 0); - lyxml_ctx_free(YCTX->xmlctx); - lysp_mod = mod_renew(YCTX); - data = "\n" - " \n" - " \n" - " \n" - " \n" - ""; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); - assert_int_equal(yin_parse_mod(YCTX, lysp_mod), LY_EVALID); - CHECK_LOG_CTX("Invalid order of module\'s sub-elements \"namespace\" can\'t appear after \"feature\".", NULL, 3); -} + yin_data = + "" + " " + " " + " " + " " + ""; -static struct lysp_submodule * -submod_renew(struct lysp_yin_ctx *ctx, const char *belongs_to) -{ - struct ly_ctx *ly_ctx = PARSER_CUR_PMOD(ctx)->mod->ctx; - struct lysp_submodule *submod; - - lys_module_free(ly_ctx, PARSER_CUR_PMOD(ctx)->mod, 0); - submod = calloc(1, sizeof *submod); - ctx->parsed_mods->objs[0] = submod; - submod->mod = calloc(1, sizeof *submod->mod); - lysdict_insert(ly_ctx, belongs_to, 0, &submod->mod->name); - submod->mod->parsed = (struct lysp_module *)submod; - submod->mod->ctx = ly_ctx; - - return submod; + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"mod-inv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid order of module\'s sub-elements \"namespace\" can\'t appear after \"feature\".", NULL, 1); } static void test_submodule_elem(void **state) { - const char *data; - struct lysp_submodule *lysp_submod = submod_renew(YCTX, "module-name"); + char *yin_data; + const char *parent_data; + struct lys_module *mod = NULL; + struct lysp_submodule *lysp_submod = NULL; + const char *a_mod = + "" + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, a_mod, LYS_IN_YIN, NULL)); /* max subelements */ - data = "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " org\n" - " contact\n" - " desc\n" - " ref\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - EXT_SUBELEM "\n" - "\n"; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); + yin_data = + "" + " " + " " + " " + " " + " " + " org" + " contact" + " desc" + " ref" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " EXT_SUBELEM "" + ""; + + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, yin_data); + parent_data = + "" + " " + " " + " " + ""; - assert_int_equal(yin_parse_submod(YCTX, lysp_submod), LY_SUCCESS); - CHECK_LOG_CTX("YANG version 1.1 expects all includes in main module, includes in submodules (mod) are not necessary.", - NULL, 0); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, parent_data, LYS_IN_YIN, &mod)); + lysp_submod = mod->parsed->includes[0].submodule; assert_string_equal(lysp_submod->name, "mod"); assert_string_equal(lysp_submod->revs[0].date, "2019-02-02"); assert_string_equal(lysp_submod->prefix, "pref"); @@ -3234,9 +3560,7 @@ test_submodule_elem(void **state) assert_string_equal(lysp_submod->dsc, "desc"); assert_string_equal(lysp_submod->ref, "ref"); assert_int_equal(lysp_submod->version, LYS_VERSION_1_1); - CHECK_LYSP_IMPORT(lysp_submod->imports, NULL, 0, "a-mod", - "imp-pref", NULL, ""); - assert_string_equal(lysp_submod->includes->name, "b-mod"); + CHECK_LYSP_IMPORT(lysp_submod->imports, NULL, 0, "a-mod", "imp-pref", NULL, ""); assert_string_equal(lysp_submod->extensions->name, "ext"); assert_string_equal(lysp_submod->features->name, "feature"); assert_string_equal(lysp_submod->identities->name, "ident-name"); @@ -3259,254 +3583,239 @@ test_submodule_elem(void **state) assert_string_equal(lysp_submod->data->next->next->next->next->next->next->next->name, "uses-name"); assert_int_equal(lysp_submod->data->next->next->next->next->next->next->next->nodetype, LYS_USES); assert_null(lysp_submod->data->next->next->next->next->next->next->next->next); - assert_string_equal(lysp_submod->augments->nodeid, "target"); + assert_string_equal(lysp_submod->augments->nodeid, "/pref:cont"); assert_string_equal(lysp_submod->rpcs->name, "rpc-name"); assert_string_equal(lysp_submod->notifs->name, "notf"); - assert_string_equal(lysp_submod->deviations->nodeid, "target"); - TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_submod->exts[0]), LY_STMT_SUBMODULE); - - /* min subelemnts */ - ly_in_free(UTEST_IN, 0); - lyxml_ctx_free(YCTX->xmlctx); - lysp_submod = submod_renew(YCTX, "module-name"); - data = "\n" - " \n" - " \n" + assert_string_equal(lysp_submod->deviations->nodeid, "/pref:cont"); + TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_submod->exts[0]), LY_STMT_SUBMODULE, "MY_MTU"); + + /* min subelements */ + yin_data = + "" + " " + " " ""; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); - assert_int_equal(yin_parse_submod(YCTX, lysp_submod), LY_SUCCESS); + + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, yin_data); + + parent_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, parent_data, LYS_IN_YIN, &mod)); + lysp_submod = mod->parsed->includes[0].submodule; + assert_string_equal(lysp_submod->prefix, "pref"); assert_int_equal(lysp_submod->version, LYS_VERSION_1_0); /* incorrect subelem order */ - ly_in_free(UTEST_IN, 0); - lyxml_ctx_free(YCTX->xmlctx); - lysp_submod = submod_renew(YCTX, "module-name"); - data = "\n" - " \n" - " ref\n" - " \n" + yin_data = + "" + " " + " ref" + " " ""; - assert_int_equal(ly_in_new_memory(data, &UTEST_IN), LY_SUCCESS); - assert_int_equal(lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx), LY_SUCCESS); - assert_int_equal(yin_parse_submod(YCTX, lysp_submod), LY_EVALID); - CHECK_LOG_CTX("Invalid order of submodule's sub-elements \"belongs-to\" can't appear after \"reference\".", NULL, 4); + + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, (void *)yin_data); + + parent_data = + "" + " " + " " + " " + ""; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, parent_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"parent3\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"submod-inv\" failed.", NULL, 0); + CHECK_LOG_CTX("Invalid order of submodule's sub-elements \"belongs-to\" can't appear after \"reference\".", NULL, 1); } static void test_yin_parse_module(void **state) { - const char *data; - struct lys_module *mod; - struct lysp_yin_ctx *yin_ctx = NULL; - struct ly_in *in = NULL; - - mod = calloc(1, sizeof *mod); - mod->ctx = UTEST_LYCTX; - data = " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " test\n" - " \n" - " \n" - " test\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - "\n"; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_module(&yin_ctx, in, mod), LY_SUCCESS); - assert_null(mod->parsed->exts->child->next->child); - assert_string_equal(mod->parsed->exts->child->next->arg, "test"); - lys_module_free(UTEST_LYCTX, mod, 0); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - mod = NULL; - yin_ctx = NULL; - - mod = calloc(1, sizeof *mod); - mod->ctx = UTEST_LYCTX; - data = "" + " " + " " + " " + ""; + + yin_data = + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " test" + " " + " " + " test" + " " + " " + " " + " " + " " + " " + ""; + + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); + assert_null(mod->parsed->exts[0].child->next->child); + assert_string_equal(mod->parsed->exts[0].child->next->arg, "test"); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, ext_mod, LYS_IN_YIN, NULL)); + + yin_data = + "\n" + " xmlns:myext=\"urn:example:extensions\">" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " The MTU of the interface." + " " + " " + " " + " " + ""; - " \n" + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); - " \n" - " \n" + yin_data = + "" + " " + " " + " " + ""; - " \n" - " \n" - " \n" + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, &mod)); - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " The MTU of the interface.\n" - " \n" - " \n" - " \n" - " \n" - "\n"; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_module(&yin_ctx, in, mod), LY_SUCCESS); - lys_module_free(UTEST_LYCTX, mod, 0); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - mod = NULL; - yin_ctx = NULL; - - mod = calloc(1, sizeof *mod); - mod->ctx = UTEST_LYCTX; - data = "\n" - " \n" - " \n" - " \n" - "\n"; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_module(&yin_ctx, in, mod), LY_SUCCESS); - lys_module_free(UTEST_LYCTX, mod, 0); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - mod = NULL; - yin_ctx = NULL; - - mod = calloc(1, sizeof *mod); - mod->ctx = UTEST_LYCTX; - data = "" - "\n"; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_module(&yin_ctx, in, mod), LY_EINVAL); + yin_data = ""; + + assert_int_equal(LY_EINVAL, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); CHECK_LOG_CTX("Input data contains submodule which cannot be parsed directly without its main module.", NULL, 0); - lys_module_free(UTEST_LYCTX, mod, 0); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - - mod = calloc(1, sizeof *mod); - mod->ctx = UTEST_LYCTX; - data = "\n" - " \n" - " \n" - " \n" - "\n" + + yin_data = + "" + " " + " " + " " + "" ""; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_module(&yin_ctx, in, mod), LY_EVALID); - CHECK_LOG_CTX("Trailing garbage \"\" after module, expected end-of-input.", NULL, 6); - lys_module_free(UTEST_LYCTX, mod, 0); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - mod = NULL; - yin_ctx = NULL; + + assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, yin_data, LYS_IN_YIN, NULL)); + CHECK_LOG_CTX("Parsing module \"example-foo-garb\" failed.", NULL, 0); + CHECK_LOG_CTX("Trailing garbage \"\" after module, expected end-of-input.", NULL, 1); } static void test_yin_parse_submodule(void **state) { - const char *data; - struct lysp_yin_ctx *yin_ctx = NULL; - struct lysp_submodule *submod = NULL; - struct ly_in *in; - - lysdict_insert(UTEST_LYCTX, "a", 0, &PARSER_CUR_PMOD(YCTX)->mod->name); + struct lys_module *mod; + char *yin_data; + const char *mod_a = + "" + " " + " " + " " + " " + " " + " " + ""; - data = "\n" + yin_data = "\n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" - " \n" + " xmlns:a=\"urn:a\">" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " ""; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_submodule(&yin_ctx, UTEST_LYCTX, (struct lysp_ctx *)YCTX, in, &submod), LY_SUCCESS); - lysp_module_free(UTEST_LYCTX, (struct lysp_module *)submod); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - yin_ctx = NULL; - submod = NULL; - - data = "\n" - "\n" - " \n" - " \n" - " \n" - " \n" + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, yin_data); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, mod_a, LYS_IN_YIN, &mod)); + UTEST_TEARDOWN; + UTEST_SETUP; + + yin_data = + "" + " " + " " + " " + " " ""; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_submodule(&yin_ctx, UTEST_LYCTX, (struct lysp_ctx *)YCTX, in, &submod), LY_SUCCESS); - lysp_module_free(UTEST_LYCTX, (struct lysp_module *)submod); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - yin_ctx = NULL; - submod = NULL; - - data = "\n" + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, yin_data); + assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, mod_a, LYS_IN_YIN, &mod)); + UTEST_TEARDOWN; + UTEST_SETUP; + + yin_data = "" ""; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_submodule(&yin_ctx, UTEST_LYCTX, (struct lysp_ctx *)YCTX, in, &submod), LY_EINVAL); + ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, yin_data); + assert_int_equal(lys_parse_mem(UTEST_LYCTX, mod_a, LYS_IN_YIN, &mod), LY_EINVAL); + CHECK_LOG_CTX("Parsing module \"a\" failed.", NULL, 0); + CHECK_LOG_CTX("Parsing submodule \"asub\" failed.", NULL, 0); CHECK_LOG_CTX("Input data contains module when a submodule is expected.", NULL, 0); - lysp_module_free(UTEST_LYCTX, (struct lysp_module *)submod); - lysp_yin_ctx_free(yin_ctx); - ly_in_free(in, 0); - yin_ctx = NULL; - submod = NULL; - - data = "\n" - "\n" - " \n" - " \n" - " \n" - " \n" - "\n" - "\n" - " \n" - " \n" - " \n" - " \n" + + UTEST_TEARDOWN; + UTEST_SETUP; + + yin_data = + "" + " " + " " + " " + " " + "" + "" + " " + " " + " " + " " ""; - assert_int_equal(ly_in_new_memory(data, &in), LY_SUCCESS); - assert_int_equal(yin_parse_submodule(&yin_ctx, UTEST_LYCTX, (struct lysp_ctx *)YCTX, in, &submod), LY_EVALID); - CHECK_LOG_CTX("Trailing garbage \"compiled->data)->type; lysc_type2 = ((struct lysc_node_leaf *)mod->compiled->data->next)->type; + type = lysc_get_type_plugin(lysc_type2->plugin_ref); /* check proper type */ assert_string_equal("ly2 binary", type->id); @@ -250,13 +251,14 @@ test_plugin_print(void **state) struct lyd_value value = {0}; struct lys_module *mod; struct lysc_type *lysc_type; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BINARY])); + struct lyplg_type *type = NULL; struct ly_err_item *err = NULL; /* create schema. Prepare common used variables */ schema = MODULE_CREATE_YANG("a", "leaf l {type binary;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* Testing empty value. */ val = ""; @@ -273,13 +275,14 @@ test_plugin_duplicate(void **state) struct lyd_value value = {0}, dup; struct lys_module *mod; struct lysc_type *lysc_type; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BINARY])); + struct lyplg_type *type = NULL; struct ly_err_item *err = NULL; /* create schema. Prepare common used variables */ schema = MODULE_CREATE_YANG("a", "leaf l {type binary;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* Testing empty value. */ val = ""; @@ -298,7 +301,7 @@ test_plugin_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BINARY])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; @@ -306,6 +309,7 @@ test_plugin_sort(void **state) schema = MODULE_CREATE_YANG("a", "leaf-list ll {type binary;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* v1 < v2, v2 > v1, v1 == v1 */ v1 = "YWhveQ=="; /* ahoy */ diff --git a/tests/utests/types/bits.c b/tests/utests/types/bits.c index d599e3c8b8..df8f61754d 100644 --- a/tests/utests/types/bits.c +++ b/tests/utests/types/bits.c @@ -21,7 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" #define MODULE_CREATE_YIN(MOD_NAME, NODES) \ "\n" \ @@ -800,7 +799,7 @@ test_plugin_store(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value value = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BITS])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; char *alloc; @@ -811,6 +810,7 @@ test_plugin_store(void **state) " bit two; bit three;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* check proper type */ assert_string_equal("ly2 bits", type->id); @@ -884,7 +884,7 @@ test_plugin_compare(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BITS])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; const char *schema; @@ -904,6 +904,7 @@ test_plugin_compare(void **state) "leaf p4 {type string;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) { @@ -946,7 +947,7 @@ test_plugin_sort(void **state) { const char *schema; struct lys_module *mod; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BITS])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; struct lyd_value val1 = {0}, val2 = {0}; @@ -954,6 +955,7 @@ test_plugin_sort(void **state) schema = MODULE_CREATE_YANG("T0", "leaf-list ll { type bits { bit zero; bit one; bit two; bit three;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* 1000 < 1001 */ assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, "three", strlen("three") * 8, @@ -983,7 +985,7 @@ test_plugin_print(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BITS])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; const char *schema; @@ -996,6 +998,7 @@ test_plugin_print(void **state) " bit two; bit three;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) { @@ -1025,7 +1028,7 @@ test_plugin_dup(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_BITS])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; const char *schema; LY_ERR ly_ret; @@ -1038,6 +1041,7 @@ test_plugin_dup(void **state) " bit two; bit three;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) { diff --git a/tests/utests/types/enumeration.c b/tests/utests/types/enumeration.c index 119ebfd768..5cc8ab9d87 100644 --- a/tests/utests/types/enumeration.c +++ b/tests/utests/types/enumeration.c @@ -94,13 +94,14 @@ test_plugin_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_ENUM])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; schema = MODULE_CREATE_YANG("sort", "leaf l1 {type enumeration {enum white; enum yellow; enum black;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "white"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, diff --git a/tests/utests/types/inet_types.c b/tests/utests/types/inet_types.c index 8e2e7942d5..4756d8635e 100644 --- a/tests/utests/types/inet_types.c +++ b/tests/utests/types/inet_types.c @@ -197,7 +197,7 @@ test_plugin_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_UNION])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; @@ -212,6 +212,7 @@ test_plugin_sort(void **state) /* ipv4-address */ lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "192.168.0.1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, @@ -239,7 +240,7 @@ test_plugin_sort(void **state) /* ipv6-address */ lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data->next)->type; - type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "2008:15:0:0:0:0:feAC:1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, @@ -267,7 +268,7 @@ test_plugin_sort(void **state) /* ipv4-address-no-zone */ lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data->next->next)->type; - type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_UNION])); + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "127.0.0.1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, 0, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, NULL, &val1, NULL, &err)); @@ -282,7 +283,7 @@ test_plugin_sort(void **state) /* ipv6-address-no-zone */ lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data->next->next->next)->type; - type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "A:B:c:D:e:f:1:1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, 0, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, NULL, &val1, NULL, &err)); @@ -297,6 +298,7 @@ test_plugin_sort(void **state) /* ipv4-prefix */ lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data->next->next->next->next)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "0.1.58.4/32"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, 0, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, NULL, &val1, NULL, &err)); @@ -311,10 +313,11 @@ test_plugin_sort(void **state) /* ipv6-prefix */ lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data->next->next->next->next->next)->type; - v1 = "::C:D:E:f:a/96"; + type = lysc_get_type_plugin(lysc_type->plugin_ref); + v1 = "::C:D:E:f:a/112"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, 0, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, NULL, &val1, NULL, &err)); - v2 = "::C:D:E:f:a/112"; + v2 = "::C:D:E:f:a/96"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v2, strlen(v2) * 8, 0, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, NULL, &val2, NULL, &err)); assert_true(0 < type->sort(UTEST_LYCTX, &val1, &val2)); diff --git a/tests/utests/types/instanceid.c b/tests/utests/types/instanceid.c index b3f6a5c45a..e0b1a2f61e 100644 --- a/tests/utests/types/instanceid.c +++ b/tests/utests/types/instanceid.c @@ -18,7 +18,13 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" + +enum ly_path_pred_type { + LY_PATH_PREDTYPE_POSITION, /**< position predicate - [2] */ + LY_PATH_PREDTYPE_LIST, /**< keys predicate - [key1='val1'][key2='val2']... */ + LY_PATH_PREDTYPE_LEAFLIST, /**< leaflist value predicate - [.='value'] */ + LY_PATH_PREDTYPE_LIST_VAR /**< keys predicate with variable instead of value - [key1=$USER]... */ +}; #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/int16.c b/tests/utests/types/int16.c index 96828e0330..efff7f8f54 100644 --- a/tests/utests/types/int16.c +++ b/tests/utests/types/int16.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/int32.c b/tests/utests/types/int32.c index fa2b34107e..7e03f9375a 100644 --- a/tests/utests/types/int32.c +++ b/tests/utests/types/int32.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/int64.c b/tests/utests/types/int64.c index 04066739e7..ca0de307d8 100644 --- a/tests/utests/types/int64.c +++ b/tests/utests/types/int64.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/int8.c b/tests/utests/types/int8.c index 62ae3ff868..3fb9416fbe 100644 --- a/tests/utests/types/int8.c +++ b/tests/utests/types/int8.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define LYD_TREE_CREATE(INPUT, MODEL) \ CHECK_PARSE_LYD_PARAM(INPUT, LYD_XML, 0, LYD_VALIDATE_PRESENT, LY_SUCCESS, MODEL) @@ -1399,7 +1397,7 @@ test_plugin_store(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value value = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_INT8])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; char *alloc; @@ -1410,6 +1408,7 @@ test_plugin_store(void **state) schema = MODULE_CREATE_YANG("defs", "leaf port {type int8 {range \"-50 .. 50\";}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* check proper type */ assert_string_equal("ly2 integers", type->id); @@ -1546,7 +1545,7 @@ test_plugin_compare(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_INT8])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; const char *schema; @@ -1565,6 +1564,7 @@ test_plugin_compare(void **state) "leaf p4 {type uint8;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) { @@ -1631,7 +1631,7 @@ test_plugin_print(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_INT8])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; const char *schema; @@ -1642,6 +1642,7 @@ test_plugin_print(void **state) schema = MODULE_CREATE_YANG("defs", "leaf port {type int8;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) { @@ -1671,7 +1672,7 @@ test_plugin_dup(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_INT8])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type[2]; const char *schema; LY_ERR ly_ret; @@ -1682,6 +1683,7 @@ test_plugin_dup(void **state) schema = MODULE_CREATE_YANG("T0", "leaf port {type int8;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type[0] = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type[0]->plugin_ref); schema = MODULE_CREATE_YANG("T1", "typedef my_int_type {" diff --git a/tests/utests/types/leafref.c b/tests/utests/types/leafref.c index 6c464ceb94..7469df5c77 100644 --- a/tests/utests/types/leafref.c +++ b/tests/utests/types/leafref.c @@ -216,7 +216,7 @@ test_plugin_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_LEAFREF])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; @@ -232,6 +232,7 @@ test_plugin_sort(void **state) "}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "str1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, diff --git a/tests/utests/types/string.c b/tests/utests/types/string.c index 23210a70cd..198511b055 100644 --- a/tests/utests/types/string.c +++ b/tests/utests/types/string.c @@ -20,8 +20,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YIN(MOD_NAME, NODES) \ "\n" \ @@ -1122,7 +1120,7 @@ test_plugin_store(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value value = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; char *alloc_text; unsigned int alloc_text_size; @@ -1133,6 +1131,7 @@ test_plugin_store(void **state) "pattern '[0-9\\n<>\\\"\\|]*' ;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *) mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* check proper type */ assert_string_equal("ly2 string", type->id); @@ -1263,7 +1262,7 @@ test_plugin_compare(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; const char *schema; @@ -1281,6 +1280,7 @@ test_plugin_compare(void **state) "leaf p4 {type uint8;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *) mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ const char *val_init[] = {"hi", "hello", "hi", "hello", "hell", "hh"}; @@ -1321,7 +1321,7 @@ test_plugin_print(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; LY_ERR ly_ret; @@ -1330,6 +1330,7 @@ test_plugin_print(void **state) UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *) mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* CREATE VALUES */ const char *val_init[] = {"20", "0x4A", "<|>", "\""}; @@ -1360,7 +1361,7 @@ test_plugin_dup(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value values[10]; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_STRING])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type[2]; const char *schema; LY_ERR ly_ret; @@ -1377,6 +1378,7 @@ test_plugin_dup(void **state) "leaf port {type my_int_type; }"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type[1] = ((struct lysc_node_leaf *) mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type[1]->plugin_ref); /* CREATE VALUES */ const char *val_init[] = {"20", "0x4A", "<\">", "0x4A"}; diff --git a/tests/utests/types/uint16.c b/tests/utests/types/uint16.c index 2ded9eb596..cb4bb397c6 100644 --- a/tests/utests/types/uint16.c +++ b/tests/utests/types/uint16.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/uint32.c b/tests/utests/types/uint32.c index 89221c404f..a547b2a6ef 100644 --- a/tests/utests/types/uint32.c +++ b/tests/utests/types/uint32.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/uint64.c b/tests/utests/types/uint64.c index 71e024e09a..9feadf23b2 100644 --- a/tests/utests/types/uint64.c +++ b/tests/utests/types/uint64.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/uint8.c b/tests/utests/types/uint8.c index 618e422744..79dd852dae 100644 --- a/tests/utests/types/uint8.c +++ b/tests/utests/types/uint8.c @@ -21,8 +21,6 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" -#include "plugins_internal.h" #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ diff --git a/tests/utests/types/union.c b/tests/utests/types/union.c index 9091b632ef..a7c304f3ad 100644 --- a/tests/utests/types/union.c +++ b/tests/utests/types/union.c @@ -18,7 +18,13 @@ /* LOCAL INCLUDE HEADERS */ #include "libyang.h" -#include "path.h" + +enum ly_path_pred_type { + LY_PATH_PREDTYPE_POSITION, /**< position predicate - [2] */ + LY_PATH_PREDTYPE_LIST, /**< keys predicate - [key1='val1'][key2='val2']... */ + LY_PATH_PREDTYPE_LEAFLIST, /**< leaflist value predicate - [.='value'] */ + LY_PATH_PREDTYPE_LIST_VAR /**< keys predicate with variable instead of value - [key1=$USER]... */ +}; #define MODULE_CREATE_YANG(MOD_NAME, NODES) \ "module " MOD_NAME " {\n" \ @@ -154,13 +160,14 @@ test_plugin_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_UNION])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; schema = MODULE_CREATE_YANG("sort", "leaf-list ll {type union {type uint16; type int16;}}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); v1 = "1"; assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, v1, strlen(v1) * 8, @@ -306,7 +313,7 @@ test_validation_store_only(void **state) struct ly_err_item *err = NULL; struct lys_module *mod; struct lyd_value value = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[LY_TYPE_UNION])); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; const char *schema; @@ -323,6 +330,7 @@ test_validation_store_only(void **state) "}\n"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaf *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* check proper type */ assert_string_equal("ly2 union", type->id); diff --git a/tests/utests/types/yang_types.c b/tests/utests/types/yang_types.c index 9b1f841e9a..9b726cd1c8 100644 --- a/tests/utests/types/yang_types.c +++ b/tests/utests/types/yang_types.c @@ -18,7 +18,6 @@ #include -#include "compat.h" #include "libyang.h" #define MODULE_CREATE_YIN(MOD_NAME, NODES) \ @@ -281,7 +280,7 @@ test_sort(void **state) const char *schema; struct lys_module *mod; struct lyd_value val1 = {0}, val2 = {0}; - struct lyplg_type *type = lysc_get_type_plugin(lyplg_type_plugin_find(NULL, "ietf-yang-types", "2025-12-22", "date-and-time")); + struct lyplg_type *type = NULL; struct lysc_type *lysc_type; struct ly_err_item *err = NULL; @@ -290,6 +289,7 @@ test_sort(void **state) "leaf-list ll {type yang:date-and-time;}"); UTEST_ADD_MODULE(schema, LYS_IN_YANG, NULL, &mod); lysc_type = ((struct lysc_node_leaflist *)mod->compiled->data)->type; + type = lysc_get_type_plugin(lysc_type->plugin_ref); /* v1 > v2, v2 < v1, v1 == v1 */ v1 = "2005-05-25T23:15:15Z"; diff --git a/tests/utests/utests.h b/tests/utests/utests.h index aaf3701e6a..935faf7374 100644 --- a/tests/utests/utests.h +++ b/tests/utests/utests.h @@ -31,10 +31,8 @@ #include "libyang.h" #include "plugins_exts/metadata.h" -#include "plugins_internal.h" #include "plugins_types.h" #include "tests_config.h" -#include "tree_schema_internal.h" /** * TESTS OVERVIEW @@ -87,6 +85,8 @@ * function call. */ +#define UNUSED(x) UNUSED_ ## x __attribute__((__unused__)) + /** * @brief Test's context to provide common storage for various variables. */ @@ -222,7 +222,7 @@ struct utest_context { */ /** - * @brief check compileted type + * @brief check compiled type * * @param[in] NODE pointer to lysc_type value * @param[in] TYPE expected type [LY_DATA_TYPE](@ref LY_DATA_TYPE) @@ -232,7 +232,7 @@ struct utest_context { assert_non_null(NODE); \ assert_int_equal((NODE)->basetype, TYPE); \ CHECK_ARRAY((NODE)->exts, EXTS); \ - assert_ptr_equal((NODE)->plugin_ref, lyplg_type_plugin_find(NULL, "", NULL, ly_data_type2str[TYPE])) + assert_non_null((NODE)->plugin_ref) /** * @brief check compileted numeric type @@ -585,9 +585,8 @@ struct utest_context { * LYS_USES, LYS_INPUT, LYS_OUTPUT, LYS_GROUPING, LYS_AUGMENT * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root * @param[in] REF expected reference statement - * @param[in] WHEN 0-> pointer is null, 1 -> pointer is not null */ -#define CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, NODETYPE, PARENT, REF, WHEN) \ +#define CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, NODETYPE, PARENT, REF) \ assert_non_null(NODE); \ CHECK_STRING((NODE)->dsc, DSC); \ CHECK_ARRAY((NODE)->exts, EXTS); \ @@ -597,8 +596,7 @@ struct utest_context { CHECK_POINTER((NODE)->next, NEXT); \ assert_int_equal((NODE)->nodetype, NODETYPE); \ CHECK_POINTER((NODE)->parent, PARENT); \ - CHECK_STRING((NODE)->ref, REF); \ - CHECK_POINTER(lysp_node_when((struct lysp_node *)NODE), WHEN); + CHECK_STRING((NODE)->ref, REF); /** * @brief assert that lysp_node structure members are correct @@ -619,7 +617,8 @@ struct utest_context { */ #define CHECK_LYSP_NODE_LEAF(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, \ PARENT, REF, WHEN, MUSTS, UNITS, DFLT) \ - CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, LYS_LEAF, PARENT, REF, WHEN); \ + CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, LYS_LEAF, PARENT, REF); \ + CHECK_POINTER(((struct lysp_node_leaf *)NODE)->when, WHEN); \ CHECK_ARRAY((NODE)->musts, MUSTS); \ CHECK_STRING((NODE)->units, UNITS); \ CHECK_STRING((NODE)->dflt.str, DFLT); @@ -1004,11 +1003,6 @@ struct utest_context { { \ LY_ARRAY_COUNT_TYPE arr_size = sizeof(VALUE) / sizeof(VALUE[0]); \ assert_int_equal(arr_size, LY_ARRAY_COUNT((NODE).target)); \ - for (LY_ARRAY_COUNT_TYPE it = 0; it < arr_size; it++) { \ - if ((NODE).target[it].predicates) { \ - assert_int_equal(VALUE[it], (NODE).target[it].predicates[0].type); \ - } \ - } \ } /**