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 (document_type)
{
reset_errno();
size_t c = model_size(model);
assert_noerr();
assert_uint_eq(1, c);
reset_errno();
Document *d = model_document(model, 0);
assert_noerr();
assert_not_null(d);
reset_errno();
Node *bogus = model_document(model, 1);
assert_errno(EINVAL);
assert_null(bogus);
reset_errno();
Node *r1 = model_document_root(model, 0);
assert_noerr();
assert_not_null(r1);
assert_node_kind(r1, MAPPING);
reset_errno();
Node *r2 = document_root(d);
assert_noerr();
assert_not_null(r2);
assert_ptr_eq(r1, r2);
}
END_TEST
START_TEST (absolute_multi_step)
{
char *expression = "$.foo.baz..yobble.thingum";
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, 5);
assert_root_step(path);
assert_single_name_step(path, 1, "foo");
assert_single_name_step(path, 2, "baz");
assert_recursive_name_step(path, 3, "yobble");
assert_single_name_step(path, 4, "thingum");
assert_no_predicate(path, 1);
assert_no_predicate(path, 2);
assert_no_predicate(path, 3);
assert_no_predicate(path, 4);
path_free(path);
parser_free(context);
}
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 (nodes)
{
reset_errno();
Node *r = model_document_root(model, 0);
assert_noerr();
assert_not_null(r);
assert_node_kind(r, MAPPING);
reset_errno();
unsigned char *n = node_name(r);
assert_noerr();
assert_null(n);
reset_errno();
size_t s = node_size(r);
assert_noerr();
assert_uint_eq(4, s);
}
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
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 (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 (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 (whitespace_predicate)
{
char *expression = "$.foo[ \t ].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_EMPTY_PREDICATE, 9);
parser_free(context);
path_free(path);
}
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 (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 (relative_path_begins_with_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_EXPECTED_NAME_CHAR, 0);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (extra_junk_in_predicate)
{
char *expression = "$.foo[ * quux].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_EXTRA_JUNK_AFTER_PREDICATE, 9);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (empty_type_test_name)
{
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_failure(expression, context, path, ERR_EXPECTED_NODE_TYPE_TEST, 6);
parser_free(context);
path_free(path);
}
END_TEST
START_TEST (bogus_predicate)
{
char *expression = "$.foo[asdf].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_UNSUPPORTED_PRED_TYPE, 6);
parser_free(context);
path_free(path);
}
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);
}
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;
}
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
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 (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 (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 (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);
}
