bool mapping_contains(const node *mapping, uint8_t *scalar, size_t length)
{
PRECOND_NONNULL_ELSE_FALSE(mapping, scalar);
PRECOND_ELSE_FALSE(MAPPING == node_kind(mapping), 0 < length);
node *key = make_scalar_node(scalar, length, SCALAR_STRING);
bool result = hashtable_contains(mapping->content.mapping, key);
node_free(key);
return result;
}
bool sequence_iterate(const node *sequence, sequence_iterator iterator, void *context)
{
PRECOND_NONNULL_ELSE_FALSE(sequence, iterator);
PRECOND_ELSE_FALSE(SEQUENCE == node_kind(sequence));
context_adapter adapter = {.iterator.sequence=iterator, .context=context };
return vector_iterate(sequence->content.sequence, sequence_iterator_adpater, &adapter);
}
node *mapping_get(const node *mapping, uint8_t *scalar, size_t length)
{
PRECOND_NONNULL_ELSE_NULL(mapping, scalar);
PRECOND_ELSE_NULL(MAPPING == node_kind(mapping));
PRECOND_ELSE_NULL(0 < length);
node *key = make_scalar_node(scalar, length, SCALAR_STRING);
node *result = hashtable_get(mapping->content.mapping, key);
node_free(key);
return result;
}
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();
}
