END_TEST
START_TEST (missing_dot)
{
char *expression = "$x";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, 2);
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_failure(expression, context, path, ERR_UNEXPECTED_VALUE, 1);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (bogus_context_length)
{
jsonpath bogus_path;
uint8_t bogus_input = 64;
parser_context context;
context.path = &bogus_path;
context.input = &bogus_input;
context.length = 0;
reset_errno();
assert_null(parse(&context));
assert_errno(EINVAL);
}
END_TEST
START_TEST (missing_recursive_step_test)
{
char *expression = "$..";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, 3);
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_failure(expression, context, path, ERR_PREMATURE_END_OF_INPUT, 3);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (eof_file_input)
{
FILE *input = tmpfile();
fseek(input, 0, SEEK_END);
reset_errno();
loader_context *loader = make_file_loader(input);
assert_not_null(loader);
assert_errno(EINVAL);
assert_loader_failure(loader, ERR_INPUT_SIZE_IS_ZERO);
fclose(input);
loader_free(loader);
}
END_TEST
START_TEST (quoted_empty_step)
{
char *expression = "$.foo.''.bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_failure(expression, context, path, ERR_EXPECTED_NAME_CHAR, 7);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (negative_subscript_predicate)
{
char *expression = "$.foo[ -3].bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
// xxx - fixme! this should be ERR_EXPECTED_INTEGER instead!
assert_parser_failure(expression, context, path, ERR_UNSUPPORTED_PRED_TYPE, 7);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (dollar_only)
{
char *expression = "$";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, 1);
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 1);
assert_root_step(path);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (zero_step_slice_predicate)
{
char *expression = "$.foo[::0].bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
// xxx - fix me! this should be ERR_STEP_CANNOT_BE_ZERO instead
// xxx - fix me! this should be position 8 instead, need a non-zero signed int parser
assert_parser_failure(expression, context, path, ERR_UNSUPPORTED_PRED_TYPE, 9);
path_free(path);
parser_free(context);
}
void tag_setup(void)
{
size_t yaml_size = strlen((char *)TAGGED_YAML);
loader_context *loader = make_string_loader(TAGGED_YAML, yaml_size);
assert_not_null(loader);
tagged_model = load(loader);
assert_not_null(tagged_model);
assert_int_eq(LOADER_SUCCESS, loader_status(loader));
reset_errno();
tagged_mapping_root = model_document_root(tagged_model, 0);
assert_noerr();
assert_not_null(tagged_mapping_root);
assert_node_kind(tagged_mapping_root, MAPPING);
assert_node_size(tagged_mapping_root, 7);
loader_free(loader);
}
END_TEST
document_model *anchor_setup(const unsigned char *yaml)
{
loader_context *loader = make_string_loader(yaml, strlen((const char *)yaml));
assert_not_null(loader);
document_model *result = load(loader);
assert_not_null(result);
assert_int_eq(LOADER_SUCCESS, loader_status(loader));
reset_errno();
node *root = model_document_root(result, 0);
assert_noerr();
assert_not_null(root);
assert_node_kind(root, MAPPING);
loader_free(loader);
return result;
}
END_TEST
START_TEST (absolute_recursive_step)
{
char *expression = "$..foo";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, 6);
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 2);
assert_root_step(path);
assert_recursive_name_step(path, 1, "foo");
assert_no_predicate(path, 0);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (iteration)
{
char *expression = "$.foo.bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
unsigned long counter = 0;
assert_true(path_iterate(path, count, &counter));
assert_uint_eq(3, counter);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (recursive_wildcard)
{
char *expression = "$.foo..*";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_recursive_wildcard_step(path, 2);
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (negative_step_slice_predicate)
{
char *expression = "$.foo[1:3:-3].bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_slice_predicate(path, 1, 1, 3, -3);
assert_single_name_step(path, 2, "bar");
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (slice_predicate_form2_with_step)
{
char *expression = "$.foo[-1::2].bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_slice_predicate(path, 1, -1, INT_FAST32_MAX, 2);
assert_single_name_step(path, 2, "bar");
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (boolean_type_test)
{
char *expression = "$.foo.boolean()";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_single_type_step(path, 2, BOOLEAN_TEST);
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (type_test_with_subscript_predicate)
{
char *expression = "$.foo.array()[0]";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_no_predicate(path, 1);
assert_single_type_step(path, 2, ARRAY_TEST);
assert_subscript_predicate(path, 2, 0);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (subscript_predicate_with_whitespace)
{
char *expression = "$.foo [\t42\r]\n.bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 3);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_subscript_predicate(path, 1, 42);
assert_single_name_step(path, 2, "bar");
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (relative_multi_step)
{
char *expression = "foo.bar..baz";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, RELATIVE_PATH, 3);
assert_single_name_step(path, 0, "foo");
assert_single_name_step(path, 1, "bar");
assert_recursive_name_step(path, 2, "baz");
assert_no_predicate(path, 0);
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
path_free(path);
parser_free(context);
}
/* @total: The sum of the data in giovec
*/
static ssize_t
_gnutls_writev(gnutls_session_t session, const giovec_t * giovec,
unsigned giovec_cnt, unsigned total)
{
int i;
bool is_dtls = IS_DTLS(session);
unsigned no_writev = 0;
gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
reset_errno(session);
if (session->internals.vec_push_func != NULL) {
if (is_dtls && giovec_cnt > 1) {
if (total > session->internals.dtls.mtu) {
no_writev = 1;
}
}
if (no_writev == 0) {
i = session->internals.vec_push_func(fd, giovec, giovec_cnt);
} else {
i = _gnutls_writev_emu(session, fd, giovec, giovec_cnt, 1);
}
} else if (session->internals.push_func != NULL) {
i = _gnutls_writev_emu(session, fd, giovec, giovec_cnt, 0);
} else
return gnutls_assert_val(GNUTLS_E_PUSH_ERROR);
if (i == -1) {
int err = get_errno(session);
_gnutls_debug_log("WRITE: %d returned from %p, errno: %d\n",
i, fd, err);
return errno_to_gerr(err, is_dtls);
}
return i;
}
BOOL delete_all_rw_fat (const VOL_PTR volume, const dword chain) {
dword t=0, prec=0;
if(!(volume) || chain <= 2 ) {
set_errno(EINVAL,"Volume errato (%s-line%d)", __FILE__, __LINE__);
return FALSE;
}
sem_wait(volume->sem_fat);
t=chain;
prec=chain;
do {
prec=t;
if(!(t=get_next_fat(volume->fat, t))) {
perror("Errore lettura ");
sem_signal(volume->sem_fat);
return FALSE;
}
if (!scrivi_fat(volume,prec, FREE_32)) {
perror("Errore scrittura");
sem_signal(volume->sem_fat);
return FALSE;
}
} while(!isLast_fat(t));
sem_signal(volume->sem_fat);
reset_errno();
return TRUE;
}
END_TEST
document_model *duplicate_setup(enum loader_duplicate_key_strategy value)
{
size_t yaml_size = strlen((char *)DUPLICATE_KEY_YAML);
loader_context *loader = make_string_loader(DUPLICATE_KEY_YAML, yaml_size);
assert_not_null(loader);
loader_set_dupe_strategy(loader, value);
document_model *result = load(loader);
assert_not_null(result);
assert_int_eq(LOADER_SUCCESS, loader_status(loader));
reset_errno();
node *root = model_document_root(result, 0);
assert_noerr();
assert_not_null(root);
assert_node_kind(root, MAPPING);
loader_free(loader);
return result;
}
END_TEST
START_TEST (quoted_multi_step)
{
char *expression = "$.foo.'happy fun ball'.bar";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 4);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_single_name_step(path, 2, "happy fun ball");
assert_single_name_step(path, 3, "bar");
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
assert_no_predicate(path, 3);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (whitespace)
{
char *expression = " $ \r\n. foo \n.\n. \t'happy fun ball' . \t string()";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 4);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_recursive_name_step(path, 2, "happy fun ball");
assert_single_type_step(path, 3, STRING_TEST);
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
assert_no_predicate(path, 3);
path_free(path);
parser_free(context);
}
END_TEST
START_TEST (wildcard_predicate)
{
char *expression = "$.store.book[*].author";
reset_errno();
parser_context *context = make_parser((uint8_t *)expression, strlen(expression));
assert_not_null(context);
assert_noerr();
jsonpath *path = parse(context);
assert_parser_success(expression, context, path, ABSOLUTE_PATH, 4);
assert_root_step(path);
assert_single_name_step(path, 1, "store");
assert_no_predicate(path, 1);
assert_single_name_step(path, 2, "book");
assert_wildcard_predicate(path, 2);
assert_single_name_step(path, 3, "author");
assert_no_predicate(path, 3);
path_free(path);
parser_free(context);
}
static ssize_t
_gnutls_stream_read(gnutls_session_t session, mbuffer_st ** bufel,
size_t size, gnutls_pull_func pull_func,
unsigned int *ms)
{
size_t left;
ssize_t i = 0;
size_t max_size = max_record_recv_size(session);
uint8_t *ptr;
gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
int ret;
struct timespec t1, t2;
unsigned int diff;
session->internals.direction = 0;
*bufel = _mbuffer_alloc_align16(MAX(max_size, size), get_total_headers(session));
if (!*bufel) {
gnutls_assert();
return GNUTLS_E_MEMORY_ERROR;
}
ptr = (*bufel)->msg.data;
left = size;
while (left > 0) {
if (ms && *ms > 0) {
ret = _gnutls_io_check_recv(session, *ms);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
gnutls_gettime(&t1);
}
reset_errno(session);
i = pull_func(fd, &ptr[size - left], left);
if (i < 0) {
int err = get_errno(session);
_gnutls_read_log
("READ: %d returned from %p, errno=%d gerrno=%d\n",
(int) i, fd, errno,
session->internals.errnum);
if (err == EAGAIN || err == EINTR) {
if (size - left > 0) {
_gnutls_read_log
("READ: returning %d bytes from %p\n",
(int) (size - left), fd);
goto finish;
}
ret = errno_to_gerr(err, 0);
goto cleanup;
} else {
gnutls_assert();
ret = GNUTLS_E_PULL_ERROR;
goto cleanup;
}
} else {
_gnutls_read_log("READ: Got %d bytes from %p\n",
(int) i, fd);
if (i == 0)
break; /* EOF */
}
left -= i;
(*bufel)->msg.size += i;
if (ms && *ms > 0 && *ms != GNUTLS_INDEFINITE_TIMEOUT) {
gnutls_gettime(&t2);
diff = timespec_sub_ms(&t2, &t1);
if (diff < *ms)
*ms -= diff;
else {
ret = gnutls_assert_val(GNUTLS_E_TIMEDOUT);
goto cleanup;
}
}
}
finish:
_gnutls_read_log("READ: read %d bytes from %p\n",
(int) (size - left), fd);
if (size - left == 0)
_mbuffer_xfree(bufel);
return (size - left);
cleanup:
_mbuffer_xfree(bufel);
return ret;
}
static ssize_t
_gnutls_dgram_read(gnutls_session_t session, mbuffer_st ** bufel,
gnutls_pull_func pull_func, unsigned int *ms)
{
ssize_t i, ret;
uint8_t *ptr;
struct timespec t1, t2;
size_t max_size, recv_size;
gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
unsigned int diff;
max_size = max_record_recv_size(session);
recv_size = max_size;
session->internals.direction = 0;
if (ms && *ms > 0) {
ret = _gnutls_io_check_recv(session, *ms);
if (ret < 0)
return gnutls_assert_val(ret);
gnutls_gettime(&t1);
}
*bufel = _mbuffer_alloc_align16(max_size, get_total_headers(session));
if (*bufel == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
ptr = (*bufel)->msg.data;
reset_errno(session);
i = pull_func(fd, ptr, recv_size);
if (i < 0) {
int err = get_errno(session);
_gnutls_read_log("READ: %d returned from %p, errno=%d\n",
(int) i, fd, err);
ret = errno_to_gerr(err, 1);
goto cleanup;
} else {
_gnutls_read_log("READ: Got %d bytes from %p\n", (int) i,
fd);
if (i == 0) {
/* If we get here, we likely have a stream socket.
* That assumption may not work on DCCP. */
gnutls_assert();
ret = 0;
goto cleanup;
}
_mbuffer_set_udata_size(*bufel, i);
}
if (ms && *ms > 0) {
gnutls_gettime(&t2);
diff = timespec_sub_ms(&t2, &t1);
if (diff < *ms)
*ms -= diff;
else {
ret = gnutls_assert_val(GNUTLS_E_TIMEDOUT);
goto cleanup;
}
}
_gnutls_read_log("READ: read %d bytes from %p\n", (int) i, fd);
return i;
cleanup:
_mbuffer_xfree(bufel);
return ret;
}
END_TEST
static void assert_model_state(loader_context *loader, document_model *model)
{
assert_int_eq(LOADER_SUCCESS, loader_status(loader));
assert_not_null(model);
assert_uint_eq(1, model_document_count(model));
reset_errno();
node *root = model_document_root(model, 0);
assert_noerr();
assert_not_null(root);
assert_node_kind(root, MAPPING);
assert_node_size(root, 5);
reset_errno();
node *one = mapping_get(root, (uint8_t *)"one", 3ul);
assert_noerr();
assert_not_null(one);
assert_node_kind(one, SEQUENCE);
assert_node_size(one, 2);
reset_errno();
node *one_0 = sequence_get(one, 0);
assert_noerr();
assert_node_kind(one_0, SCALAR);
assert_scalar_value(one_0, "foo1");
assert_scalar_kind(one_0, SCALAR_STRING);
reset_errno();
node *one_1 = sequence_get(one, 1);
assert_noerr();
assert_node_kind(one_1, SCALAR);
assert_scalar_value(one_1, "bar1");
assert_scalar_kind(one_1, SCALAR_STRING);
reset_errno();
node *two = mapping_get(root, (uint8_t *)"two", 3ul);
assert_noerr();
assert_not_null(two);
assert_node_kind(two, SCALAR);
assert_scalar_value(two, "foo2");
assert_scalar_kind(two, SCALAR_STRING);
reset_errno();
node *three = mapping_get(root, (uint8_t *)"three", 5ul);
assert_noerr();
assert_not_null(three);
assert_node_kind(three, SCALAR);
assert_scalar_value(three, "null");
assert_scalar_kind(three, SCALAR_NULL);
reset_errno();
node *four = mapping_get(root, (uint8_t *)"four", 4ul);
assert_noerr();
assert_not_null(four);
assert_node_kind(four, SEQUENCE);
reset_errno();
node *four_0 = sequence_get(four, 0);
assert_noerr();
assert_node_kind(four_0, SCALAR);
assert_scalar_value(four_0, "true");
assert_scalar_kind(four_0, SCALAR_BOOLEAN);
assert_true(scalar_boolean_is_true(four_0));
assert_false(scalar_boolean_is_false(four_0));
reset_errno();
node *four_1 = sequence_get(four, 1);
assert_noerr();
assert_node_kind(four_0, SCALAR);
assert_scalar_value(four_1, "false");
assert_scalar_kind(four_1, SCALAR_BOOLEAN);
assert_true(scalar_boolean_is_false(four_1));
assert_false(scalar_boolean_is_true(four_1));
reset_errno();
node *five = mapping_get(root, (uint8_t *)"five", 4ul);
assert_noerr();
assert_not_null(five);
assert_node_kind(five, SEQUENCE);
node *five_0 = sequence_get(five, 0);
assert_noerr();
assert_node_kind(five_0, SCALAR);
assert_scalar_value(five_0, "1.5");
assert_scalar_kind(five_0, SCALAR_REAL);
reset_errno();
node *five_1 = sequence_get(five, 1);
assert_noerr();
assert_node_kind(five_1, SCALAR);
assert_scalar_value(five_1, "42");
assert_scalar_kind(five_1, SCALAR_INTEGER);
reset_errno();
node *five_2 = sequence_get(five, 2);
assert_noerr();
assert_node_kind(five_2, SCALAR);
assert_scalar_value(five_2, "1978-07-26 10:15");
assert_scalar_kind(five_2, SCALAR_TIMESTAMP);
reset_errno();
}
END_TEST
START_TEST (sequence_type)
{
reset_errno();
Node *r = model_document_root(model, 0);
assert_noerr();
assert_not_null(r);
assert_node_kind(r, MAPPING);
reset_errno();
Node *s = mapping_get(mapping(r), (uint8_t *)"one", 3ul);
assert_noerr();
assert_not_null(s);
assert_node_kind(s, SEQUENCE);
assert_node_size(s, 2);
reset_errno();
Node *zero = sequence_get(sequence(s), 0);
assert_noerr();
assert_not_null(zero);
assert_node_kind(zero, SCALAR);
reset_errno();
Node *one = sequence_get(sequence(s), 1);
assert_noerr();
assert_not_null(one);
assert_node_kind(one, SCALAR);
reset_errno();
Scalar *x = make_scalar_node((uint8_t *)"x", 1, SCALAR_STRING);
assert_noerr();
assert_not_null(x);
reset_errno();
Scalar *y = make_scalar_node((uint8_t *)"y", 1, SCALAR_STRING);
assert_noerr();
assert_not_null(y);
reset_errno();
Scalar *z = make_scalar_node((uint8_t *)"z", 1, SCALAR_STRING);
assert_noerr();
assert_not_null(z);
reset_errno();
Sequence *xyz = make_sequence_node();
assert_noerr();
assert_not_null(xyz);
reset_errno();
sequence_add(xyz, node(x));
assert_noerr();
reset_errno();
sequence_add(xyz, node(y));
assert_noerr();
reset_errno();
sequence_add(xyz, node(z));
assert_noerr();
assert_uint_eq(3, node_size(node(xyz)));
assert_ptr_eq(node(x), sequence_get(xyz, 0));
assert_ptr_eq(node(y), sequence_get(xyz, 1));
assert_ptr_eq(node(z), sequence_get(xyz, 2));
node_free(node(xyz));
}
END_TEST
void model_setup(void)
{
reset_errno();
model = make_model();
assert_not_null(model);
assert_noerr();
reset_errno();
Mapping *root = make_mapping_node();
assert_noerr();
assert_not_null(root);
reset_errno();
Scalar *foo1 = make_scalar_node((uint8_t *)"foo1", 4, SCALAR_STRING);
assert_noerr();
assert_not_null(foo1);
reset_errno();
Scalar *one_point_five = make_scalar_node((uint8_t *)"1.5", 4, SCALAR_REAL);
assert_noerr();
assert_not_null(one_point_five);
reset_errno();
Sequence *one_value = make_sequence_node();
assert_noerr();
assert_not_null(one_value);
reset_errno();
sequence_add(one_value, node(foo1));
assert_noerr();
reset_errno();
sequence_add(one_value, node(one_point_five));
assert_noerr();
reset_errno();
mapping_put(root, (uint8_t *)"one", 3, node(one_value));
assert_noerr();
reset_errno();
Scalar *two_value = make_scalar_node((uint8_t *)"foo2", 4, SCALAR_STRING);
assert_noerr();
assert_not_null(two_value);
reset_errno();
mapping_put(root, (uint8_t *)"two", 3, node(two_value));
assert_noerr();
reset_errno();
Scalar *three_value = make_scalar_node((uint8_t *)"false", 5, SCALAR_BOOLEAN);
assert_noerr();
assert_not_null(three_value);
reset_errno();
mapping_put(root, (uint8_t *)"three", 5, node(three_value));
assert_noerr();
reset_errno();
Scalar *four_value = make_scalar_node((uint8_t *)"true", 4, SCALAR_BOOLEAN);
assert_noerr();
assert_not_null(four_value);
reset_errno();
mapping_put(root, (uint8_t *)"four", 4, node(four_value));
assert_noerr();
reset_errno();
Document *doc = make_document_node();
document_set_root(doc, node(root));
assert_noerr();
assert_not_null(doc);
reset_errno();
model_add(model, doc);
assert_noerr();
}
