static int
ylib_submodules(struct lyd_node *parent, struct lys_module *cur_mod)
{
int i;
struct lyd_node *cont, *item;
if (cur_mod->inc_size) {
cont = lyd_new(parent, NULL, "submodules");
}
for (i = 0; i < cur_mod->inc_size; ++i) {
item = lyd_new(cont, NULL, "submodule");
if (!item) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(item, NULL, "name", cur_mod->inc[i].submodule->name)) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(item, NULL, "revision", (cur_mod->inc[i].submodule->rev_size ?
cur_mod->inc[i].submodule->rev[0].date : ""))) {
return EXIT_FAILURE;
}
if (cur_mod->inc[i].submodule->uri
&& !lyd_new_leaf(item, NULL, "schema", cur_mod->inc[i].submodule->uri)) {
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
static int
ylib_feature(struct lyd_node *parent, struct lys_module *cur_mod)
{
int i, j;
/* module features */
for (i = 0; i < cur_mod->features_size; ++i) {
if (!(cur_mod->features[i].flags & LYS_FENABLED)) {
continue;
}
if (!lyd_new_leaf(parent, NULL, "feature", cur_mod->features[i].name)) {
return EXIT_FAILURE;
}
}
/* submodule features */
for (i = 0; i < cur_mod->inc_size; ++i) {
for (j = 0; j < cur_mod->inc[i].submodule->features_size; ++j) {
if (!(cur_mod->inc[i].submodule->features[j].flags & LYS_FENABLED)) {
continue;
}
if (!lyd_new_leaf(parent, NULL, "feature", cur_mod->inc[i].submodule->features[j].name)) {
return EXIT_FAILURE;
}
}
}
return EXIT_SUCCESS;
}
static void
test_df4(void **state)
{
struct state *st = (*state);
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<b1_2>x</b1_2><foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<b2>1</b2><foo ncwd:default=\"true\">42</foo>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
const char *xml3 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<s2a>1</s2a><foo ncwd:default=\"true\">42</foo>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* select2 - s2a */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "s2a", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml3);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select2 - s2b - b2 */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "b2", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml2);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select2 - s2b - b1 */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "b1_2", "x"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml1);
}
int main(int argc, char *argv[])
{
int fd, i;
struct ly_ctx *ctx = NULL;
char buf[30];
struct lyd_node *data = NULL, *next;
const struct lys_module *mod;
/* libyang context */
ctx = ly_ctx_new(NULL);
if (!ctx) {
fprintf(stderr, "Failed to create context.\n");
return 1;
}
/* schema */
if (!(mod = lys_parse_path(ctx, argv[1], LYS_IN_YIN))) {
fprintf(stderr, "Failed to load data model.\n");
goto cleanup;
}
/* data */
data = NULL;
fd = open("./addloop_result.xml", O_WRONLY | O_CREAT, 0666);
data = NULL;
for(i = 1; i <= 5000; i++) {
next = lyd_new(NULL, mod, "ptest1");
// if (i == 2091) {sprintf(buf, "%d", 1);} else {
sprintf(buf, "%d", i);//}
lyd_new_leaf(next, mod, "index", buf);
lyd_new_leaf(next, mod, "p1", buf);
if (!data) {
data = next;
} else {
lyd_insert_after(data->prev, next);
}
if (lyd_validate(&data, LYD_OPT_CONFIG, NULL)) {
goto cleanup;
}
//lyd_print_fd(fd, data, LYD_XML);
}
lyd_print_fd(fd, data, LYD_XML, LYP_WITHSIBLINGS | LYP_FORMAT);
close(fd);
cleanup:
lyd_free_withsiblings(data);
ly_ctx_destroy(ctx, NULL);
return 0;
}
static void
test_df2(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<list><name>a</name><value>42</value></list>"
"<list><name>b</name><value>1</value></list>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* lists */
assert_ptr_not_equal(lyd_new_path(st->dt, NULL, "/defaults:df/defaults:list[name='a']", NULL, 0), NULL);
assert_ptr_not_equal((node = lyd_new_path(st->dt, NULL, "/defaults:df/defaults:list[name='b']", NULL, 0)), NULL);
assert_ptr_not_equal(lyd_new_leaf(node, NULL, "value", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
static void
test_df1(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<bar><ho>1</ho><hi>42</hi></bar>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* presence container */
assert_ptr_not_equal((node = lyd_new(st->dt, NULL, "bar")), NULL);
assert_int_not_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_string_equal(ly_errmsg(), "Missing required element \"ho\" in \"bar\".");
/* manadatory node in bar */
assert_ptr_not_equal(lyd_new_leaf(node, NULL, "ho", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml);
}
static void
test_leafref_free(void **state)
{
struct state *st = (*state);
int r;
lyd_free(st->data->child->child->prev);
r = lyd_validate(&(st->data), LYD_OPT_CONFIG, NULL);
assert_int_not_equal(r, 0);
lyd_new_leaf(st->data->child, NULL, "name", "jedna");
r = lyd_validate(&(st->data), LYD_OPT_CONFIG, NULL);
assert_int_equal(r, 0);
}
static void
test_df3(void **state)
{
struct state *st = (*state);
struct lyd_node *node;
const char *xml1 = "<df xmlns=\"urn:libyang:tests:defaults\">"
"<a1>1</a1>"
"<foo>42</foo><b1_1>42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\">"
"<foo>42</foo><baz>42</baz></hidden>";
const char *xml2 = "<df xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<c><x ncwd:default=\"true\">42</x></c>"
"<foo ncwd:default=\"true\">42</foo><b1_1 ncwd:default=\"true\">42</b1_1>"
"</df><hidden xmlns=\"urn:libyang:tests:defaults\" "
"xmlns:ncwd=\"urn:ietf:params:xml:ns:yang:ietf-netconf-with-defaults\">"
"<foo ncwd:default=\"true\">42</foo><baz ncwd:default=\"true\">42</baz></hidden>";
st->dt = lyd_new(NULL, st->mod, "df");
assert_ptr_not_equal(st->dt, NULL);
/* select - c */
assert_ptr_not_equal((node = lyd_new(st->dt, NULL, "c")), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL_TAG), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml2);
assert_int_equal(lyd_wd_cleanup(&(st->dt), 0), 0);
free(st->xml);
st->xml = NULL;
/* select - a */
assert_ptr_not_equal(lyd_new_leaf(st->dt, NULL, "a1", "1"), NULL);
assert_int_equal(lyd_validate(&(st->dt), LYD_OPT_CONFIG), 0);
assert_int_equal(lyd_wd_add(NULL, &(st->dt), LYD_OPT_CONFIG | LYD_WD_ALL), 0);
assert_int_equal(lyd_print_mem(&(st->xml), st->dt, LYD_XML, LYP_WITHSIBLINGS), 0);
assert_ptr_not_equal(st->xml, NULL);
assert_string_equal(st->xml, xml1);
}
API struct lyd_node *
ly_ctx_info(struct ly_ctx *ctx)
{
int i;
char id[8];
const struct lys_module *mod;
struct lyd_node *root, *cont;
mod = ly_ctx_get_module(ctx, "ietf-yang-library", NULL);
if (!mod) {
mod = lyp_search_file(ctx, NULL, "ietf-yang-library", NULL);
}
if (!mod || !mod->data || strcmp(mod->data->next->name, "modules")) {
return NULL;
}
root = lyd_new(NULL, mod, "modules");
if (!root) {
return NULL;
}
for (i = 0; i < ctx->models.used; ++i) {
cont = lyd_new(root, NULL, "module");
if (!cont) {
lyd_free(root);
return NULL;
}
if (!lyd_new_leaf(cont, NULL, "name", ctx->models.list[i]->name)) {
lyd_free(root);
return NULL;
}
if (!lyd_new_leaf(cont, NULL, "revision", (ctx->models.list[i]->rev_size ?
ctx->models.list[i]->rev[0].date : ""))) {
lyd_free(root);
return NULL;
}
if (ctx->models.list[i]->uri
&& !lyd_new_leaf(cont, NULL, "schema", ctx->models.list[i]->uri)) {
lyd_free(root);
return NULL;
}
if (!lyd_new_leaf(cont, NULL, "namespace", ctx->models.list[i]->ns)) {
lyd_free(root);
return NULL;
}
if (ylib_feature(cont, ctx->models.list[i])) {
lyd_free(root);
return NULL;
}
if (ylib_deviation(cont, ctx->models.list[i], ctx)) {
lyd_free(root);
return NULL;
}
if (ctx->models.list[i]->implemented
&& !lyd_new_leaf(cont, NULL, "conformance", "implement")) {
lyd_free(root);
return NULL;
}
if (!ctx->models.list[i]->implemented
&& !lyd_new_leaf(cont, NULL, "conformance", "import")) {
lyd_free(root);
return NULL;
}
if (ylib_submodules(cont, ctx->models.list[i])) {
lyd_free(root);
return NULL;
}
}
sprintf(id, "%u", ctx->models.module_set_id);
if (!lyd_new_leaf(root, mod, "module-set-id", id)) {
lyd_free(root);
return NULL;
}
if (lyd_validate(root, 0)) {
lyd_free(root);
return NULL;
}
return root;
}
static int
ylib_deviation(struct lyd_node *parent, struct lys_module *cur_mod, struct ly_ctx *ctx)
{
int i, j, k;
struct lys_module *target_module, *mod_iter;
struct lyd_node *cont;
for (i = 0; i < ctx->models.used; ++i) {
mod_iter = ctx->models.list[i];
for (k = 0; k < mod_iter->deviation_size; ++k) {
if (mod_iter->deviation[k].target->module->type) {
target_module = ((struct lys_submodule *)mod_iter->deviation[k].target->module)->belongsto;
} else {
target_module = mod_iter->deviation[k].target->module;
}
/* we found a module deviating our module */
if (target_module == cur_mod) {
cont = lyd_new(parent, NULL, "deviation");
if (!cont) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(cont, NULL, "name", mod_iter->name)) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(cont, NULL, "revision", (mod_iter->rev_size ? mod_iter->rev[0].date : ""))) {
return EXIT_FAILURE;
}
}
}
for (j = 0; j < mod_iter->inc_size; ++j) {
for (k = 0; k < mod_iter->inc[j].submodule->deviation_size; ++k) {
if (mod_iter->inc[j].submodule->deviation[k].target->module->type) {
target_module = ((struct lys_submodule *)
mod_iter->inc[j].submodule->deviation[k].target->module)->belongsto;
} else {
target_module = mod_iter->inc[j].submodule->deviation[k].target->module;
}
/* we found a submodule deviating our module */
if (target_module == cur_mod) {
cont = lyd_new(parent, NULL, "deviation");
if (!cont) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(cont, NULL, "name", mod_iter->inc[j].submodule->name)) {
return EXIT_FAILURE;
}
if (!lyd_new_leaf(cont, NULL, "revision",
(mod_iter->inc[j].submodule->rev_size ?
mod_iter->inc[j].submodule->rev[0].date : ""))) {
return EXIT_FAILURE;
}
}
}
}
}
return EXIT_SUCCESS;
}
void
createDataTreeTestModule()
{
struct ly_ctx *ctx = NULL;
struct lyd_node *node = NULL;
struct lyd_node *n = NULL;
struct lyd_node *r = NULL;
ctx = ly_ctx_new(TEST_SCHEMA_SEARCH_DIR);
assert_non_null(ctx);
const struct lys_module *module = ly_ctx_load_module(ctx, "test-module", NULL);
assert_non_null(module);
r = lyd_new(NULL, module, "main");
assert_non_null(r);
node = lyd_new_leaf(r, module, "enum", XP_TEST_MODULE_ENUM_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "raw", XP_TEST_MODULE_RAW_VALUE);
assert_non_null(node);
/*Strict = 1, Recursive = 1, Loggin = 0*/
node = lyd_new_leaf(r, module, "options", XP_TEST_MODULE_BITS_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "dec64", XP_TEST_MODULE_DEC64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i8", XP_TEST_MODULE_INT8_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i16", XP_TEST_MODULE_INT16_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i32", XP_TEST_MODULE_INT32_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i64", XP_TEST_MODULE_INT64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui8", XP_TEST_MODULE_UINT8_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui16", XP_TEST_MODULE_UINT16_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui32", XP_TEST_MODULE_UINT32_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui64", XP_TEST_MODULE_INT64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "empty", XP_TEST_MODULE_EMPTY_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "boolean", XP_TEST_MODULE_BOOL_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "string", XP_TEST_MODULE_STRING_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "id_ref", XP_TEST_MODULE_IDREF_VALUE);
assert_non_null(node);
/* leaf -list*/
n = lyd_new_leaf(r, module, "numbers", "1");
assert_non_null(n);
n = lyd_new_leaf(r, module, "numbers", "2");
assert_non_null(n);
n = lyd_new_leaf(r, module, "numbers", "42");
assert_non_null(n);
/* list k1*/
node = lyd_new(NULL, module, "list");
assert_non_null(node);
assert_int_equal(0,lyd_insert_after(r, node));
n = lyd_new_leaf(node, module, "key", "k1");
assert_non_null(n);
n = lyd_new_leaf(node, module, "id_ref", "id_1");
assert_non_null(n);
n = lyd_new_leaf(node, module, "union", "42");
assert_non_null(n);
/* presence container*/
n = lyd_new(node, module, "wireless");
assert_non_null(n);
/* list k2*/
node = lyd_new(NULL, module, "list");
assert_non_null(node);
assert_int_equal(0, lyd_insert_after(r, node));
n = lyd_new_leaf(node, module, "key", "k2");
assert_non_null(n);
n = lyd_new_leaf(node, module, "id_ref", "id_2");
assert_non_null(n);
n = lyd_new_leaf(node, module, "union", "infinity");
assert_non_null(n);
assert_int_equal(0, lyd_validate(&r, LYD_OPT_STRICT | LYD_OPT_CONFIG));
assert_int_equal(SR_ERR_OK, sr_save_data_tree_file(TEST_MODULE_DATA_FILE_NAME, r));
lyd_free_withsiblings(r);
ly_ctx_destroy(ctx, NULL);
}
