END_TEST
START_TEST (scalar_boolean)
{
reset_errno();
Node *r = model_document_root(model, 0);
assert_noerr();
assert_not_null(r);
assert_node_kind(r, MAPPING);
reset_errno();
Node *three = mapping_get(mapping(r), (uint8_t *)"three", 5ul);
assert_noerr();
assert_not_null(three);
assert_node_kind(three, SCALAR);
assert_true(scalar_boolean_is_false(scalar(three)));
assert_false(scalar_boolean_is_true(scalar(three)));
reset_errno();
Node *four = mapping_get(mapping(r), (uint8_t *)"four", 4ul);
assert_noerr();
assert_not_null(four);
assert_node_kind(four, SCALAR);
assert_true(scalar_boolean_is_true(scalar(four)));
assert_false(scalar_boolean_is_false(scalar(four)));
}
END_TEST
START_TEST (null_mapping)
{
reset_errno();
assert_null(mapping_get(NULL, NULL, 0));
assert_errno(EINVAL);
}
END_TEST
START_TEST (mapping_type)
{
reset_errno();
Node *r = model_document_root(model, 0);
assert_noerr();
assert_not_null(r);
assert_node_kind(r, MAPPING);
assert_node_size(r, 4);
assert_mapping_has_key(mapping(r), "two");
assert_mapping_has_no_key(mapping(r), "bogus");
assert_not_null(mapping_get(mapping(r), (uint8_t *)"two", 3ul));
assert_null(mapping_get(mapping(r), (uint8_t *)"bogus", 5ul));
reset_errno();
Node *scalar_value = mapping_get(mapping(r), (uint8_t *)"two", 3);
assert_noerr();
assert_not_null(scalar_value);
assert_node_kind(scalar_value, SCALAR);
}
END_TEST
START_TEST (key_anchor)
{
document_model *model = anchor_setup(KEY_ANCHOR_YAML);
node *root = model_document_root(model, 0);
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 *alias1 = sequence_get(one, 1);
assert_noerr();
assert_not_null(alias1);
assert_node_kind(alias1, ALIAS);
node *one_1 = alias_target(alias1);
assert_noerr();
assert_not_null(one_1);
assert_node_kind(one_1, SCALAR);
assert_scalar_kind(one_1, SCALAR_STRING);
assert_scalar_value(one_1, "one");
reset_errno();
node *alias2 = mapping_get(root, (uint8_t *)"two", 3ul);
assert_noerr();
assert_not_null(alias2);
node *two = alias_target(alias2);
assert_node_kind(two, SCALAR);
assert_scalar_kind(two, SCALAR_STRING);
assert_scalar_value(two, "one");
}
END_TEST
START_TEST (duplicate_warn)
{
document_model *model = duplicate_setup(DUPE_WARN);
node *root = model_document_root(model, 0);
node *one = mapping_get(root, (uint8_t *)"one", 3ul);
assert_noerr();
assert_not_null(one);
assert_node_kind(one, SCALAR);
assert_scalar_value(one, "bar");
assert_scalar_kind(one, SCALAR_STRING);
model_free(model);
}
END_TEST
START_TEST (explicit_tags)
{
reset_errno();
node *name = mapping_get(tagged_mapping_root, (uint8_t *)"name", 4ul);
assert_noerr();
assert_not_null(name);
assert_node_kind(name, SCALAR);
assert_scalar_kind(name, SCALAR_STRING);
assert_node_tag(name, "tag:yaml.org,2002:str");
reset_errno();
node *exchange_rate = mapping_get(tagged_mapping_root, (uint8_t *)"exchange-rate", 13ul);
assert_noerr();
assert_not_null(exchange_rate);
assert_node_kind(exchange_rate, SCALAR);
assert_scalar_kind(exchange_rate, SCALAR_REAL);
assert_node_tag(exchange_rate, "tag:yaml.org,2002:float");
reset_errno();
node *spot_date = mapping_get(tagged_mapping_root, (uint8_t *)"spot-date", 9ul);
assert_noerr();
assert_not_null(spot_date);
assert_node_kind(spot_date, SCALAR);
assert_scalar_kind(spot_date, SCALAR_TIMESTAMP);
assert_node_tag(spot_date, "tag:yaml.org,2002:timestamp");
reset_errno();
node *settlement_date = mapping_get(tagged_mapping_root, (uint8_t *)"settlement-date", 15ul);
assert_noerr();
assert_not_null(settlement_date);
assert_node_kind(settlement_date, SCALAR);
assert_scalar_kind(settlement_date, SCALAR_TIMESTAMP);
assert_node_tag(settlement_date, "tag:yaml.org,2002:timestamp");
}
END_TEST
START_TEST (scalar_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 *)"two", 3ul);
assert_noerr();
assert_not_null(s);
assert_node_kind(s, SCALAR);
assert_scalar_value((s), "foo2");
}
END_TEST
START_TEST (sequence_iteration)
{
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);
size_t count = 0;
reset_errno();
assert_true(sequence_iterate(sequence(s), check_sequence, &count));
assert_noerr();
assert_uint_eq(2, count);
}
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));
}
