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 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;
}
int main (int argc, char **argv)
{
Lyd *lyd;
LydVoice *voice;
LydProgram *instrument;
int i;
const char *code = "saw(hz=440.0) * adsr(0.1, 0.2, 0.8, 0.50) * 2";
float scale[]={261.63, 293.66, 329.63, 349.23, 392.0,
440.0, 493.88, 523.25, 493.88, 440.0,
392.0, 349.23, 329.63, 293.66, 261.0};
lyd = lyd_new ();
if (!lyd_audio_init (lyd, "auto"))
{
lyd_free (lyd);
printf ("failed to initialize lyd (audio output)\n");
return -1;
}
instrument = lyd_compile (lyd, code);
for (i = 0; i<14;i++)
{
voice = lyd_voice_new (lyd, instrument, 0.3 * i, 0);
lyd_voice_set_param (voice, "hz", scale[i]);
lyd_voice_set_duration (voice, 0.2);
}
lyd_program_free (instrument);
sleep (5);
lyd_free (lyd);
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_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);
}
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);
}
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;
}
struct nc_server_reply *
my_getconfig_rpc_clb(struct lyd_node *rpc, struct nc_session *session)
{
struct lyd_node *data;
const struct lys_module *module;
assert_string_equal(rpc->schema->name, "get-config");
assert_ptr_equal(session, server_session);
module = ly_ctx_get_module(session->ctx, "ietf-netconf-acm", NULL);
assert_non_null(module);
data = lyd_new(NULL, module, "nacm");
assert_non_null(data);
return nc_server_reply_data(data, NC_PARAMTYPE_FREE);
}
static void
TEST_RPC_OUTPUT(void **state)
{
struct state *st = (*state);
const int schemas_fail[] = {TEST_SCHEMA_LOAD_FAIL};
const int data_files_fail[] = {TEST_DATA_FILE_LOAD_FAIL};
char buf[1024];
LYS_INFORMAT schema_format = LYS_IN_YANG;
const struct lys_module *mod;
int i, j, ret;
const int data_compare_fail[] = {TEST_DATA_COMPARE_FAIL};
const char *data_compare_string[] = {TEST_DATA_COMPARE};
const char *data_rpc_name[] = {TEST_RPC_NODE};
struct lyd_node *rpc;
for (i = 0; i < 2; ++i) {
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.%s", j + 1, (schema_format == LYS_IN_YANG ? "yang" : "yin"));
mod = lys_parse_path(st->ctx, buf, schema_format);
if (schemas_fail[j]) {
assert_ptr_equal(mod, NULL);
} else {
assert_ptr_not_equal(mod, NULL);
}
}
for (j = 0; j < TEST_DATA_FILE_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/data%d.xml", j + 1);
rpc = lyd_new(NULL, mod, data_rpc_name[j]);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_RPCREPLY, rpc, NULL);
lyd_free(rpc);
if (data_files_fail[j]) {
assert_ptr_equal(st->node, NULL);
} else {
assert_ptr_not_equal(st->node, NULL);
lyd_print_mem(&st->s, st->node, LYD_XML, LYP_WITHSIBLINGS | LYP_FORMAT | LYP_WD_ALL);
if (data_compare_fail[j]) {
assert_ptr_equal(strstr(st->s, data_compare_string[j]), NULL);
} else {
assert_ptr_not_equal(strstr(st->s, data_compare_string[j]), NULL);
}
free(st->s);
st->s = NULL;
}
lyd_free_withsiblings(st->node);
st->node = NULL;
}
if (schema_format == LYS_IN_YANG) {
/* convert the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, BUILD_DIR "/yang2yin "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yang "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1, j + 1);
ret = system(buf);
if (ret == -1) {
fprintf(stderr, "system() failed (%s).\n", strerror(errno));
fail();
} else if (WEXITSTATUS(ret) != 0) {
fprintf(stderr, "Executing command \"%s\" finished with %d.\n", buf, WEXITSTATUS(ret));
fail();
}
}
schema_format = LYS_IN_YIN;
} else {
/* remove the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1);
if (unlink(buf)) {
fprintf(stderr, "unlink() on \"%s\" failed (%s).\n", buf, strerror(errno));
}
}
}
}
}
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;
}
int main (int argc,
char **argv)
{
Lyd *lyd;
long length;
char *mididata;
FILE *file;
int i;
lyd = lyd_new ();
if (!argv[1])
{
argv[1]="/home/pippin/mid/popcorn.mid";
}
printf ("initing sound\n");
if (!lyd_audio_init (lyd, "auto", NULL))
{
lyd_free (lyd);
printf ("failed to initialize lyd (audio output)\n");
return -1;
}
file = fopen (argv[1], "r");
fseek (file, 0, SEEK_END);
length = ftell (file);
fseek (file, 0, SEEK_SET);
mididata = malloc (length);
if (fread (mididata, length, 1, file) != 1)
{
printf ("Failed to read midi data from %s\n", argv[1]);
return -1;
}
else
{
printf ("Loaded %li bytes midi data from %s\n", length, argv[1]);
fclose (file);
}
lyd_midi_load (lyd, (void*)mididata, length);
lyd_midi_set_playing (lyd, 1);
sleep (3);
lyd_midi_set_playing (lyd, 0);
sleep (2);
lyd_midi_set_playing (lyd, 1);
sleep (2);
lyd_midi_seek (lyd, 0);
lyd_midi_set_playing (lyd, 1);
for (i=0; i<40;i ++) /* speed up sequencer speed using midi meta tempo events */
{
static int tempo = 198436;
unsigned char mididata[] = {0xff, 0x51, tempo >> 16, (tempo >> 8) & 0xff, tempo & 0xff};
tempo /= 1.2;
lyd_midi_out (lyd, mididata, 5);
sleep (1);
}
lyd_midi_set_playing (lyd, 1);
sleep (40);
lyd_free (lyd);
return 0;
}
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);
}
