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 (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 (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 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 (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 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 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)); }
evaluator_context *make_evaluator(const document_model *model, const jsonpath *path) { evaluator_debug("creating evaluator context"); evaluator_context *context = (evaluator_context *)calloc(1, sizeof(evaluator_context)); if(NULL == context) { evaluator_debug("uh oh! out of memory, can't allocate the evaluator context"); return NULL; } if(NULL == model) { evaluator_debug("model is null"); errno = EINVAL; context->code = ERR_MODEL_IS_NULL; return context; } if(NULL == path) { evaluator_debug("path is null"); errno = EINVAL; context->code = ERR_PATH_IS_NULL; return context; } if(NULL == model_document(model, 0)) { evaluator_debug("document is null"); errno = EINVAL; context->code = ERR_NO_DOCUMENT_IN_MODEL; return context; } if(NULL == model_document_root(model, 0)) { evaluator_debug("document root is null"); errno = EINVAL; context->code = ERR_NO_ROOT_IN_DOCUMENT; return context; } if(ABSOLUTE_PATH != path_kind(path)) { evaluator_debug("path is not absolute"); errno = EINVAL; context->code = ERR_PATH_IS_NOT_ABSOLUTE; return context; } if(0 == path_length(path)) { evaluator_debug("path is empty"); errno = EINVAL; context->code = ERR_PATH_IS_EMPTY; return context; } nodelist *list = make_nodelist(); if(NULL == list) { evaluator_debug("uh oh! out of memory, can't allocate the result nodelist"); context->code = ERR_EVALUATOR_OUT_OF_MEMORY; return context; } context->list = list; context->model = model; context->path = path; return context; }