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); }