static int test_fixed(void)
{
char bytes[] = { 0xD, 0xA, 0xD, 0xA, 0xB, 0xA, 0xB, 0xA };
avro_schema_t schema = avro_schema_fixed("msg", sizeof(bytes));
avro_datum_t datum;
avro_datum_t expected_datum;
datum = avro_givefixed(schema, bytes, sizeof(bytes), NULL);
write_read_check(schema, datum, NULL, NULL, "fixed");
test_json(datum, "\"\\r\\n\\r\\n\\u000b\\n\\u000b\\n\"");
avro_datum_decref(datum);
datum = avro_givefixed(schema, NULL, sizeof(bytes), NULL);
avro_givefixed_set(datum, bytes, sizeof(bytes), NULL);
expected_datum = avro_givefixed(schema, bytes, sizeof(bytes), NULL);
if (!avro_datum_equal(datum, expected_datum)) {
fprintf(stderr,
"Expected equal fixed instances.\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(datum);
avro_datum_decref(expected_datum);
// The following should bork if we don't copy the fixed value
// correctly (since we'll try to free a static string).
datum = avro_fixed(schema, "original", 8);
avro_fixed_set(datum, "alsothis", 8);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_record(void)
{
avro_schema_t schema = avro_schema_record("person", NULL);
avro_schema_record_field_append(schema, "name", avro_schema_string());
avro_schema_record_field_append(schema, "age", avro_schema_int());
avro_datum_t datum = avro_record(schema);
avro_datum_t name_datum, age_datum;
name_datum = avro_givestring("Joseph Campbell", NULL);
age_datum = avro_int32(83);
avro_record_set(datum, "name", name_datum);
avro_record_set(datum, "age", age_datum);
write_read_check(schema, datum, NULL, NULL, "record");
test_json(datum, "{\"name\": \"Joseph Campbell\", \"age\": 83}");
int rc;
avro_record_set_field_value(rc, datum, int32, "age", 104);
int32_t age = 0;
avro_record_get_field_value(rc, datum, int32, "age", &age);
if (age != 104) {
fprintf(stderr, "Incorrect age value\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(name_datum);
avro_datum_decref(age_datum);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_int64(void)
{
int i;
avro_schema_t writer_schema = avro_schema_long();
avro_schema_t float_schema = avro_schema_float();
avro_schema_t double_schema = avro_schema_double();
for (i = 0; i < 100; i++) {
int64_t value = rand_int64();
avro_datum_t datum = avro_int64(value);
avro_datum_t float_datum = avro_float(value);
avro_datum_t double_datum = avro_double(value);
write_read_check(writer_schema, datum, NULL, NULL, "long");
write_read_check(writer_schema, datum,
float_schema, float_datum, "long->float");
write_read_check(writer_schema, datum,
double_schema, double_datum, "long->double");
avro_datum_decref(datum);
avro_datum_decref(float_datum);
avro_datum_decref(double_datum);
}
avro_datum_t datum = avro_int64(10000);
test_json(datum, "10000");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
avro_schema_decref(float_schema);
avro_schema_decref(double_schema);
return 0;
}
static int test_bytes(void)
{
char bytes[] = { 0xDE, 0xAD, 0xBE, 0xEF };
avro_schema_t writer_schema = avro_schema_bytes();
avro_datum_t datum;
avro_datum_t expected_datum;
datum = avro_givebytes(bytes, sizeof(bytes), NULL);
write_read_check(writer_schema, datum, NULL, NULL, "bytes");
test_json(datum, "\"\\u00de\\u00ad\\u00be\\u00ef\"");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
datum = avro_givebytes(NULL, 0, NULL);
avro_givebytes_set(datum, bytes, sizeof(bytes), NULL);
expected_datum = avro_givebytes(bytes, sizeof(bytes), NULL);
if (!avro_datum_equal(datum, expected_datum)) {
fprintf(stderr,
"Expected equal bytes instances.\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(datum);
avro_datum_decref(expected_datum);
// The following should bork if we don't copy the bytes value
// correctly (since we'll try to free a static string).
datum = avro_bytes("original", 8);
avro_bytes_set(datum, "alsothis", 8);
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
return 0;
}
static int test_array(void)
{
int i, rval;
avro_schema_t schema = avro_schema_array(avro_schema_int());
avro_datum_t datum = avro_array(schema);
for (i = 0; i < 10; i++) {
avro_datum_t i32_datum = avro_int32(i);
rval = avro_array_append_datum(datum, i32_datum);
avro_datum_decref(i32_datum);
if (rval) {
exit(EXIT_FAILURE);
}
}
if (avro_array_size(datum) != 10) {
fprintf(stderr, "Unexpected array size");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "array");
test_json(datum, "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_string(void)
{
unsigned int i;
const char *strings[] = { "Four score and seven years ago",
"our father brought forth on this continent",
"a new nation", "conceived in Liberty",
"and dedicated to the proposition that all men are created equal."
};
avro_schema_t writer_schema = avro_schema_string();
for (i = 0; i < sizeof(strings) / sizeof(strings[0]); i++) {
avro_datum_t datum = avro_givestring(strings[i], NULL);
write_read_check(writer_schema, datum, NULL, NULL, "string");
avro_datum_decref(datum);
}
avro_datum_t datum = avro_givestring(strings[0], NULL);
test_json(datum, "\"Four score and seven years ago\"");
avro_datum_decref(datum);
// The following should bork if we don't copy the string value
// correctly (since we'll try to free a static string).
datum = avro_string("this should be copied");
avro_string_set(datum, "also this");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
return 0;
}
static int test_map(void)
{
avro_schema_t schema = avro_schema_map(avro_schema_long());
avro_datum_t datum = avro_map(schema);
int64_t i = 0;
char *nums[] =
{ "zero", "one", "two", "three", "four", "five", "six", NULL };
while (nums[i]) {
avro_datum_t i_datum = avro_int64(i);
avro_map_set(datum, nums[i], i_datum);
avro_datum_decref(i_datum);
i++;
}
if (avro_array_size(datum) != 7) {
fprintf(stderr, "Unexpected map size\n");
exit(EXIT_FAILURE);
}
avro_datum_t value;
const char *key;
avro_map_get_key(datum, 2, &key);
avro_map_get(datum, key, &value);
int64_t val;
avro_int64_get(value, &val);
if (val != 2) {
fprintf(stderr, "Unexpected map value 2\n");
exit(EXIT_FAILURE);
}
int index;
if (avro_map_get_index(datum, "two", &index)) {
fprintf(stderr, "Can't get index for key \"two\": %s\n",
avro_strerror());
exit(EXIT_FAILURE);
}
if (index != 2) {
fprintf(stderr, "Unexpected index for key \"two\"\n");
exit(EXIT_FAILURE);
}
if (!avro_map_get_index(datum, "foobar", &index)) {
fprintf(stderr, "Unexpected index for key \"foobar\"\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "map");
test_json(datum,
"{\"zero\": 0, \"one\": 1, \"two\": 2, \"three\": 3, "
"\"four\": 4, \"five\": 5, \"six\": 6}");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int
avro_datum_value_append(const avro_value_iface_t *iface,
void *vself, avro_value_t *child_out, size_t *new_index)
{
AVRO_UNUSED(iface);
avro_datum_t self = (avro_datum_t) vself;
check_param(EINVAL, self, "datum instance");
if (!is_avro_array(self)) {
avro_set_error("Can only append to array");
return EINVAL;
}
int rval;
avro_schema_t array_schema = avro_datum_get_schema(self);
avro_schema_t child_schema = avro_schema_array_items(array_schema);
avro_datum_t child_datum = avro_datum_from_schema(child_schema);
if (child_datum == NULL) {
return ENOMEM;
}
rval = avro_array_append_datum(self, child_datum);
avro_datum_decref(child_datum);
if (rval != 0) {
return rval;
}
if (new_index != NULL) {
*new_index = avro_array_size(self) - 1;
}
return avro_datum_as_child_value(child_out, child_datum);
}
static int test_union(void)
{
avro_schema_t schema = avro_schema_union();
avro_datum_t union_datum;
avro_datum_t datum;
avro_datum_t union_datum1;
avro_datum_t datum1;
avro_schema_union_append(schema, avro_schema_string());
avro_schema_union_append(schema, avro_schema_int());
avro_schema_union_append(schema, avro_schema_null());
datum = avro_givestring("Follow your bliss.", NULL);
union_datum = avro_union(schema, 0, datum);
if (avro_union_discriminant(union_datum) != 0) {
fprintf(stderr, "Unexpected union discriminant\n");
exit(EXIT_FAILURE);
}
if (avro_union_current_branch(union_datum) != datum) {
fprintf(stderr, "Unexpected union branch datum\n");
exit(EXIT_FAILURE);
}
union_datum1 = avro_datum_from_schema(schema);
avro_union_set_discriminant(union_datum1, 0, &datum1);
avro_givestring_set(datum1, "Follow your bliss.", NULL);
if (!avro_datum_equal(datum, datum1)) {
fprintf(stderr, "Union values should be equal\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, union_datum, NULL, NULL, "union");
test_json(union_datum, "{\"string\": \"Follow your bliss.\"}");
avro_datum_decref(datum);
avro_union_set_discriminant(union_datum, 2, &datum);
test_json(union_datum, "null");
avro_datum_decref(union_datum);
avro_datum_decref(datum);
avro_datum_decref(union_datum1);
avro_schema_decref(schema);
return 0;
}
static int test_null(void)
{
avro_schema_t schema = avro_schema_null();
avro_datum_t datum = avro_null();
write_read_check(schema, NULL, datum, "null");
avro_datum_decref(datum);
return 0;
}
static int test_double(void)
{
int i;
avro_schema_t schema = avro_schema_double();
for (i = 0; i < 100; i++) {
avro_datum_t datum = avro_double(rand_number(-1.0E10, 1.0E10));
write_read_check(schema, datum, NULL, NULL, "double");
avro_datum_decref(datum);
}
avro_datum_t datum = avro_double(2000.0);
test_json(datum, "2000.0");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_map(void)
{
avro_schema_t schema = avro_schema_map(avro_schema_long());
avro_datum_t datum = avro_map();
int64_t i = 0;
char *nums[] =
{ "zero", "one", "two", "three", "four", "five", "six", NULL };
while (nums[i]) {
avro_datum_t i_datum = avro_int64(i);
avro_map_set(datum, nums[i], i_datum);
avro_datum_decref(i_datum);
i++;
}
write_read_check(schema, NULL, datum, "map");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_fixed(void)
{
char bytes[] = { 0xD, 0xA, 0xD, 0xA, 0xB, 0xA, 0xB, 0xA };
avro_schema_t schema = avro_schema_fixed("msg", sizeof(bytes));
avro_datum_t datum = avro_wrapfixed("msg", bytes, sizeof(bytes));
write_read_check(schema, NULL, datum, "fixed");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_union(void)
{
avro_schema_t schema = avro_schema_union();
avro_datum_t union_datum;
avro_datum_t datum;
avro_schema_union_append(schema, avro_schema_string());
avro_schema_union_append(schema, avro_schema_int());
avro_schema_union_append(schema, avro_schema_null());
datum = avro_wrapstring("Follow your bliss.");
union_datum = avro_union(0, datum);
write_read_check(schema, NULL, union_datum, "union");
avro_datum_decref(union_datum);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
void
write_read_check(avro_schema_t writers_schema, avro_datum_t datum,
avro_schema_t readers_schema, avro_datum_t expected, char *type)
{
avro_datum_t datum_out;
int validate;
for (validate = 0; validate <= 1; validate++) {
reader = avro_reader_memory(buf, sizeof(buf));
writer = avro_writer_memory(buf, sizeof(buf));
if (!expected) {
expected = datum;
}
/* Validating read/write */
if (avro_write_data
(writer, validate ? writers_schema : NULL, datum)) {
fprintf(stderr, "Unable to write %s validate=%d\n %s\n",
type, validate, avro_strerror());
exit(EXIT_FAILURE);
}
int64_t size =
avro_size_data(writer, validate ? writers_schema : NULL,
datum);
if (size != avro_writer_tell(writer)) {
fprintf(stderr,
"Unable to calculate size %s validate=%d "
"(%"PRId64" != %"PRId64")\n %s\n",
type, validate, size, avro_writer_tell(writer),
avro_strerror());
exit(EXIT_FAILURE);
}
if (avro_read_data
(reader, writers_schema, readers_schema, &datum_out)) {
fprintf(stderr, "Unable to read %s validate=%d\n %s\n",
type, validate, avro_strerror());
fprintf(stderr, " %s\n", avro_strerror());
exit(EXIT_FAILURE);
}
if (!avro_datum_equal(expected, datum_out)) {
fprintf(stderr,
"Unable to encode/decode %s validate=%d\n %s\n",
type, validate, avro_strerror());
exit(EXIT_FAILURE);
}
avro_reader_dump(reader, stderr);
avro_datum_decref(datum_out);
avro_reader_free(reader);
avro_writer_free(writer);
}
}
static int test_array(void)
{
int i, rval;
avro_schema_t schema = avro_schema_array(avro_schema_int());
avro_datum_t datum = avro_array();
for (i = 0; i < 10; i++) {
avro_datum_t i32_datum = avro_int32(i);
rval = avro_array_append_datum(datum, i32_datum);
avro_datum_decref(i32_datum);
if (rval) {
exit(EXIT_FAILURE);
}
}
write_read_check(schema, NULL, datum, "array");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_bytes(void)
{
char bytes[] = { 0xDE, 0xAD, 0xBE, 0xEF };
avro_schema_t writer_schema = avro_schema_bytes();
avro_datum_t datum = avro_wrapbytes(bytes, sizeof(bytes));
write_read_check(writer_schema, NULL, datum, "bytes");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
return 0;
}
static int test_int64(void)
{
int i;
avro_schema_t writer_schema = avro_schema_long();
for (i = 0; i < 100; i++) {
avro_datum_t datum = avro_int64(rand_int64());
write_read_check(writer_schema, NULL, datum, "long");
avro_datum_decref(datum);
}
avro_schema_decref(writer_schema);
return 0;
}
static int test_boolean(void)
{
int i;
avro_schema_t schema = avro_schema_boolean();
for (i = 0; i <= 1; i++) {
avro_datum_t datum = avro_boolean(i);
write_read_check(schema, NULL, datum, "boolean");
avro_datum_decref(datum);
}
avro_schema_decref(schema);
return 0;
}
static int
avro_datum_value_add(const avro_value_iface_t *iface,
void *vself, const char *key,
avro_value_t *child, size_t *index, int *is_new)
{
AVRO_UNUSED(iface);
avro_datum_t self = (avro_datum_t) vself;
check_param(EINVAL, self, "datum instance");
if (!is_avro_map(self)) {
avro_set_error("Can only add to map");
return EINVAL;
}
int rval;
avro_datum_t child_datum;
if (avro_map_get(self, key, &child_datum) == 0) {
/* key already exists */
if (is_new != NULL) {
*is_new = 0;
}
if (index != NULL) {
int real_index;
avro_map_get_index(self, key, &real_index);
*index = real_index;
}
return avro_datum_as_child_value(child, child_datum);
}
/* key is new */
avro_schema_t map_schema = avro_datum_get_schema(self);
avro_schema_t child_schema = avro_schema_map_values(map_schema);
child_datum = avro_datum_from_schema(child_schema);
if (child_datum == NULL) {
return ENOMEM;
}
rval = avro_map_set(self, key, child_datum);
avro_datum_decref(child_datum);
if (rval != 0) {
return rval;
}
if (is_new != NULL) {
*is_new = 1;
}
if (index != NULL) {
*index = avro_map_size(self) - 1;
}
return avro_datum_as_child_value(child, child_datum);
}
static int test_float(void)
{
int i;
avro_schema_t schema = avro_schema_double();
for (i = 0; i < 100; i++) {
avro_datum_t datum = avro_double(rand_number(-1.0E10, 1.0E10));
write_read_check(schema, NULL, datum, "float");
avro_datum_decref(datum);
}
avro_schema_decref(schema);
return 0;
}
static int test_enum(void)
{
enum avro_languages {
AVRO_C,
AVRO_CPP,
AVRO_PYTHON,
AVRO_RUBY,
AVRO_JAVA
};
avro_schema_t schema = avro_schema_enum("language");
avro_datum_t datum = avro_enum(schema, AVRO_C);
avro_schema_enum_symbol_append(schema, "C");
avro_schema_enum_symbol_append(schema, "C++");
avro_schema_enum_symbol_append(schema, "Python");
avro_schema_enum_symbol_append(schema, "Ruby");
avro_schema_enum_symbol_append(schema, "Java");
if (avro_enum_get(datum) != AVRO_C) {
fprintf(stderr, "Unexpected enum value AVRO_C\n");
exit(EXIT_FAILURE);
}
if (strcmp(avro_enum_get_name(datum), "C") != 0) {
fprintf(stderr, "Unexpected enum value name C\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "enum");
test_json(datum, "\"C\"");
avro_enum_set(datum, AVRO_CPP);
if (strcmp(avro_enum_get_name(datum), "C++") != 0) {
fprintf(stderr, "Unexpected enum value name C++\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "enum");
test_json(datum, "\"C++\"");
avro_enum_set_name(datum, "Python");
if (avro_enum_get(datum) != AVRO_PYTHON) {
fprintf(stderr, "Unexpected enum value AVRO_PYTHON\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "enum");
test_json(datum, "\"Python\"");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static avro_datum_t json_t_to_avro_value(
const avro_schema_t schema, const json_t *json)
{
avro_datum_t datum = avro_datum_from_schema(schema);
if (datum == NULL) return NULL;
int rval = json_t_to_avro_value_helper(schema, json, datum);
if (rval) {
avro_datum_decref(datum);
return NULL;
}
return datum;
}
static int record_free_foreach(int i, struct avro_record_field_t *field,
void *arg)
{
AVRO_UNUSED(i);
AVRO_UNUSED(arg);
avro_str_free(field->name);
avro_schema_decref(field->type);
avro_datum_decref(field->default_value);
avro_freet(struct avro_record_field_t, field);
return ST_DELETE;
}
static int test_record(void)
{
avro_schema_t schema = avro_schema_record("person", NULL);
avro_datum_t datum = avro_record("person", NULL);
avro_datum_t name_datum, age_datum;
avro_schema_record_field_append(schema, "name", avro_schema_string());
avro_schema_record_field_append(schema, "age", avro_schema_int());
name_datum = avro_wrapstring("Joseph Campbell");
age_datum = avro_int32(83);
avro_record_set(datum, "name", name_datum);
avro_record_set(datum, "age", age_datum);
write_read_check(schema, NULL, datum, "record");
avro_datum_decref(name_datum);
avro_datum_decref(age_datum);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_boolean(void)
{
int i;
const char *expected_json[] = { "false", "true" };
avro_schema_t schema = avro_schema_boolean();
for (i = 0; i <= 1; i++) {
avro_datum_t datum = avro_boolean(i);
write_read_check(schema, datum, NULL, NULL, "boolean");
test_json(datum, expected_json[i]);
avro_datum_decref(datum);
}
avro_schema_decref(schema);
return 0;
}
static int test_float(void)
{
int i;
avro_schema_t schema = avro_schema_float();
avro_schema_t double_schema = avro_schema_double();
for (i = 0; i < 100; i++) {
float value = rand_number(-1.0E10, 1.0E10);
avro_datum_t datum = avro_float(value);
avro_datum_t double_datum = avro_double(value);
write_read_check(schema, datum, NULL, NULL, "float");
write_read_check(schema, datum,
double_schema, double_datum, "float->double");
avro_datum_decref(datum);
avro_datum_decref(double_datum);
}
avro_datum_t datum = avro_float(2000.0);
test_json(datum, "2000.0");
avro_datum_decref(datum);
avro_schema_decref(schema);
avro_schema_decref(double_schema);
return 0;
}
static int test_string(void)
{
unsigned int i;
const char *strings[] = { "Four score and seven years ago",
"our father brought forth on this continent",
"a new nation", "conceived in Liberty",
"and dedicated to the proposition that all men are created equal."
};
avro_schema_t writer_schema = avro_schema_string();
for (i = 0; i < sizeof(strings) / sizeof(strings[0]); i++) {
avro_datum_t datum = avro_wrapstring(strings[i]);
write_read_check(writer_schema, NULL, datum, "string");
avro_datum_decref(datum);
}
avro_schema_decref(writer_schema);
return 0;
}
static int read_data_datum() {
int rval;
int records_read = 0;
avro_file_reader_t reader;
avro_datum_t datum;
fprintf(stderr, "\nReading...\n");
rval = avro_file_reader(filename, &reader);
if (rval) {
fprintf(stderr, "Error using 'datum': %s\n", avro_strerror());
return -1;
}
avro_schema_t schema = avro_file_reader_get_writer_schema(reader);
while ((rval = avro_file_reader_read(reader, schema, &datum)) == 0) {
avro_datum_t val_datum;
int32_t val;
if (avro_record_get(datum, "ab", &val_datum)) {
fprintf(stderr, "Error getting value: %s\n", avro_strerror());
return -1;
}
avro_int32_get(val_datum, &val);
fprintf(stderr, "value = %d\n", val);
records_read++;
avro_datum_decref(datum);
}
avro_schema_decref(schema);
avro_file_reader_close(reader);
fprintf(stderr, "read %d records using 'datum'.\n", records_read);
if (rval != EOF) {
fprintf(stderr, "Error using 'datum': %s\n", avro_strerror());
return -1;
}
return records_read;
}
/*输出数据库中的学生信息*/
int show_student(avro_file_reader_t db,
avro_schema_t reader_schema)
{
int rval;
avro_datum_t student;
rval = avro_file_reader_read(db, reader_schema, &student);
if (rval == 0) {
int64_t i64;
int32_t i32;
char *p;
avro_datum_t sid_datum, name_datum, dept_datum,
phone_datum, age_datum;
if (avro_record_get(student, "SID", &sid_datum) == 0) {
avro_int64_get(sid_datum, &i64);
fprintf(stdout, "%"PRId64" ", i64);
}
if (avro_record_get(student, "Name", &name_datum) == 0) {
avro_string_get(name_datum, &p);
fprintf(stdout, "%12s ", p);
}
if (avro_record_get(student, "Dept", &dept_datum) == 0) {
avro_string_get(dept_datum, &p);
fprintf(stdout, "%12s ", p);
}
if (avro_record_get(student, "Phone", &phone_datum) == 0) {
avro_string_get(phone_datum, &p);
fprintf(stdout, "%12s ", p);
}
if (avro_record_get(student, "Age", &age_datum) == 0) {
avro_int32_get(age_datum, &i32);
fprintf(stdout, "%d", i32);
}
fprintf(stdout, "\n");
/*释放记录*/
avro_datum_decref(student);
}
return rval;
}
