static void
TEST_MODULE(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;
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/data%d.xml", j + 1);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_CONFIG);
if (data_files_fail[j]) {
assert_ptr_not_equal(st->node, NULL);
} else {
assert_ptr_equal(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));
}
}
}
}
}
static int
setup_f(void **state)
{
struct state *st;
const char *schemafile = TESTS_DIR"/data/files/instance.yin";
const char *datafile = TESTS_DIR"/data/files/instance.xml";
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(NULL);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
return -1;
}
/* schema */
if (!lys_parse_path(st->ctx, schemafile, LYS_IN_YIN)) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schemafile);
return -1;
}
/* data */
st->data = lyd_parse_path(st->ctx, datafile, LYD_XML, 0);
if (!st->data) {
fprintf(stderr, "Failed to load initial data file.\n");
return -1;
}
return 0;
}
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));
}
}
}
}
}
static void
test_parse_print_json(void **state)
{
struct state *st = (*state);
struct stat s;
const struct lys_node *rpc_schema;
int fd;
const char *data = TESTS_DIR"/data/files/all-data.json";
const char *rpc = TESTS_DIR"/data/files/all-rpc.json";
const char *rpcreply = TESTS_DIR"/data/files/all-rpcreply.json";
const char *act = TESTS_DIR"/data/files/all-act.json";
const char *actreply = TESTS_DIR"/data/files/all-actreply.json";
const char *notif = TESTS_DIR"/data/files/all-notif.json";
const char *innotif = TESTS_DIR"/data/files/all-innotif.json";
/* data */
fd = open(data, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, data, LYD_JSON, LYD_OPT_CONFIG);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
/* rpc */
fd = open(rpc, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->rpc_act = lyd_parse_path(st->ctx, rpc, LYD_JSON, LYD_OPT_RPC, NULL);
assert_ptr_not_equal(st->rpc_act, NULL);
lyd_print_mem(&(st->str2), st->rpc_act, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
/* rpcreply */
fd = open(rpcreply, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
rpc_schema = ly_ctx_get_node(st->ctx, NULL, "/all:rpc1");
assert_ptr_not_equal(rpc_schema, NULL);
assert_int_equal(rpc_schema->nodetype, LYS_RPC);
st->dt = lyd_parse_path(st->ctx, rpcreply, LYD_JSON, LYD_OPT_RPCREPLY, st->rpc_act, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
lyd_free(st->rpc_act);
st->rpc_act = NULL;
/* act */
fd = open(act, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->rpc_act = lyd_parse_path(st->ctx, act, LYD_JSON, LYD_OPT_RPC, NULL);
assert_ptr_not_equal(st->rpc_act, NULL);
lyd_print_mem(&(st->str2), st->rpc_act, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
/* actreply */
fd = open(actreply, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
rpc_schema = ly_ctx_get_node(st->ctx, NULL, "/all:cont1/list1/act1");
assert_ptr_not_equal(rpc_schema, NULL);
assert_int_equal(rpc_schema->nodetype, LYS_ACTION);
st->dt = lyd_parse_path(st->ctx, actreply, LYD_JSON, LYD_OPT_RPCREPLY, st->rpc_act, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT | LYP_NETCONF);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
lyd_free(st->rpc_act);
st->rpc_act = NULL;
/* notif */
fd = open(notif, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, notif, LYD_JSON, LYD_OPT_NOTIF, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
lyd_free(st->dt);
st->dt = NULL;
/* inline notif */
fd = open(innotif, O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
st->dt = lyd_parse_path(st->ctx, innotif, LYD_JSON, LYD_OPT_NOTIF, NULL);
assert_ptr_not_equal(st->dt, NULL);
lyd_print_mem(&(st->str2), st->dt, LYD_JSON, LYP_FORMAT);
assert_string_equal(st->str1, st->str2);
}
