static void
sr_new_values_test(void **state)
{
int rc = 0;
sr_val_t *values = NULL;
rc = sr_new_values(0, &values);
assert_int_equal(SR_ERR_OK, rc);
assert_null(values);
sr_free_values(values, 0);
rc = sr_new_values(10, &values);
assert_int_equal(SR_ERR_OK, rc);
assert_non_null(values);
#ifdef USE_SR_MEM_MGMT
assert_non_null(values->_sr_mem);
assert_int_equal(1, values->_sr_mem->obj_count);
assert_true(0 < values->_sr_mem->used_total);
#else
assert_null(values->_sr_mem);
#endif
for (int i = 0; i < 10; ++i) {
#ifdef USE_SR_MEM_MGMT
if (0 < i) {
assert_ptr_equal(values[i-1]._sr_mem, values[i]._sr_mem);
}
#endif
assert_null(values[i].xpath);
assert_false(values[i].dflt);
assert_int_equal(SR_UNKNOWN_T, values[i].type);
assert_int_equal(0, values[i].data.uint64_val);
}
sr_free_values(values, 10);
}
static void
sr_val_set_xpath_test(void **state)
{
int rc = 0;
sr_val_t *value = NULL, *values = NULL;
char xpath[PATH_MAX] = { 0, };
rc = sr_new_val(NULL, &value);
assert_int_equal(SR_ERR_OK, rc);
assert_null(value->xpath);
rc = sr_val_set_xpath(value, XPATH1);
assert_int_equal(SR_ERR_OK, rc);
assert_string_equal(XPATH1, value->xpath);
rc = sr_val_set_xpath(value, XPATH2);
assert_int_equal(SR_ERR_OK, rc);
assert_string_equal(XPATH2, value->xpath);
sr_free_val(value);
rc = sr_new_values(10, &values);
assert_int_equal(SR_ERR_OK, rc);
for (int i = 0; i < 10; ++i) {
assert_null(values[i].xpath);
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE1, i, i);
rc = sr_val_set_xpath(values + i, xpath);
assert_int_equal(SR_ERR_OK, rc);
assert_string_equal(xpath, values[i].xpath);
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE2, i);
rc = sr_val_set_xpath(values + i, xpath);
assert_int_equal(SR_ERR_OK, rc);
assert_string_equal(xpath, values[i].xpath);
}
sr_free_values(values, 10);
}
int
np_trusted_cert_list_clb(const char *name, void *UNUSED(user_data), char ***UNUSED(cert_paths), int *UNUSED(cert_path_count),
char ***cert_data, int *cert_data_count)
{
int ret;
char *path;
sr_val_t *sr_certs;
size_t sr_cert_count, i;
ret = asprintf(&path, "/ietf-keystore:keystore/trusted-certificates[name='%s']/trusted-certificate/certificate",
name);
if (ret == -1) {
EMEM;
return 1;
}
if (np2srv.sr_sess.ds != SR_DS_RUNNING) {
if (np2srv_sr_session_switch_ds(np2srv.sr_sess.srs, SR_DS_RUNNING, NULL)) {
free(path);
return 1;
}
np2srv.sr_sess.ds = SR_DS_RUNNING;
}
if (np2srv_sr_get_items(np2srv.sr_sess.srs, path, &sr_certs, &sr_cert_count, NULL)) {
free(path);
return 1;
}
free(path);
*cert_data = calloc(sr_cert_count, sizeof **cert_data);
for (i = 0; i < sr_cert_count; ++i) {
(*cert_data)[i] = strdup(sr_certs[i].data.binary_val);
}
*cert_data_count = sr_cert_count;
sr_free_values(sr_certs, sr_cert_count);
return 0;
}
static void
sr_dup_values_test(void **state)
{
int rc = 0;
sr_val_t *values = NULL, *values_dup = NULL;
char xpath[PATH_MAX] = { 0, }, string_val[10] = { 0, };
/* create new array of values using the API */
rc = sr_new_values(10, &values);
assert_int_equal(SR_ERR_OK, rc);
for (int i = 0; i < 10; ++i) {
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE1, i, i);
rc = sr_val_set_xpath(values + i, xpath);
assert_int_equal(SR_ERR_OK, rc);
snprintf(string_val, 10, "%d", i);
rc = sr_val_set_str_data(values + i, SR_STRING_T, string_val);
assert_int_equal(SR_ERR_OK, rc);
}
/* duplicate */
rc = sr_dup_values(values, 10, &values_dup);
assert_int_equal(SR_ERR_OK, rc);
assert_non_null(values_dup);
#ifdef USE_SR_MEM_MGMT
assert_non_null(values_dup->_sr_mem);
assert_int_equal(1, values_dup->_sr_mem->obj_count);
assert_true(0 < values_dup->_sr_mem->used_total);
#else
assert_null(values_dup->_sr_mem);
#endif
for (int i = 0; i < 10; ++i) {
#ifdef USE_SR_MEM_MGMT
if (0 < i) {
assert_ptr_equal(values_dup[i-1]._sr_mem, values_dup[i]._sr_mem);
}
#endif
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE1, i, i);
assert_string_equal(xpath, values_dup[i].xpath);
assert_false(values_dup[i].dflt);
assert_int_equal(SR_STRING_T, values_dup[i].type);
snprintf(string_val, 10, "%d", i);
assert_string_equal(string_val, values_dup[i].data.string_val);
}
sr_free_values(values_dup, 10);
/* set dflt to true, change XPATH and data */
for (int i = 0; i < 10; ++i) {
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE2, i);
rc = sr_val_set_xpath(values + i, xpath);
assert_int_equal(SR_ERR_OK, rc);
values[i].dflt = true;
values[i].type = SR_UINT8_T;
#ifndef USE_SR_MEM_MGMT
free(values[i].data.string_val);
#endif
values[i].data.uint8_val = i;
}
/* duplicate */
rc = sr_dup_values(values, 10, &values_dup);
assert_int_equal(SR_ERR_OK, rc);
assert_non_null(values_dup);
#ifdef USE_SR_MEM_MGMT
assert_non_null(values_dup->_sr_mem);
assert_int_equal(1, values_dup->_sr_mem->obj_count);
assert_true(0 < values_dup->_sr_mem->used_total);
#else
assert_null(values_dup->_sr_mem);
#endif
for (int i = 0; i < 10; ++i) {
#ifdef USE_SR_MEM_MGMT
if (0 < i) {
assert_ptr_equal(values_dup[i-1]._sr_mem, values_dup[i]._sr_mem);
}
#endif
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE2, i);
assert_string_equal(xpath, values_dup[i].xpath);
assert_true(values_dup[i].dflt);
assert_int_equal(SR_UINT8_T, values_dup[i].type);
assert_int_equal(i, values_dup[i].data.uint8_val);
}
sr_free_values(values_dup, 10);
sr_free_values(values, 10);
/* duplicate manually created array */
values = calloc(10, sizeof *values);
assert_non_null(values);
for (int i = 0; i < 10; ++i) {
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE1, i, i);
values[i].xpath = strdup(xpath);
assert_non_null(values[i].xpath);
values[i].type = SR_STRING_T;
snprintf(string_val, 10, "%d", i);
values[i].data.string_val = strdup(string_val);
assert_non_null(values[i].data.string_val);
}
/* duplicate */
rc = sr_dup_values(values, 10, &values_dup);
assert_int_equal(SR_ERR_OK, rc);
assert_non_null(values_dup);
#ifdef USE_SR_MEM_MGMT
assert_non_null(values_dup->_sr_mem);
assert_int_equal(1, values_dup->_sr_mem->obj_count);
assert_true(0 < values_dup->_sr_mem->used_total);
#else
assert_null(values_dup->_sr_mem);
#endif
for (int i = 0; i < 10; ++i) {
#ifdef USE_SR_MEM_MGMT
if (0 < i) {
assert_ptr_equal(values_dup[i-1]._sr_mem, values_dup[i]._sr_mem);
}
#endif
snprintf(xpath, PATH_MAX, XPATH_TEMPLATE1, i, i);
assert_string_equal(xpath, values_dup[i].xpath);
assert_false(values_dup[i].dflt);
assert_int_equal(SR_STRING_T, values_dup[i].type);
snprintf(string_val, 10, "%d", i);
assert_string_equal(string_val, values_dup[i].data.string_val);
}
sr_free_values(values_dup, 10);
sr_free_values(values, 10);
}
